Revisiting Windows 11 KTM: Lessons Learnt from New Vulnerabilities

Jael Koh (Security Researcher), Cedric Halbronn (Security Researcher · EZSecLab)

POC2025 (Power of Community) · Main Stage

Overview

The talk "Revisiting Windows 11 KTM: Lessons Learnt from New Vulnerabilities" delivered by Jael Koh and Cedric Halbronn delves into the intricate and often overlooked attack surface of the Kernel Transaction Manager (KTM) in Windows. KTM is a core kernel component designed to handle atomic operations, ensuring data integrity across various system functions, most notably the Transactional File System (TXF) and Transactional Registry (TXR). Despite its critical role, KTM has historically been under-audited, presenting a fertile ground for security researchers. This presentation highlights two novel Use-After-Free (UAF) vulnerabilities discovered by Jael Koh in Windows 11, alongside a detailed analysis of recent patches and an exploration into the use of Artificial Intelligence (AI) for vulnerability discovery within KTM.

Watch on YouTube · Slides

Visual summary for Revisiting Windows 11 KTM: Lessons Learnt from New Vulnerabilities by Jael Koh, Cedric Halbronn
Visual summary for Revisiting Windows 11 KTM: Lessons Learnt from New Vulnerabilities by Jael Koh, Cedric Halbronn

Key moments

  1. 0:00 Introduction and Kernel Transaction Manager overview
  2. 8:45 Joel's bug hunting methodology: reversing undocumented cookies
  3. 17:30 Live demo: first kernel vulnerability and system shell
  4. 22:50 Patch diffing: Resource Manager reference count mismatch bug
  5. 32:10 Introducing AI/LLM for kernel vulnerability research
  6. 50:00 AI assists Ghidra reverse engineering and structure recovery
  7. 56:00 Cost of AI research and empowering future vulnerability hunters

Revisiting Windows 11 KTM: Lessons Learnt from New Vulnerabilities

Speakers: Jael Koh (Security Researcher); Cedric Halbronn (Security Researcher, EZSecLab)

Conference: POC

YouTube: https://www.youtube.com/watch?v=G4hLUSg8MVQ

Overview

The talk "Revisiting Windows 11 KTM: Lessons Learnt from New Vulnerabilities" delivered by Jael Koh and Cedric Halbronn delves into the intricate and often overlooked attack surface of the Kernel Transaction Manager (KTM) in Windows. KTM is a core kernel component designed to handle atomic operations, ensuring data integrity across various system functions, most notably the Transactional File System (TXF) and Transactional Registry (TXR). Despite its critical role, KTM has historically been under-audited, presenting a fertile ground for security researchers. This presentation highlights two novel Use-After-Free (UAF) vulnerabilities discovered by Jael Koh in Windows 11, alongside a detailed analysis of recent patches and an exploration into the use of Artificial Intelligence (AI) for vulnerability discovery within KTM.

The speakers emphasize the dual benefit of their research: providing actionable advice for aspiring security researchers to find their first vulnerabilities and break into the industry, while also equipping advanced researchers with a deeper understanding of KTM to uncover further weaknesses. Cedric Halbronn, a seasoned security researcher from EZSecLab, shares his methodology for leveraging AI tools like OpenAI's Codex in conjunction with Ghidra and Windbg to automate aspects of vulnerability hunting. The talk serves as a testament to the persistence required in vulnerability research, showcasing both successful exploits and the challenging, often frustrating, path to discovery.

Ultimately, this talk underscores that KTM remains a complex, yet accessible, target for kernel-level vulnerabilities. The discovered UAFs demonstrate how subtle race conditions in object lifecycle management can lead to critical security flaws, potentially allowing for local privilege escalation. The innovative application of AI in the research process signals a future direction for vulnerability discovery, where automated tools augment human expertise in navigating vast and complex codebases like the Windows kernel.

Background

▶ Watch: Introduction and Kernel Transaction Manager overview (0:00)

The Kernel Transaction Manager (KTM) was introduced in Windows Vista in 2007 as a foundational component for ensuring atomicity in system operations. Its primary function is to manage transactions, which are sequences of operations treated as a single, indivisible unit. If any part of the transaction fails, the entire operation is rolled back to its initial state, preventing data corruption. KTM's architecture involves several key objects: Objects (OB) for tracking kernel objects, a Transaction Manager (TXM) for logging and recovery, Resource Managers (RM) to manage transactional resources like files or registry keys, and Enlistments (EN) which link transactions to specific resource managers. This intricate object model is exposed to user mode via Win32 APIs, allowing applications to interact with KTM's transactional capabilities.

Historically, KTM has been a source of interesting, albeit often underexploited, vulnerabilities. Project Zero, for instance, identified several bugs in its syscalls shortly after its release. A notable Use-After-Free (UAF) vulnerability in 2018 (not explicitly detailed in this talk but referenced as "Bug 1") was exploited in the wild, demonstrating the real-world impact of KTM flaws. This specific bug involved a race condition during the recovery of a resource manager, where an enlistment could be freed and then reused due to improper state checking during linked list traversal. In 2019, researchers also explored using KTM transactions to evade antivirus detection by manipulating the state of files. More recently, in 2023, additional bugs were found, though without full exploitation chains being publicly disclosed.

The research presented by Jael Koh and Cedric Halbronn builds upon this legacy. Cedric's prior work on exploiting the 2018 UAF, including a training module on Windows kernel exploitation, directly inspired Jael's subsequent discoveries. Jael, having taken Cedric's course, applied the learned methodologies to KTM, leading to the identification of two new UAFs in Windows 11. This continuous discovery of vulnerabilities highlights that despite its age, KTM remains a complex and fertile ground for security research, often due to its nuanced object lifecycle management and the potential for subtle race conditions in its intricate internal workings. The talk also acknowledges recent (Summer 2024) changes to KTM, hinting at ongoing development and the introduction of new potential attack surfaces.

Key Findings

▶ Watch: Live demo: first kernel vulnerability and system shell (17:30)

The talk presents several key findings, ranging from novel vulnerabilities discovered by Jael Koh to a detailed analysis of recently patched bugs and an exploration of AI-assisted vulnerability research.

1. Two New Use-After-Free (UAF) Vulnerabilities in Windows 11 KTM (Discovered by Jael Koh):

Jael Koh's primary contribution is the discovery of two distinct UAF vulnerabilities in the Windows 11 Kernel Transaction Manager. The talk focuses on detailing the first of these:

  • UAF involving Cookie 5 (Protocol Address Information Object) and Cookie 6 (Propagate Request Object): This vulnerability arises from a race condition within the TmpDispatchPropagateRequests function. Specifically, after a promoting protocol (a special type of protocol object identified by a static GUID) is located, but before its associated resource manager field is read, the promoting protocol object can be freed. By reclaiming the freed memory with user-controlled data (e.g., a named pipe), the resource manager field can be poisoned to point to an arbitrary user-mode address. This ultimately yields an arbitrary write zero primitive, which can be used to null out critical kernel pointers, such as the PreviousMode field of an ETHREAD structure, leading to Local Privilege Escalation (LPE). This exploit requires specific conditions: it must be run on a clustered disk and within the security context of the KTM RM service.

2. Analysis of Recently Patched KTM Vulnerabilities (Microsoft's Fixes):

Jael also performed patch diffing on recent Windows updates to identify and analyze other KTM vulnerabilities addressed by Microsoft. While specific CVEs were not available or confirmed, the analysis covered:

  • UAF in TmpInitializeEnlistment: A patch added reference and dereference calls to the transaction manager. Jael expressed confusion regarding the exact root cause, noting that the patch's logic didn't align with obvious UAF scenarios involving transaction or resource managers.
  • Resource Manager Ref Mismatch: Identified by Microsoft, this bug was patched by adding a reference to the resource manager before ObInsertObject and a dereference if ObInsertObject fails. Jael initially suspected a memory leak but discovered it was a reference by zero vulnerability. A race condition allows a second thread to open a handle to a resource manager that has been dereferenced to zero, leading to a system crash when ObReferenceObjectByPointer attempts to reference an object with a zero reference count.
  • Enlistment Security Init: A patch introduced a 0x100 flag for enlistments after ObInsertObject and checked for this flag in TmpLockTransaction. The intent was likely to prevent operations on uninitialized enlistments, but the precise exploit path remained unclear to Jael.
  • MSDTC Integer Overflow (Information Disclosure): This vulnerability, found outside of KTM but related to its ecosystem (MSDTC), involved an integer overflow in GetNextVarItemWithinBounds. While no Proof of Concept (PoC) was developed to reach the function, it was theorized to allow for information disclosure (leaking data/pointers within MSDTC) and could potentially be chained with other bugs for code execution.

3. AI-Assisted Vulnerability Research (Cedric Halbronn's Methodology):

Cedric Halbronn showcased a novel approach to vulnerability research using AI/Large Language Models (LLMs).

  • Methodology Focus: The research emphasized the process of using an AI agent (Codex with GPT) integrated with reverse engineering tools (Ghidra via MCP server, Windbg via RedSync) to analyze kernel code.
  • Training and Validation: The LLM was trained on previous KTM vulnerability writeups and PoCs, and its understanding was validated against known vulnerable code.
  • Bug Hunting Attempts:
  • The LLM attempted to find bugs in TmpLockTransaction, identifying a potential race condition in linked list traversal without an explicit mutex. However, manual debugging revealed that a caller function (NT commit transaction) did hold the mutex, negating the vulnerability.
  • A promising lead was found in the Transactional File System (TXF), specifically in GetTransactedVersion. The LLM identified a potential UAF where the transaction mutex was not acquired while copying context information, leading to a race condition. Despite generating a PoC and successfully reaching the vulnerable function, the inability to create necessary "mini-versions" (snapshots) via a "not supported" IOCTL prevented the full exploitation and confirmation of the bug.
  • Cost-Effectiveness: The AI research, despite not yielding a new confirmed bug, was remarkably cost-effective, totaling only $25 and using 120 million tokens across 5500 requests.

These findings collectively highlight the persistent vulnerability of complex kernel components like KTM, the critical importance of meticulous object lifecycle management, and the emerging role of AI in augmenting traditional reverse engineering and vulnerability discovery efforts.

Technical Deep Dive

▶ Watch: Patch diffing: Resource Manager reference count mismatch bug (22:50)

The talk provides a deep dive into the internal workings of the Kernel Transaction Manager (KTM) and the technical details behind the discovered vulnerabilities, particularly Jael Koh's first UAF.

KTM Object Model

KTM manages several kernel objects, each represented by specific structures:

  • KTRANSACTION_MANAGER: The core object for managing transactions.
  • KRESOURCEMANAGER: Represents a resource manager, responsible for managing transactional operations on specific resources (e.g., files, registry keys).
  • KTRANSACTION: An object representing a single transaction, encapsulating a set of atomic operations.
  • KENLISTMENT: Links a KTRANSACTION to a KRESOURCEMANAGER, representing a specific operation within a transaction.

These objects are interconnected via linked lists. Crucially, a KTRANSACTION can have a linked list of associated KENLISTMENT objects, and a KRESOURCEMANAGER also maintains a linked list of enlistments. This intricate web of interconnected objects and their lifecycle management is a common source of vulnerabilities.

Jael Koh's First UAF: Cookie 5/6 Race Condition

Jael's initial breakthrough came from exploring undocumented KTM objects, specifically Cookie 5 and Cookie 6, which he discovered after observing an undocumented table of object cookies.

  • Cookie 5 Object (Protocol Address Information Object): This object is created by calling NtRegisterProtocolAddressInformationExt on a resource manager handle. It's then added to the resource manager's protocol list head linked list. Key fields include:
  • Protocol GUID: A unique identifier.
  • Resource Manager: A pointer back to the KRESOURCEMANAGER that registered it.

A special variant, the promoting protocol, is identified by a specific static GUID.

  • Cookie 6 Object (Propagate Request Object): This object is allocated by TmpAllocatePropagateRequest during transaction promotion, a process where a transaction can be "promoted" to a distributed transaction. It contains one important field:
  • Resource Manager: This pointer is initially NULL.

The vulnerability lies within the TmpDispatchPropagateRequests function. This function's workflow is:

  1. Identify the promoting protocol (Cookie 5 object with the special GUID).
  2. Set the resource manager field of the propagate request (Cookie 6 object) to the resource manager field of the promoting protocol.

The race condition occurs precisely between steps 1 and 2. After the promoting protocol has been identified, but before its resource manager field is read, the promoting protocol object can be freed.

  • How to Free the Promoting Protocol: The TmpCloseResourceManager function, which is the close procedure for a resource manager object, iterates through the protocol list head and calls TmpDeleteProtocol on each entry, effectively freeing the promoting protocol. By closing the resource manager associated with the promoting protocol at the opportune moment, an attacker can free the promoting protocol object.
  • Memory Reclamation: Once freed, the memory backing the promoting protocol object can be reclaimed with attacker-controlled data. Jael successfully used a named pipe to achieve this. By carefully crafting the named pipe's data, the resource manager field of the reallocated (poisoned) promoting protocol can be made to point to an arbitrary user-mode address.
  • Arbitrary Write Zero Primitive: When TmpDispatchPropagateRequests subsequently reads the poisoned resource manager field and attempts to use it in functions like KeWaitForSingleObject, KeReleaseMutex, or TmpSetNotificationResourceManager, it will write a zero to the user-mode address specified by the attacker. This constitutes an arbitrary write zero primitive.
  • Privilege Escalation: An arbitrary write zero primitive is highly potent. Jael demonstrated its use to nullify the PreviousMode field of an ETHREAD structure. PreviousMode typically indicates whether a thread is executing in kernel mode (0) or user mode (1). By setting it to 0, subsequent kernel checks that rely on PreviousMode to enforce security boundaries (e.g., when accessing kernel objects) can be bypassed, leading to Local Privilege Escalation (LPE) to a System shell.

Constraints for Exploitation: The vulnerability required two specific conditions:

  1. The exploit must run on a clustered disk.
  2. Only the KTM RM service can register a promoting protocol. This second constraint means the vulnerability effectively requires high privileges to begin with, making it a privilege escalation from an already privileged context, rather than from a low-privileged user.

Cedric Halbronn's AI-Assisted Research Methodology

Cedric presented an innovative approach using AI for vulnerability research, focusing on the methodology rather than confirmed new bugs.

  • Tooling:
  • Codex (OpenAI Agent): A reasoning agent powered by GPT, used for asking questions, planning research steps, and analyzing code.
  • Ghidra with MCP Server: Ghidra's decompiler was exposed to Codex via a Machine Code Platform (MCP) server, allowing the AI to query decompiled code, analyze structures, and even suggest variable renames and type changes.
  • Windbg with RedSync: Used for live debugging in a target VM, synchronized with Ghidra to provide context.
  • Training the Model: The LLM was "trained" by feeding it historical KTM blog posts (Cedric's 2019 series) and Jael's detailed bug reports (2024). This established a baseline understanding of KTM's architecture and common vulnerability patterns (e.g., UAFs, race conditions in linked lists). The LLM's understanding was validated by asking it to identify known vulnerabilities in a deliberately vulnerable TM.SYS driver.
  • Bug Hunting Process:
  • Initial Scan (TmpInitializeEnlistment): An early attempt to find a known patched bug in TmpInitializeEnlistment using the LLM was unsuccessful, highlighting limitations.
  • Analyzing TmpLockTransaction: The LLM identified a potential race condition when traversing a linked list of enlistments without an apparent mutex. However, manual debugging and subsequent AI queries revealed that a caller function (NT commit transaction) did acquire the transaction mutex, negating the race condition. This demonstrated the crucial interplay between AI suggestions and human validation.
  • Exploring TXF (GetTransactedVersion): The LLM then focused on the Transactional File System (TXF), identifying a potential UAF in GetTransactedVersion. The theory was that the function might copy transaction context information to a resource manager context without holding the transaction mutex, creating a race window.
  • PoC Generation: The AI rapidly generated a PoC to trigger GetTransactedVersion. Manual fixes were needed (e.g., using CreateFileTransacted and CommitTransactionAsync instead of CommitTransaction) to reach the target function.
  • Reverse Engineering Assistance: The LLM was instrumental in reverse engineering undocumented TXF structures. It analyzed decompiled code to generate header files, rename variables, and correct data types in Ghidra, significantly accelerating the understanding of complex kernel structures (main file object structure, FS context, FS context 2).
  • Stumbling Block: To trigger the race condition, multiple "mini-versions" (snapshots) of the file were needed. The LLM suggested using a CreateMiniVersion IOCTL, but during debugging, this IOCTL consistently returned "request not supported," preventing the necessary state from being achieved and thus confirming the bug.

This deep dive illustrates the complexity of kernel vulnerability research, the subtle nature of race conditions, and the potential for AI to act as a powerful, albeit still imperfect, assistant in navigating these challenges.

Demo / Proof of Concept

▶ Watch: AI assists Ghidra reverse engineering and structure recovery (50:00)

The talk featured a compelling live demonstration of Jael Koh's discovered Use-After-Free (UAF) vulnerability in the Kernel Transaction Manager (KTM), leading to Local Privilege Escalation (LPE) to a system shell. While Cedric Halbronn's AI-assisted research also involved the generation and debugging of Proof of Concepts (PoCs), his efforts did not result in a confirmed new vulnerability or a full exploitation demo.

Jael Koh's LPE Demo (Cookie 5/6 UAF)

Jael's demo focused on the UAF involving the protocol address information object (Cookie 5) and the propagate request object (Cookie 6). To overcome the specific constraints of this vulnerability, which required a clustered disk and execution within the security context of the KTM RM service, Jael employed runtime patching using Windbg commands.

Demo Setup:

  1. Emulating a Clustered Disk: A Windbg command was used to patch a specific function, making the system behave as if it were operating on a clustered disk, thus satisfying the first constraint.
  2. Emulating KTM RM Service Context: Another Windbg command patched a different function to simulate the exploit running within the high-privileged context of the KTM RM service, addressing the second constraint.

Exploitation Steps (Conceptual):

The PoC would orchestrate the following:

  1. Register a promoting protocol (Cookie 5 object) with a resource manager.
  2. Initiate a transaction promotion that triggers the TmpDispatchPropagateRequests function.
  3. In a race condition, after TmpDispatchPropagateRequests identifies the promoting protocol but before it reads its resource manager field, close the resource manager. This action, via TmpCloseResourceManager and TmpDeleteProtocol, frees the promoting protocol object.
  4. Reclaim the freed memory using a named pipe, carefully crafting the pipe's data to poison the resource manager field of the reallocated promoting protocol to point to a user-mode address.
  5. When TmpDispatchPropagateRequests proceeds to use the poisoned resource manager field (e.g., in KeWaitForSingleObject), it will perform an arbitrary write of zero to the attacker-controlled user-mode address.
  6. This arbitrary write zero primitive is then used to nullify the PreviousMode field of the current thread's ETHREAD structure, bypassing privilege checks.

Demo Outcome:

Upon executing the PoC, the system initially encountered a "thread issue" and did not immediately yield a shell. However, after a second attempt, the exploit successfully provided a system shell, visually confirming the achievement of local privilege escalation. This live demonstration provided concrete proof of the UAF's exploitability and its potential for severe security impact.

Cedric's AI PoC Generation and Debugging

While Cedric's AI research did not culminate in a confirmed new exploit, the methodology heavily relied on PoC generation and debugging:

  • TmpLockTransaction PoC: The AI generated a PoC to trigger the TmpLockTransaction function, which was initially suspected of having a race condition. Debugging revealed that the transaction mutex was held by a caller, preventing the race.
  • TXF GetTransactedVersion PoC: For the potential TXF UAF, the AI generated a PoC to hit the GetTransactedVersion function. Cedric manually fixed the IOCTL to correctly call the target function. The PoC involved creating a file, opening it in a transacted context, and performing file operations like writing and flushing buffers before triggering the vulnerable IOCTL.
  • Debugging Challenges: A key challenge was creating multiple "mini-versions" of the file, which the AI suggested via a CreateMiniVersion IOCTL. However, this IOCTL consistently returned "request not supported" during debugging, preventing the necessary state for the race condition from being achieved. This illustrates that even with AI-generated PoCs, manual debugging and a deep understanding of the underlying system are still crucial for successful exploitation and bug confirmation.

The demonstrations and PoC efforts underscored the practical application of the research, confirming the severity of Jael's findings and showcasing the potential, and current limitations, of AI in kernel vulnerability hunting.

Defensive Implications

▶ Watch: Cost of AI research and empowering future vulnerability hunters (56:00)

The detailed exploration of KTM vulnerabilities in this talk offers several critical defensive implications for system administrators, security engineers, and developers:

  1. KTM Remains a High-Value, Under-Audited Attack Surface: The consistent discovery of critical vulnerabilities (like UAFs) in KTM, even after years of its existence, highlights that it is a complex, yet under-audited, component of the Windows kernel. Defenders should be aware that this area is still being actively researched by attackers and researchers alike.
  2. Focus on Object Lifecycle and Race Conditions: The presented UAFs are classic examples of flaws arising from improper object lifecycle management and race conditions. Developers of kernel components, especially those dealing with complex object graphs and multi-threaded access, must meticulously ensure correct reference counting, mutex acquisition, and state management across all possible execution paths. Code review and static analysis tools should prioritize identifying these patterns.
  3. Patch Management is Crucial: The analysis of several patched vulnerabilities, even if their exact exploitation was unclear, underscores the importance of prompt and consistent application of security updates. Microsoft is actively addressing KTM-related issues, and keeping systems up-to-date is a fundamental defensive measure.
  4. Least Privilege Principle for Services: The constraint that Jael's first UAF required execution within the KTM RM service context emphasizes the importance of the principle of least privilege. Services should run with the minimum necessary permissions to perform their functions. While this vulnerability still allows escalation from a privileged service, it doesn't allow a direct jump from a low-privileged user, demonstrating the value of defense-in-depth.
  5. Enhanced Monitoring for Kernel Crashes: The "reference by zero vulnerability" (Resource Manager Ref Mismatch) leading to a system crash highlights that even non-exploitability (e.g., memory leaks or crashes) can be indicative of underlying security flaws. Robust crash dump analysis and monitoring for kernel panics (BSODs) can be early indicators of potential vulnerabilities being triggered.
  6. Reviewing Transactional File System (TXF) and Transactional Registry (TXR) Interactions: Given the AI-assisted research's focus on TXF and its potential UAF, defenders should be particularly vigilant about applications that extensively use transactional file or registry operations. These components, built atop KTM, inherit its complexity and potential for subtle bugs.
  7. Consider AI in Defensive Code Analysis: While the talk focused on AI for offensive research, the methodology of using LLMs to analyze decompiled code, identify structures, and understand complex functions (as shown with TXF) has clear defensive applications. Security teams could leverage similar AI tools to audit their own kernel modules or critical third-party drivers for similar classes of bugs.
  8. The "Mental Game" Applies to Defense Too: Jael's emphasis on persistence and dealing with failure in vulnerability research is also relevant for defenders. Understanding complex attack surfaces and identifying subtle flaws requires continuous learning, experimentation, and resilience in the face of initial setbacks.

In summary, the talk serves as a stark reminder that fundamental security principles like robust object management, secure coding practices, and diligent patch application remain paramount, especially in the face of increasingly sophisticated attack techniques and the emerging role of AI in security research.

Key Takeaways

  • KTM is a Rich Source of Kernel Vulnerabilities: The Kernel Transaction Manager (KTM) in Windows, despite its age, remains a complex and under-audited component, consistently yielding critical vulnerabilities like Use-After-Free (UAF) and race conditions due to its intricate object lifecycle and multi-threaded operations.
  • Deep Code Understanding Leads to Discovery: Rather than directly hunting for bugs, a deep, curious understanding of an undocumented codebase, as demonstrated by Jael Koh's exploration of Cookie 5 and Cookie 6 objects, often leads to the discovery of vulnerabilities. "Do not find bugs; bugs will find you."
  • UAF Exploitation via Memory Reclamation is Key: The successful exploitation of UAFs in the kernel often relies on reclaiming freed memory with attacker-controlled data (e.g., using named pipes) to corrupt critical pointers, leading to potent primitives like arbitrary write zero for Local Privilege Escalation (LPE).
  • AI/LLMs Augment Vulnerability Research: Large Language Models (LLMs) integrated with reverse engineering tools (like Ghidra and Windbg) show significant promise in accelerating code analysis, structure reverse engineering, and PoC generation. However, human expertise remains crucial for validating AI's findings, debugging PoCs, and overcoming technical roadblocks.
  • Persistence is Paramount: Vulnerability research is a challenging "mental game" characterized by numerous failures and rejections. Jael Koh's journey, including multiple prior unsuccessful attempts at reversing KTM, highlights that persistence and learning from failures are essential for eventual success.
  • Patch Diffing Reveals Attack Vectors: Analyzing patches released by vendors, even when the full vulnerability details are not public, is a valuable technique for understanding the types of flaws being addressed and can guide further research into related attack surfaces.

About the Speaker(s)

Jael Koh is a security researcher who gained significant recognition for his work on Windows kernel vulnerabilities. His interest in kernel exploitation was sparked after taking a training course on the subject led by Cedric Halbronn. This foundational knowledge, combined with his diligent curiosity, directly led to his discovery of two novel Use-After-Free vulnerabilities in the Windows 11 Kernel Transaction Manager. Jael's journey, as shared in the talk, emphasizes the importance of deep code understanding and persistence for aspiring researchers seeking to break into the security industry.

Cedric Halbronn is a seasoned security researcher affiliated with EZSecLab. He is known for his expertise in Windows kernel exploitation and has previously delivered training on the subject. Cedric played a pivotal role in Jael's development, having taught the KTM course that inspired Jael's research. In this talk, Cedric also showcased his innovative work in applying Artificial Intelligence and Large Language Models to vulnerability research, demonstrating a forward-thinking approach to automating and augmenting traditional reverse engineering and bug hunting methodologies.

Reviews

Dr. Zero (Offensive Security Researcher) — SOLID

Solid Windows kernel research with a confirmed UAF-to-LPE chain in KTM, plus an honest exploration of AI-assisted vuln hunting that actually shows the methodology's current limitations. Not groundbreaking technique, but real work with a live demo and practical takeaways for both newcomers and experienced kernel researchers.

Heather Calloway (CISO) — SOLID

Solid kernel exploitation research on an underexplored Windows attack surface. The UAF discovery and exploitation methodology are technically sound, but the constraints—clustered disk, KTM RM service context—limit real-world applicability. The AI-assisted research angle is interesting but didn't yield confirmed bugs.

→ Top-rated talks at POC2025 (Power of Community)

All talks from POC2025 (Power of Community)