Accelerated Response by Design

Tom Gallagher (VP of Engineering · Microsoft Security Response Center (MSRC))

BlueHat Asia 2026 · Day 2 · Main Stage

Overview

In the rapidly evolving landscape of cybersecurity, the speed of response can be the critical factor between a contained incident and widespread compromise. Tom Gallagher, VP of Engineering at the Microsoft Security Response Center (MSRC), delivered a compelling talk at BlueHat Asia, "Accelerated Response by Design," outlining Microsoft's transformative approach to security incident management. The core message is a paradigm shift: move beyond the traditional focus on delivering the "perfect, durable fix" first, and instead prioritize rapid, tactical mitigations that can be deployed within hours, effectively breaking exploit chains before full patches are ready.

Watch on YouTube

Visual summary for Accelerated Response by Design by Tom Gallagher
Visual summary for Accelerated Response by Design by Tom Gallagher

Key moments

  1. 0:00 Introduction: The challenge of accelerating security response
  2. 2:15 Dramatic 10x increase in CVEs due to AI
  3. 4:00 Hallucinating AI generates fake vulnerability reports for MSRC
  4. 10:15 Introducing tactical mitigation: Rapid countermeasures within hours
  5. 14:00 Case Study: Microsoft Word zero-day protected without patch
  6. 20:00 Strategy: Breaking exploit chains with the 'puzzle piece' analogy
  7. 22:00 How Word mitigation worked: CoCreateInstance activation filter
  8. 28:00 Summary: Attack speed vs. release speed and tactical mitigations

Accelerated Response by Design

Speakers: Tom Gallagher, VP of Engineering, Microsoft Security Response Center (MSRC)

Conference: BlueHat Asia

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

Overview

In the rapidly evolving landscape of cybersecurity, the speed of response can be the critical factor between a contained incident and widespread compromise. Tom Gallagher, VP of Engineering at the Microsoft Security Response Center (MSRC), delivered a compelling talk at BlueHat Asia, "Accelerated Response by Design," outlining Microsoft's transformative approach to security incident management. The core message is a paradigm shift: move beyond the traditional focus on delivering the "perfect, durable fix" first, and instead prioritize rapid, tactical mitigations that can be deployed within hours, effectively breaking exploit chains before full patches are ready.

Gallagher's presentation underscored the urgent need for this acceleration, driven by the escalating pace of attacker innovation and the burgeoning role of artificial intelligence in vulnerability discovery and exploitation. He highlighted a dramatic, nearly tenfold increase in reported CVEs within a single year, demonstrating that traditional release cycles are no longer sufficient to protect customers effectively. This talk is crucial for anyone involved in building, defending, or managing software systems, offering practical insights into how to bake rapid response capabilities into product design from the outset.

The talk champions a proactive, engineering-led strategy where systems are designed not just for resilience, but for agility in response. By focusing on configuration-driven countermeasures, Microsoft has demonstrated the ability to neutralize active threats globally without requiring a software update, fundamentally changing the economics of exploitation for attackers. This approach ensures that defenders can operate at "attack speed," minimizing the window of opportunity for adversaries and safeguarding customers more effectively.

Background

▶ Watch: Introduction: The challenge of accelerating security response (0:00)

The foundational challenge addressed by Gallagher is the ever-widening gap between the speed of attackers and the traditional release cycles of software development. As he pointed out, if a critical service goes down, the immediate priority is always to get it back online with a rapid mitigation, followed by a durable fix. Yet, with security incidents, the tendency has historically been to invest time in crafting the "best durable fix," which often takes weeks for code changes, testing, and deployment. This "release speed" paradigm is increasingly unsustainable when facing adversaries operating at "attack speed."

Adding to this urgency is the accelerating impact of Artificial Intelligence (AI) on the vulnerability landscape. AI models are becoming remarkably adept at finding, reporting, and even exploiting vulnerabilities. Gallagher illustrated this with a stark statistic: Microsoft shipped 94 new CVEs on Patch Tuesday a year ago, but this past September, that number surged to 974—a nearly 10x increase. While the number of patches customers need to install remains relatively flat due to bundling, the sheer volume of discovered vulnerabilities demands a faster response.

However, the rise of AI also introduces new complexities. MSRC has encountered instances of AI hallucination, where systems like Copilot or other Large Language Models (LLMs) generate plausible but entirely fabricated vulnerability reports. Gallagher shared anecdotes, such as a researcher using Copilot to "access" a backend file system, only for Copilot to invent the directory listings and file contents. Even more concerning are cases where new security researchers, lacking traditional validation experience, submit AI-generated vulnerability reports to MSRC that turn out to be completely fictitious, leading to wasted effort and potential erosion of trust. Another memorable example involved an AI-generated exploit chain for Azure Quantum that referenced "time traveling" with Alice and Bob. These scenarios underscore the dual nature of AI in security: a powerful tool for discovery, but also a source of noise that demands careful human validation.

This backdrop of rapidly increasing vulnerability discovery and the operational challenges posed by AI-generated reports necessitates a fundamental re-evaluation of security response strategies. The traditional model is no longer adequate; a new approach focused on speed, agility, and proactive design is paramount.

Key Findings

▶ Watch: Hallucinating AI generates fake vulnerability reports for MSRC (4:00)

The central theme of Gallagher's talk revolves around the concept of Accelerated Response by Design, a strategic imperative for modern cybersecurity. The key findings and contributions can be summarized as follows:

  1. Tactical Mitigation First: The primary finding is the emphasis on tactical mitigations as the initial response to a security incident. A tactical mitigation is defined as a rapid countermeasure capable of reducing exposure to a vulnerability within hours, significantly shrinking the window of opportunity for attackers. This contrasts sharply with the traditional approach of immediately pursuing a comprehensive, architecturally perfect, and durable fix that can take weeks to develop and deploy.
  1. Breaking the Exploit Chain: Rather than fixing every aspect of a vulnerability, tactical mitigations aim to break the exploit chain. Gallagher used the analogy of a puzzle: an exploit requires a series of conditions or "puzzle pieces" to align perfectly. By identifying and removing even a single critical piece, the entire exploit chain is rendered ineffective. This targeted approach allows for extremely rapid deployment, making an attacker's significant investment in developing an exploit instantly obsolete.
  1. Configuration-Driven Response: A critical enabler for tactical mitigations is the ability to implement changes through configuration updates, rather than requiring a full software build and deployment. This bypasses the lengthy development, testing, and release cycles associated with traditional patches. By manipulating configurations—whether for services, on-premise software, or client applications—defenders can rapidly block attacker access to vulnerable code paths.
  1. Building Response Capabilities by Design: The talk stresses that this accelerated response isn't magic; it's the result of intentional engineering investment. Product teams must proactively build capabilities into their software that allow for out-of-band, rapid configuration changes to influence security posture. This "response by design" philosophy ensures that when an incident occurs, the tools and mechanisms for immediate mitigation are already in place, rather than having to be engineered under duress.

These findings collectively advocate for a fundamental shift in defensive strategy, prioritizing immediate impact and agility over delayed perfection, and leveraging existing infrastructure for dynamic security adjustments.

Technical Deep Dive

▶ Watch: Case Study: Microsoft Word zero-day protected without patch (14:00)

The core technical innovation presented by Gallagher lies in leveraging existing infrastructure and designing new capabilities to enable configuration-driven tactical mitigations without requiring a full code build or deployment. This approach significantly shortens the response timeline from weeks to hours.

The general principle is straightforward: if an attacker cannot reach the vulnerable code, the vulnerability is mitigated. This can be achieved by blocking specific types of traffic, disabling certain functionalities, or altering how components interact, all through configuration changes. While seemingly intuitive for cloud services (e.g., via Web Application Firewall (WAF) rules), the groundbreaking aspect is its application to on-premise and client-side software.

Case Study 1: Microsoft Word Remote Code Execution (February 2023 Incident)

Gallagher detailed a critical incident involving Microsoft Word in February 2023, where a Remote Code Execution (RCE) vulnerability was being actively exploited in the wild. The traditional response for a complex application like Word, built with C++ and having multiple versions, would involve weeks of development, testing, and a Patch Tuesday release. However, the Office team achieved worldwide protection within hours, without a patch.

The exploit chain was sophisticated and involved several steps:

  1. A victim opens a malicious Word document, crafted from an untrusted source.
  2. The victim exits Protected View by enabling editing, which is a common user action.
  3. The attacker leverages a specially crafted OLE (Object Linking and Embedding) control to bypass Word's normal OLE activation filters, preventing any user prompts.
  4. This OLE control then uses a file moniker to initiate the WebClient service.
  5. Subsequently, a COM object within shell.dll is exploited to bypass another security mitigation known as OLE JS.
  6. The attacker then forces the loading of MSHTML (the legacy Internet Explorer rendering engine) with arbitrary HTML content.
  7. Further bypasses for MSHTML's internal security and SmartScreen are achieved.
  8. Ultimately, this chain culminates in Remote Code Execution (RCE) on the victim's system.

To tactically mitigate this, the Office team adopted the "puzzle piece" strategy, choosing to remove a critical piece of the exploit chain: the leveraging of shell.dll (step 4). Their solution was built upon a fundamental Windows operating system function: CoCreateInstance. This function is universally used to activate COM (Component Object Model) objects on Windows.

The Office team had previously built an activation filter capability into Word. This filter registers a callback with CoCreateInstance. Whenever an attempt is made to activate a COM object within the Word process, this callback is invoked, providing the Class ID (CLSID) of the object intended for activation. The filter can then programmatically decide to "allow" or "deny" the activation.

For the February incident, the Office team configured this activation filter to specifically deny the activation of the shell.explorer.1 COM object (identified by its specific CLSID) when initiated through the exploit chain's context.

The crucial aspect was the deployment mechanism. Word clients regularly communicate with a config service hosted on microsoft.com. This service is typically used to enlighten clients about various features and configurations. The security team leveraged this existing channel to push down an XML configuration file. This XML contained the CLSID for shell.explorer.1 and an instruction for the client-side activation filter to block its instantiation. This configuration was pushed globally almost immediately. Upon the next launch of Office or within a few hours, the updated configuration was applied, effectively neutralizing the exploit chain for modern versions of Office without requiring a software patch. Older, unsupported versions still required a traditional patch on the subsequent Patch Tuesday, which also included comprehensive fixes for multiple parts of the original exploit chain, making re-tooling significantly harder for attackers.

Case Study 2: Exchange On-Premise Cross-Site Scripting ("Pressed Panini")

Another example involved an Cross-Site Scripting (XSS) vulnerability in Outlook Web Access (OWA) on Exchange On-Premise servers, dubbed "Pressed Panini." This vulnerability allowed an attacker to take over a user's mailbox simply by sending a malicious email that, when viewed, would execute arbitrary script. Discovered just before a Patch Tuesday, a full code fix was impossible within the required timeframe.

The Exchange team employed a similar config-driven approach using the Exchange Mitigation Service. This service runs on the on-premise Exchange server and is designed to pull configuration updates (referred to as "code config") from Microsoft's servers.

In this instance, Microsoft pushed out a Content Security Policy (CSP) through the Exchange Mitigation Service. This CSP was specifically crafted to nullify the XSS exploit. The CSP would restrict the types of content and script sources allowed to execute within OWA, thereby preventing the attacker's malicious script from running.

This tactical mitigation was deployed immediately, providing protection for affected Exchange On-Premise deployments. A CVE was issued to inform customers, and a full, durable fix was included in the subsequent Patch Tuesday. A notable benefit was that even very old, unsupported versions of Exchange were protected by the Mitigation Service, demonstrating the broad reach of this dynamic response capability.

General Categories of Tactical Mitigations

Gallagher outlined several categories for tactical mitigations:

  • WAF-type mitigations: For services, blocking specific requests or patterns at the network edge.
  • File system actions: Modifying Access Control Lists (ACLs) or deleting specific files to prevent access to vulnerable components.
  • Content Security Policies (CSPs): For web applications, restricting script execution and resource loading.
  • Activation filters: As demonstrated with CoCreateInstance in the Word example, controlling the instantiation of dangerous components.
  • Traffic injection: Potentially injecting CSPs or other security headers into outgoing traffic without direct service modification.

These examples underscore that accelerating response by design is not just a theoretical concept but a tangible engineering practice that fundamentally alters the defensive posture against sophisticated threats.

Demo / Proof of Concept

▶ Watch: Strategy: Breaking exploit chains with the 'puzzle piece' analogy (20:00)

While Tom Gallagher's talk provided detailed technical breakdowns of real-world security incidents and Microsoft's rapid response efforts, it did not feature a live demonstration or a proof of concept conducted by the speaker. Instead, the presentation focused on recounting the specific exploit chains, the design principles behind the tactical mitigations, and the successful outcomes of these strategies in past incidents. The emphasis was on sharing the architectural and operational insights derived from these experiences rather than showcasing a live exploit or mitigation in action.

Defensive Implications

▶ Watch: Summary: Attack speed vs. release speed and tactical mitigations (28:00)

The insights shared by Tom Gallagher carry profound implications for defenders across all sectors, urging a fundamental re-evaluation of security strategy and engineering practices.

  1. Adopt a "Mitigate First, Then Durable Fix" Mindset: The most crucial implication is to shift from a reactive "wait for the perfect patch" approach to a proactive "tactical mitigation first" philosophy. When a critical vulnerability is discovered, the immediate priority must be to deploy rapid countermeasures within hours to break the exploit chain, even if temporary. The comprehensive, durable fix can follow.
  1. Design for Rapid Response: Defenders must advocate for and implement "response by design" principles in all software and service development. This means proactively building capabilities into products that enable out-of-band, configuration-driven security adjustments. Examples include:
  • Configurable Security Controls: Implement features that can be remotely enabled/disabled or modified, such as activation filters for COM objects (like in the Word example), dynamic WAF rules, or granular feature toggles.
  • Centralized Mitigation Services: Develop internal infrastructure (akin to Office's config service or the Exchange Mitigation Service) that allows security teams to push urgent configuration updates to deployed software, whether in the cloud, on-premise, or on client devices.
  1. Identify and Prioritize "Puzzle Pieces": Proactively analyze common attack patterns and exploit chains against your critical assets. Identify the most impactful "puzzle pieces"—the specific conditions, components, or functions that, if removed or altered, would effectively neutralize an entire class of exploits. Invest in capabilities to rapidly disrupt these key points.
  1. Leverage Configuration as a Primary Defensive Tool: Recognize that configuration changes offer a powerful, agile alternative to code patches.
  • For web applications, aggressively use and dynamically update Content Security Policies (CSPs) to restrict malicious script execution.
  • For services, leverage network controls like WAFs to block specific traffic patterns or vulnerable endpoints.
  • For operating systems and client software, explore mechanisms for dynamically altering component activation (e.g., COM object activation filters) or file system permissions (ACLs) to prevent access to vulnerable code.
  1. Be Wary of AI-Generated Vulnerability Reports: With the rise of AI, security teams must allocate resources to rigorously validate all incoming vulnerability reports, especially those that appear to be AI-generated. Develop clear processes to distinguish genuine findings from "hallucinations" to avoid wasting valuable time and resources on non-existent threats.
  1. Invest in Automation for Toil Reduction: While human expertise remains critical for complex analysis and strategic mitigation design, AI and automation should be leveraged to handle the "toil" of initial triage, assessment, and even some automated fixes. This frees up skilled security professionals to focus on higher-value tasks, accelerating overall response.

By embedding these principles into security architecture and operational practices, organizations can empower themselves to respond to threats with unprecedented speed and agility, turning the tables on adversaries who rely on slow defensive cycles.

Key Takeaways

  • Attack Speed vs. Release Speed: Defenders must accelerate their response beyond traditional software release cycles to match the speed of modern attackers, who increasingly leverage AI for faster exploitation.
  • Tactical Mitigations are Paramount: Prioritize rapid, configuration-driven countermeasures that can be deployed within hours to break exploit chains, rather than waiting for comprehensive, durable code patches.
  • Design for Agility: Build rapid response capabilities directly into product and service architectures, enabling out-of-band security updates via mechanisms like activation filters and centralized config services.
  • Break the Exploit Chain: Focus on identifying and removing critical "puzzle pieces" within an exploit chain; neutralizing one key dependency can render an entire sophisticated exploit ineffective.
  • AI's Dual Role: While AI accelerates vulnerability discovery (evidenced by a 10x increase in CVEs), it also introduces "hallucinated" reports that demand rigorous validation to prevent wasted defensive effort.
  • Broad Protection: Config-driven mitigation services can protect a wide range of software versions, including unsupported legacy systems, extending the reach of rapid response capabilities.

About the Speaker(s)

Tom Gallagher is the Vice President of Engineering for the Microsoft Security Response Center (MSRC) at Microsoft. In this critical role, he is responsible for overseeing the company's comprehensive efforts in responding to security vulnerabilities and incidents that impact Microsoft products and services globally. His extensive experience in security response, vulnerability management, and driving architectural shifts for enhanced security is evident in his insights into accelerating defensive measures. Gallagher champions the strategic integration of rapid response capabilities into product design, aiming to equip Microsoft and its customers with the agility needed to counter sophisticated and fast-moving cyber threats.

Reviews

Dr. Zero (Offensive Security Researcher) — SOLID

Gallagher delivers exactly what a vendor security lead should at a conference: real operational detail from real incidents, with enough architectural specificity that defenders can steal the playbook. The Word RCE case study alone—COM activation filters pushed via config service—is worth the slot. Not a research talk, but a strong case-study talk that says things most vendor execs would never clear with legal.

Heather Calloway (CISO) — STRONG ACCEPT

This is the talk I'd point my engineering leadership at when they ask why we need investment in response infrastructure before we have an incident. Gallagher makes a compelling operational case for config-driven mitigations, and the case studies are specific enough to be actionable. Worth your time if you're building or buying software at scale.

→ Top-rated talks at BlueHat Asia 2026

All talks from BlueHat Asia 2026