<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
  <channel>
    <title>Ido Veltzman :: Security Research</title>
    <link>https://idov31.github.io</link>
    <description>Security research and technical articles by Ido Veltzman.</description>
    <language>en</language>
    <lastBuildDate>Sat, 14 Mar 2026 00:00:00 GMT</lastBuildDate>
    <item>
      <title>Hypervisor Based Defense</title>
      <link>https://idov31.github.io/posts/hypervisor-based-defense</link>
      <guid isPermaLink="true">https://idov31.github.io/posts/hypervisor-based-defense</guid>
      <description>Hey there, it has been a &quot;little&quot; while since I published my last post. After scrapping and rewriting multiple ideas, I decided to write something a bit different from my previous posts. This post contains technical information, but I also wanted to share my thoughts after working on a hypervisor project for more than a year.</description>
      <pubDate>Sat, 14 Mar 2026 00:00:00 GMT</pubDate>
    </item>
    <item>
      <title>Lord Of The Ring0 — Part 6 | Conclusion</title>
      <link>https://idov31.github.io/posts/lord-of-the-ring0-p6</link>
      <guid isPermaLink="true">https://idov31.github.io/posts/lord-of-the-ring0-p6</guid>
      <description>In the last blog post, we learned about two common hooking methods (IRP Hooking and SSDT Hooking) and two different injection techniques from the kernel to the user mode for both shellcode and DLL (APC and CreateThread) with code snippets and examples from Nidhogg. In this blog post, we will write a simple driver that is capable of bypassing AMSI to demonstrate patching usermode memory from the kernel, go through credential dumping process from the kernel and finish with tampering various kernel callbacks as an example for patching kernel mode memory and last but not least - the final words and conclusion of this series. In the last blog post, we learned about process hiding and got into the internals of some of the most dangerous patching methods from the kernel.</description>
      <pubDate>Sun, 31 Mar 2024 00:00:00 GMT</pubDate>
    </item>
    <item>
      <title>Lord Of The Ring0 — Part 5 | Saruman&apos;s Manipulation</title>
      <link>https://idov31.github.io/posts/lord-of-the-ring0-p5</link>
      <guid isPermaLink="true">https://idov31.github.io/posts/lord-of-the-ring0-p5</guid>
      <description>In the last blog post, we learned about the different types of kernel callbacks and created our registry protector driver. In this blog post, I&apos;ll explain two common hooking methods (IRP Hooking and SSDT Hooking) and two different injection techniques from the kernel to the user mode for both shellcode and DLL (APC and CreateThread) with code snippets and examples from Nidhogg. While there are couple of methods to perform operations from kernel mode on user mode processes, in this part I will focus on one of the most common methods that allow it with ease - KeStackAttachProcess.</description>
      <pubDate>Wed, 19 Jul 2023 00:00:00 GMT</pubDate>
    </item>
    <item>
      <title>Lord Of The Ring0 — Part 4 | The Call Back Home</title>
      <link>https://idov31.github.io/posts/lord-of-the-ring0-p4</link>
      <guid isPermaLink="true">https://idov31.github.io/posts/lord-of-the-ring0-p4</guid>
      <description>In the last blog post, we learned some debugging concepts, understood what is IOCTL how to handle it and started to learn how to validate the data that we get from the user mode - data that cannot be trusted and a handling mistake can cause a blue screen of death. In this blog post, I&apos;ll explain the different types of callbacks and we will write another driver to protect registry keys. We started to talk about this subject in the 2nd part, so if you haven&apos;t read it yet read it here and come back as this blog is based on the knowledge you have learned in the previous ones.</description>
      <pubDate>Fri, 24 Feb 2023 00:00:00 GMT</pubDate>
    </item>
    <item>
      <title>timeout /t 31 &amp;&amp; start evil.exe</title>
      <link>https://idov31.github.io/posts/cronos-sleep-obfuscation</link>
      <guid isPermaLink="true">https://idov31.github.io/posts/cronos-sleep-obfuscation</guid>
      <description>Cronos is a new sleep obfuscation technique co-authored by idov31 and yxel. It is based on 5pider&apos;s Ekko and like it, it encrypts the process image with RC4 encryption and evades memory scanners by also changing memory regions permissions from RWX to RW back and forth. In this blog post, we will cover Cronos specifically and sleep obfuscation techniques in general and explain why we need them and the common ground of any sleep obfuscation technique.</description>
      <pubDate>Sun, 06 Nov 2022 00:00:00 GMT</pubDate>
    </item>
    <item>
      <title>Lord Of The Ring0 — Part 3 | Sailing to the Land of the User</title>
      <link>https://idov31.github.io/posts/lord-of-the-ring0-p3</link>
      <guid isPermaLink="true">https://idov31.github.io/posts/lord-of-the-ring0-p3</guid>
      <description>In the last blog post we understood what it is a callback routine, how to get basic information from user mode and for the finale created a driver that can block access to a certain process. In this blog, we will dive into two of the most important things there are when it comes to driver development: How to debug correctly, how to create good user-mode communication and what lessons I learned during the development of Nidhogg so far. This time, there will be no hands-on code writing but something more important - how to solve and understand the problems that pop up when you develop kernel drivers.</description>
      <pubDate>Sun, 30 Oct 2022 00:00:00 GMT</pubDate>
    </item>
    <item>
      <title>Lord Of The Ring0 — Part 2 | A Tale of Routines, IOCTLs and IRPs</title>
      <link>https://idov31.github.io/posts/lord-of-the-ring0-p2</link>
      <guid isPermaLink="true">https://idov31.github.io/posts/lord-of-the-ring0-p2</guid>
      <description>In the last blog post, we had an introduction to kernel development and what are the difficulties when trying to load a driver and how to bypass it. In this blog, I will write more about callbacks, how to start writing a rootkit and the difficulties I encountered during my development of Nidhogg. As I promised to bring both defensive and offensive points of view, we will create a driver that can be used for both blue and red teams - A process protector driver.</description>
      <pubDate>Thu, 04 Aug 2022 00:00:00 GMT</pubDate>
    </item>
    <item>
      <title>Lord Of The Ring0 — Part 1 | Introduction</title>
      <link>https://idov31.github.io/posts/lord-of-the-ring0-p1</link>
      <guid isPermaLink="true">https://idov31.github.io/posts/lord-of-the-ring0-p1</guid>
      <description>This blog post series isn&apos;t a thing I normally do, this will be more like a journey that I document during the development of my project Nidhogg. In this series of blogs (which I don&apos;t know how long will it be), I&apos;ll write about difficulties I encountered while developing Nidhogg and tips &amp; tricks for everyone who wants to start creating a stable kernel mode driver in 2022. This series will be about WDM type of kernel drivers, developed in VS2019.</description>
      <pubDate>Thu, 14 Jul 2022 00:00:00 GMT</pubDate>
    </item>
    <item>
      <title>Rust 101 — Let&apos;s Write Rustomware</title>
      <link>https://idov31.github.io/posts/rust101-rustomware</link>
      <guid isPermaLink="true">https://idov31.github.io/posts/rust101-rustomware</guid>
      <description>When I first heard about Rust, my first reaction was &quot;Why?&quot;. The language looked to me as a &quot;wannabe&quot; to C and I didn&apos;t understand why it is so popular. I started to read more and more about this language and began to like it.</description>
      <pubDate>Sat, 07 May 2022 00:00:00 GMT</pubDate>
    </item>
    <item>
      <title>The Good, The Bad and The Stomped Function</title>
      <link>https://idov31.github.io/posts/function-stomping</link>
      <guid isPermaLink="true">https://idov31.github.io/posts/function-stomping</guid>
      <description>When I first heard about ModuleStomping I was charmed since it wasn&apos;t like any other known injection method. Every other injection method has something in common: They use VirtualAllocEx to allocate a new space within the process, and ModuleStomping does something entirely different: Instead of allocating new space in the process, it stomps an existing module that will load the malicious DLL. After I saw that I started to think: How can I use that to make an even more evasive change that won&apos;t trigger the AV/EDR or won&apos;t be found by the injection scanner?</description>
      <pubDate>Fri, 28 Jan 2022 00:00:00 GMT</pubDate>
    </item>
    <item>
      <title>UdpInspector — Getting Active UDP Connections Without Sniffing</title>
      <link>https://idov31.github.io/posts/list-udp-connections</link>
      <guid isPermaLink="true">https://idov31.github.io/posts/list-udp-connections</guid>
      <description>Many times I&apos;ve wondered how comes that there are no tools to get active UDP connections. Of course, you can always sniff with Wireshark or any other tool of your choosing but, why netstat doesn&apos;t have it built in? That is the point that I went on a quest to investigate the matter.</description>
      <pubDate>Thu, 19 Aug 2021 00:00:00 GMT</pubDate>
    </item>
  </channel>
</rss>