Reflecting Your Authentication: Look in the Mirror - It’s You
Andrea Pierini (Senior Security Consultant · Semperis)
SEC-T 2026 · Day 2 · Main hall
Overview
In this insightful SEC-T presentation, Andrea Pierini, a Senior Security Consultant at Semperis, delved into the persistent and evolving landscape of Windows authentication reflection attacks. Despite being a long-standing class of vulnerabilities, Pierini demonstrated that these techniques are far from obsolete, continually offering new avenues for attackers to achieve significant compromise, ranging from local privilege escalation to full domain takeover. His talk highlighted novel methods for coercing authentication, circumventing modern protections, and exploiting critical infrastructure like Active Directory Certificate Services (ADCS) and Windows Admin Center (WAC).

Key moments
- 0:00 Introduction: Windows authentication reflection overview
- 2:00 Understanding authentication reflection: concept and impact
- 8:00 Remote Kerberos reflection: ADCS Potato domain compromise
- 13:10 Demo: Ghost SPN Kerberos reflection for system access
- 17:00 Critical NLM local authentication reflection: Domain takeover
- 20:00 Demo: NLM reflection bypasses LDAP channel binding
- 24:00 Windows Admin Center: Full domain compromise vulnerability
- 33:00 Conclusion: Countermeasures and future attack vectors
Reflecting Your Authentication: Look in the Mirror - It’s You
Speakers: Andrea Pierini, Senior Security Consultant, Semperis
Conference: SEC-T
YouTube: https://www.youtube.com/watch?v=DqSuJky8_Q0
Overview
In this insightful SEC-T presentation, Andrea Pierini, a Senior Security Consultant at Semperis, delved into the persistent and evolving landscape of Windows authentication reflection attacks. Despite being a long-standing class of vulnerabilities, Pierini demonstrated that these techniques are far from obsolete, continually offering new avenues for attackers to achieve significant compromise, ranging from local privilege escalation to full domain takeover. His talk highlighted novel methods for coercing authentication, circumventing modern protections, and exploiting critical infrastructure like Active Directory Certificate Services (ADCS) and Windows Admin Center (WAC).
Pierini's research underscores the critical importance of understanding subtle nuances in Windows authentication protocols and their implementations. He unveiled several zero-day vulnerabilities and bypasses, emphasizing that even seemingly robust mitigations can be circumvented with creative approaches. The presentation served as a stark reminder that security professionals must remain vigilant against these "loopback" authentication attacks, which leverage a victim machine's trust in itself to grant an attacker elevated privileges without ever needing credentials.
The core of the talk focused on practical examples, revealing how a low-privileged user could coerce a target machine into authenticating to an attacker-controlled endpoint and then reflect that authentication back to a service on the victim machine itself. This technique, often leveraging the victim's own computer account, can grant SYSTEM privileges on the local machine or, in more severe cases, lead to the compromise of an entire Active Directory domain. Pierini's work provides invaluable insights for both offensive and defensive security practitioners dealing with complex Windows environments.
Background
▶ Watch: Introduction: Windows authentication reflection overview (0:00)
Authentication reflection attacks exploit a fundamental trust mechanism in Windows where a machine authenticates to itself. The concept is deceptively simple: an attacker intercepts an authentication request from a victim and reflects it back to a service on the same victim machine. The victim, believing it's a legitimate internal authentication, grants access, often with elevated privileges, to the attacker who initiated the reflection. This allows for privilege escalation without requiring any knowledge of the victim's credentials.
Historically, authentication reflection has been a potent attack vector. A prominent example is the MS08-068 vulnerability from 2008, where an attacker could trick a remote machine into reflecting its own SMB authentication against its SMB service, achieving SYSTEM privileges. While Microsoft has implemented mitigations since Windows Server 2016 and Windows 10, preventing direct reflection to the same host using the same or even a different protocol in many scenarios, Pierini's research demonstrates that these protections are not absolute.
The talk highlighted the differences between NTLM and Kerberos in the context of reflection. While NTLM has seen more focus on local reflection (e.g., Local Potato), Kerberos is often considered more vulnerable to reflection due to its lack of a universal reflection detection mechanism. However, Kerberos reflection typically requires control over the Service Principal Name (SPN). Pierini introduced a crucial technique to overcome this: the Red Marshall Target Info (CMTI) trick. This involves crafting a special SPN format that, when processed by the Windows Security Provider Interface, allows an attacker to effectively force a "fake local authentication" from a remote machine, making it believe the authentication is originating from itself. This trick is key to many of the advanced reflection attacks discussed.
Key Findings
▶ Watch: Remote Kerberos reflection: ADCS Potato domain compromise (8:00)
Andrea Pierini's research uncovered several critical vulnerabilities and innovative bypasses, demonstrating the continued viability and severity of authentication reflection attacks:
- Remote Kerberos Reflection via DCOM (ADCS Potato): Discovery of a method to remotely coerce a machine to authenticate by abusing DCOM interfaces (specifically the ADCS
CertificateServicesRequestinterface). When reflected against the ADCS HTTP endpoint (if Extended Protection for Authentication, or EPA, is not enabled), this can lead to the issuance of a machine certificate, enabling a Golden Certificate attack and full domain compromise. - SMB-to-SMB Kerberos Reflection (Printer Bug Abuse): A technique leveraging known printer bug coercion (or other SMB callback mechanisms like DFS) combined with the CMTI trick to achieve remote code execution as SYSTEM on the target machine. This was fixed in June 2025 by invalidating call buffers containing invalid or empty strings.
- Ghost SPN Vulnerability: Identification of "ghost SPNs" – SPNs referencing non-existent or unregistered hostnames. These ghost SPNs could be exploited to perform SMB-to-SMB Kerberos reflection, achieving SYSTEM privileges on critical "tier zero" computers. This was fixed in October 2025 by validating loopback addresses in the SMB server driver.
- Fake Local NTLM Authentication Reflection: A significant finding demonstrating how to force a remote machine into performing a "local" NTLM authentication flow. This involved coercing authentication (e.g., via SMB/DFS) and reflecting it back to the target's own LDAP/LDAPS service using an empty NTLM3 message. This bypasses NTLMv2 validations, message integrity checks, and even LDAPS channel binding, leading to full domain compromise until June 2025.
- Printer Bug 2025 Bypass for NTLM Reflection: Even after the June 2025 fix, Pierini found a bypass for the fake local NTLM reflection by adapting the printer bug to use RPC calls instead of named pipes. This allowed direct use of the target's IP address, circumventing SPN spoofing requirements and enabling domain compromise until September 2025.
- RPC Endpoint Mapper Memory Corruption (CVE): While developing the Printer Bug 2025 bypass, Pierini discovered a memory corruption vulnerability in the client RPC endpoint mapper, allowing control over free loops and pointer addresses. This was classified as an important RCA and fixed in March 2026.
- Windows Admin Center (WAC) Full Domain Compromise: Discovery of a critical vulnerability in WAC, allowing a low-privileged domain user to achieve full domain compromise. By coercing machine authentication (or cross-session relaying an admin's session) and reflecting it to WAC's
invoke commandendpoint, attackers could gain SYSTEM privileges on the WAC server. This was particularly severe when WAC was installed on an ADCS server, leading to golden certificate attacks. The lack of EPA in WAC's web server was a key enabler. Fixed in January and February 2026. - "Stupid" WAC Permissions Bypass (CVE Bypass): A simple yet effective bypass for an existing WAC vulnerability (CVE) related to permissions on the
ProgramData\Windows Admin Centerdirectory. By pre-creating the directory with full control, a standard user could gain Network Service privileges upon an admin's WAC installation.
Technical Deep Dive
▶ Watch: Critical NLM local authentication reflection: Domain takeover (17:00)
The talk provided a deep dive into the technical mechanics of each attack, showcasing how seemingly minor details in protocol implementation or configuration can lead to severe security flaws.
Red Marshall Target Info (CMTI) Trick
The CMTI trick is fundamental to many of Pierini's Kerberos reflection attacks. In the Windows Security Provider Interface (SSPI), the SPN can include a base64-encoded buffer containing credential information. By crafting a DNS record with an SPN like fileserver+<empty_base64_buffer>, an attacker can trick a remote computer. When the victim machine attempts to authenticate to this hostname, it extracts only the "fileserver" part for ticket requests and NTLM extended information. Crucially, the empty buffer influences how the authentication context is perceived, making a remote authentication appear as a "local" loopback authentication to the victim. This grants the attacker control over the SPN context without requiring actual SPN registration, which is typically a privileged operation.
Remote Kerberos Reflection: ADCS Potato
The ADCS Potato attack leverages DCOM to coerce authentication. Pierini discovered that the CertificateServicesRequest interface exposed by ADCS servers is accessible to any authenticated user. An attacker can remotely trigger this interface, forcing the ADCS server to authenticate to an attacker-controlled endpoint. If this authentication is then reflected back to the ADCS server's own HTTP endpoint (e.g., /certsrv/), and if Extended Protection for Authentication (EPA) is not enabled on the ADCS web server, the attacker can request a client certificate for the ADCS machine. Obtaining this certificate is equivalent to a Golden Certificate attack, granting full control over the domain. This highlights the critical importance of EPA on sensitive web services.
SMB-to-SMB Kerberos Reflection (Printer Bug & Ghost SPN)
This attack chain involves coercing authentication via SMB and reflecting it back to the target's SMB service. The speaker demonstrated using the infamous Printer Bug (or other SMB-based coercion methods like DFS or named pipes) to force a remote computer to authenticate to the attacker. With the CMTI trick, the attacker can control the SPN, making the victim believe it's authenticating locally. The reflected Kerberos authentication then grants the attacker SYSTEM privileges on the remote machine. Microsoft addressed this in June 2025 by invalidating call buffers containing invalid or empty strings, effectively neutralizing the CMTI trick for this specific vector.
However, Pierini then introduced the Ghost SPN concept. Many Active Directory environments contain SPNs that reference hostnames which no longer exist or were never registered in DNS. By identifying such "ghost SPNs," an attacker can register a DNS entry for that ghost SPN pointing to their own machine. This allows the same SMB-to-SMB Kerberos reflection attack to proceed without needing the CMTI trick, as the attacker now has legitimate control over the SPN context. This was particularly dangerous on "tier zero" computers. Microsoft fixed this in October 2025 by enhancing validation of loopback addresses in the SMB server driver.
Fake Local NTLM Authentication Reflection
This was a particularly severe finding. The core idea is to force a remote machine to perform an NTLM Local Only (LO) authentication. NTLM LO is a special loopback authentication where the client and server are the same, and the NTLM3 message (containing the challenge response) is completely empty. Pierini discovered that by coercing a domain controller's SMB authentication (e.g., via DFS) and reflecting it to its own LDAP or LDAPS service, an attacker could trigger this NTLM LO flow. The empty NTLM3 message meant that all NTLMv2 validations, message integrity checks, and even LDAPS channel binding requirements were completely ignored. This allowed any domain user to compromise a domain controller by reflecting its authentication, granting themselves arbitrary rights (e.g., DCSync privileges). This vulnerability was present until June 2025 and was unintentionally fixed alongside the SMB-to-SMB Kerberos reflection fix.
Crucially, even after the June 2025 fix, Pierini found a bypass for this NTLM reflection. By modifying the printer bug to use RPC calls instead of named pipes, he could coerce authentication directly using the IP address of the domain controller. This circumvented the SPN-related protections, allowing the same domain compromise to persist until September 2025. The final fix in October 2025 ensured that message integrity checks and channel bindings are always evaluated, regardless of the NTLM message content, effectively mitigating this vector.
RPC Endpoint Mapper Memory Corruption
During his research into the Printer Bug 2025 bypass, Pierini discovered a memory corruption vulnerability in the client RPC endpoint mapper. While not detailed in the talk, he mentioned having control over the number of free loops and pointer addresses. This was reported to Microsoft, classified as an "important RCA," and fixed in March 2026. This exemplifies how deep dives into existing attack vectors can uncover entirely new and critical vulnerabilities.
Windows Admin Center (WAC) Full Domain Compromise
Windows Admin Center is a browser-based management tool used by administrators. Pierini identified a critical vulnerability allowing a low-privileged domain user to achieve full domain compromise when WAC was installed on a sensitive server, particularly an ADCS server.
The attack flow involved:
- Authentication Coercion: Using DCOM or other methods, coerce the machine where WAC is running to authenticate to an attacker-controlled endpoint.
- Reflection to WAC: Reflect the machine's authentication to WAC's web server.
- Exploiting
invoke command: WAC exposes a REST endpoint namedinvoke commandthat allows arbitrary PowerShell command execution. - Lack of EPA: Critically, WAC's underlying web server (Net.TCP Port Sharing Service, not IIS) did not implement Extended Protection for Authentication (EPA). EPA is designed to prevent relay attacks by binding authentication tokens to the TLS channel. Without it, the reflected authentication was accepted.
This combination allowed the attacker to gain SYSTEM privileges on the WAC server. If WAC was on an ADCS server, this immediately translated to a Golden Certificate attack and full domain compromise. Pierini also noted the possibility of cross-session relay, where an administrator's active WAC session could be hijacked.
Microsoft fixed this in two stages:
- January 2026: Backported EPA requirements to older HTTP.sys drivers (Windows Server 2022, 2019), making EPA natively enabled by default.
- February 2026: An out-of-band patch for Windows Admin Center itself to explicitly enable EPA in its Kestrel web server.
Newer Windows versions (Windows 11, Server 2025) were not vulnerable because EPA was natively enabled in their HTTP drivers by default.
"Stupid" WAC Permissions Bypass
Finally, Pierini shared a "stupid" yet effective bypass for an existing WAC CVE related to permissions on ProgramData\Windows Admin Center. The original CVE fixed permissions issues during installation that allowed a standard user to gain Network Service privileges via the WacExtensionUninstall process. Pierini discovered that if a low-privileged user pre-created the ProgramData\Windows Admin Center directory and granted themselves full control, then waited for an administrator to install WAC, the permission hardening would fail, and the attacker could still exploit the vulnerability. This simple bypass was reported and subsequently fixed under the same CVE, highlighting the importance of thorough testing and considering edge cases.
Demo / Proof of Concept
▶ Watch: Demo: NLM reflection bypasses LDAP channel binding (20:00)
Andrea Pierini included several compelling live demonstrations during his talk to illustrate the practical impact of these vulnerabilities.
One key demonstration showcased the SMB-to-SMB Kerberos reflection attack using a Ghost SPN. The speaker, as a low-privileged domain user, first ran a script to identify ghost SPNs within the Active Directory environment. Upon finding one (e.g., "ghost"), he demonstrated that ping ghost failed to resolve, confirming its non-existence in DNS. He then created a DNS entry for "ghost" pointing to his attacker machine. Next, he launched his Kerberos relay tool, triggered the authentication (using the printer bug), and successfully reflected the victim's authentication. The result was a command shell on the remote computer with SYSTEM privileges, demonstrating a complete privilege escalation.
Another impactful demo highlighted the severity of the Fake Local NTLM Authentication Reflection leading to domain compromise. This demo featured a domain controller with default security settings, including NTLM compatibility level set to 5 (disallowing NTLMv1) and LDAP channel binding enforced. Despite these protections, the low-privileged attacker created a fake DC DNS entry using the CMTI trick, coerced the domain controller's authentication via DFS, and then contacted the DC's LDAPS endpoint. The reflection granted the attacker's low-privileged user account DCSync rights, which was immediately verified by checking the user's permissions. This clearly demonstrated the complete compromise of the domain, bypassing what were considered robust security configurations.
Finally, the Windows Admin Center (WAC) vulnerability demo illustrated how a low-privileged user could achieve full remote access to a machine running WAC. The attacker identified the WAC server and, using a custom script, successfully coerced the machine's authentication. The demonstration showed the attacker being authenticated to WAC as the computer account, gaining full administrative privileges on the remote machine. To underscore the severity, the attacker used certutil to back up the private and public keys from the ADCS server, confirming the ability to perform a Golden Certificate attack and compromise the entire domain.
While a demo for the Printer Bug 2025 bypass (RPC-based NTLM reflection) was prepared, it was not shown live due to time constraints, but the speaker affirmed its functionality and similarity to the other NTLM reflection demo.
Defensive Implications
▶ Watch: Conclusion: Countermeasures and future attack vectors (33:00)
The extensive research presented by Andrea Pierini provides several critical defensive implications for organizations running Windows environments:
- Enforce Signing and Channel Binding Universally: This is a recurring theme. While NTLM signing and LDAP channel binding are crucial, they must be enforced across all relevant protocols and services. The talk demonstrated how subtle implementation flaws or the lack of Extended Protection for Authentication (EPA) in specific web servers (like WAC's Kestrel server) can render these protections ineffective against reflection attacks.
- Patch, Patch, Patch (and Understand Fixes): Regular and timely patching is paramount. The talk highlighted specific fixes in June 2025 (SMB-to-SMB Kerberos reflection, NTLM reflection unintentional fix), October 2025 (Ghost SPN, NTLM reflection final fix), January/February 2026 (WAC EPA backports), and March 2026 (RPC memory corruption). Defenders must not only apply patches but also understand what vulnerabilities they mitigate to ensure comprehensive protection.
- Harden Systems by Disabling Unnecessary Services: The Print Spooler service is a frequent target for authentication coercion. Defenders should disable the Print Spooler on domain controllers and other critical servers unless absolutely necessary. This reduces the attack surface significantly. Similarly, other unnecessary services that can coerce authentication should be identified and disabled.
- Implement RPC Filters: To limit the ability of attackers to coerce authentication, organizations should consider implementing RPC filters. These filters can restrict which services or interfaces can be called remotely, thus reducing the effectiveness of DCOM-based coercion (like the ADCS Potato) or other RPC-based coercion techniques (like the Printer Bug 2025 bypass).
- Monitor for Ghost SPNs and SPN Hygiene: Regularly audit Active Directory for ghost SPNs – SPNs referencing non-existent or unregistered hostnames. These can be exploited by attackers to take control of authentication contexts. Maintaining clean and accurate SPN registrations is essential.
- Review Windows Admin Center Deployments: If Windows Admin Center (WAC) is deployed, especially on critical servers like ADCS, ensure it is fully patched (January/February 2026 fixes). Verify that Extended Protection for Authentication (EPA) is active for WAC. Consider the principle of least privilege for WAC deployments and ensure it's not installed on domain controllers or other Tier 0 assets if possible.
- Be Aware of New Attack Vectors: Authentication reflection is an evolving field. Defenders should stay informed about new research and continuously assess their environments for novel attack vectors. The talk itself highlighted two new reflection attacks discovered by other researchers, indicating ongoing innovation in this area.
Key Takeaways
- Authentication Reflection Remains a Potent Threat: Despite years of mitigations, Windows authentication reflection continues to be a viable and severe attack vector, leading to local privilege escalation, remote code execution, and full domain compromise.
- CMTI Trick and Ghost SPNs Expand Attack Surface: The Red Marshall Target Info (CMTI) trick and the exploitation of "ghost SPNs" enable attackers to control SPN contexts, bypassing traditional Kerberos reflection protections and forcing remote machines to perceive authentication as local.
- Fake Local NTLM Reflection Bypassed Critical Protections: A critical vulnerability allowed NTLM reflection to bypass NTLMv2 integrity checks and even LDAPS channel binding until late 2025, demonstrating how an empty NTLM3 message could render security features ineffective.
- Windows Admin Center (WAC) Was a High-Impact Target: WAC's
invoke commandendpoint, combined with its lack of Extended Protection for Authentication (EPA), created a critical vulnerability allowing full domain compromise when WAC was deployed on sensitive servers like ADCS. - Patching and Hardening Are Continuous Battles: Microsoft's ongoing efforts to fix these vulnerabilities (with patches released up to March 2026) highlight the need for constant patching and comprehensive system hardening (e.g., disabling Print Spooler on DCs, implementing RPC filters).
- Simple Bypasses Can Be Highly Effective: The "stupid bypass" for a WAC permissions CVE demonstrated that attackers often look for the simplest ways to circumvent security, reinforcing the need for thorough and creative security testing.
About the Speaker(s)
Andrea Pierini is a Senior Security Consultant at Semperis, bringing a wealth of experience in IT and a passion for security research. Hailing from Italy, Andrea actively engages in security research as a hobby, sharing his findings with the community through talks at conferences like SEC-T and via his personal blog. His work often focuses on Windows security, uncovering novel vulnerabilities and attack techniques, particularly in the realm of authentication and Active Directory.
Reviews
Dr. Zero (Offensive Security Researcher) — MUST SEE
Pierini didn't just rehash MS08-068; he completely dismantled modern Windows authentication boundaries. Weaponizing the CMTI trick to spoof local loopbacks and using empty NTLM3 messages to bypass LDAPS channel binding is god-tier protocol abuse.
Heather Calloway (CISO) — STRONG ACCEPT
Andrea Pierini's research demonstrates how deeply entrenched Windows authentication flaws can still yield full domain compromise. While this is a highly technical offensive talk, the architectural implications for Active Directory Certificate Services (ADCS) and Windows Admin Center (WAC) are severe. This is required reading for your identity architecture and infrastructure engineering teams.