Virtual patching vs. real patching: Stopping an exploit isn't the same as fixing a vulnerability

Key takeaways
- Virtual patching provides immediate, targeted protection by blocking a specific exploit already in use, without modifying the underlying software. That matters during an active campaign, while the real patch is on the way. The vulnerability stays in the software until that fix removes it.
- There are serious coverage limitations with virtual patching. Security rules can miss unknown exploitation techniques, introduce false positives, and leave parts of the software supply chain unprotected.
- Real patching addresses the root cause by correcting the vulnerability in the software itself, rather than relying on rules that recognize and block attacks. The fix remains effective wherever the patched software is deployed.
- AI is accelerating vulnerability discovery, increasing the pressure on security teams to move beyond detection and deliver fixes at the same pace.
- The future of vulnerability management depends on faster remediation. As AI accelerates discovery, the priority must shift toward finding, validating, and fixing vulnerabilities at the source before attackers can exploit them.
How do you protect software when new vulnerabilities are being discovered faster than organizations can fix them?
As AI accelerates vulnerability discovery, security teams are increasingly facing flaws with no known exploitation patterns. Virtual patching can provide immediate protection against specific, known attacks, but it can't guarantee coverage against techniques it hasn't encountered. And without changing the underlying software, the vulnerability remains.
That's why blocking an exploit isn't the same as fixing a vulnerability. Virtual patching buys valuable time, while real patching corrects the underlying flaw. Once the patched software is deployed, that fix is built in, wherever the software runs.
What is virtual patching?
Virtual patching is a security technique that protects vulnerable software by blocking attempts to exploit known weaknesses without modifying the underlying code. Rather than correcting the vulnerability directly, it introduces a protective layer between potential attackers and the affected application.
This protection is commonly implemented through technologies such as web application firewalls (WAFs), intrusion prevention systems (IPS), and runtime security controls. These systems inspect traffic or application behavior and attempt to identify and block activity associated with exploitation.
For example, imagine a critical vulnerability is discovered in a widely used web application. A software update isn't available yet, but researchers have identified a particular request pattern that attackers use to exploit the flaw. A security team could deploy a WAF rule that recognizes and blocks requests matching that pattern, reducing the likelihood of successful exploitation while the underlying application remains vulnerable.
Why virtual patching is valuable
One of the greatest advantages of virtual patching is speed. Developing, testing, and deploying a permanent software fix can take time, particularly when the vulnerability affects a complex application or a widely used dependency. Virtual patching gives security teams an opportunity to introduce protective controls during that window, potentially preventing attacks before a permanent fix can be deployed.
It can also reduce operational disruption. Unlike traditional software updates, virtual patches generally don't require rebuilding applications, changing dependencies, or modifying production code. For organizations managing critical infrastructure, legacy systems, or applications with strict availability requirements, this flexibility can be particularly valuable.
This approach can also provide centralized protection across multiple applications or environments. Rather than requiring each development team to independently deploy an update, security teams can sometimes introduce controls through shared infrastructure, reducing exposure across a broader environment.
These advantages make virtual patching an important component of vulnerability management, especially during an active campaign against a known technique. The control has to recognize that technique. The vulnerability remains in the software until a real patch removes it.
Where virtual patching falls short
The fundamental limitation of virtual patching is that the underlying vulnerability remains present in the software. While a security control may successfully block certain exploitation techniques, it doesn't correct the flaw itself, leaving protection dependent on the effectiveness and coverage of the deployed defenses.
Protection depends on recognizing the attack
Many virtual patches rely on signatures, rules, or behavioral patterns associated with known exploitation techniques. When a vulnerability is first discovered, WAF vendors may not have enough information to develop a reliable rule, particularly if the flaw hasn't been publicly disclosed or its exploitation methods aren't fully understood.
Even when a rule successfully blocks a known exploit, attackers may discover alternative ways to trigger the same vulnerability. This was demonstrated during the Log4Shell crisis, when researchers documented techniques for evading WAF rules designed to block exploitation of CVE-2021-44228. AI-driven vulnerability research makes this challenge more significant by accelerating the exploration of potential exploitation paths.
Behavioral and anomaly-based protections can sometimes identify previously unknown attacks, but they also face tradeoffs between detection accuracy, coverage, and false positives. As a result, virtual patching cannot guarantee protection against every possible way a vulnerability might be exploited.
Coverage doesn't extend across the entire software supply chain
Virtual patching is also limited by where protective controls are deployed and what they can inspect. A WAF might successfully block malicious HTTP requests targeting a vulnerable application, but it may have little visibility into internal services, background processes, build environments, or compromised dependencies.
This matters because modern applications depend on extensive software supply chains, including open-source libraries, container images, operating system packages, and development tools. Vulnerabilities in these components may be exploitable through pathways that never pass through a traditional perimeter security control.
The challenge becomes particularly significant when the vulnerable code sits deep in the dependency tree. A flaw in a parsing library, for example, may be reachable through a message queue, a file upload processed in the background, or an internal API call – paths that never pass through the network-based rules typically associated with virtual patching.
Runtime security controls can extend protection beyond the network perimeter, but they still depend on being deployed wherever the vulnerable software runs and having visibility into the relevant activity. Even when those controls successfully block an exploit, the vulnerability remains in the underlying software.
Real patching addresses this limitation by making the fix part of the software itself. Once the patched component is incorporated and deployed, the correction applies wherever that version runs, whether in production, staging, or an internal service. It also remains part of the component when that patched version is pulled into another application, without requiring a separate vulnerability-specific rule for each environment or attack path.
Security rules create their own operational burden
Virtual patching also introduces ongoing maintenance requirements. Security teams must develop, test, deploy, monitor, and update protective rules as new vulnerabilities and exploitation techniques emerge.
Rules that are too restrictive can block legitimate application behavior, creating false positives and operational disruption, while rules that are too narrow may fail to detect modified exploitation techniques. As the number of vulnerabilities grows, maintaining effective protection becomes increasingly complex.
Over time, organizations can accumulate large collections of vulnerability-specific rules that add operational complexity without reducing the number of vulnerabilities present in their software. Even when those rules remain effective, they still require ongoing attention from security teams.
These limitations don’t make virtual patching ineffective – they reinforce why it should generally be viewed as a risk-reduction measure rather than a permanent substitute for correcting vulnerable software.
What is real patching?
Real patching, also known as software patching or code-level remediation, addresses a vulnerability by correcting the underlying software. Instead of relying on a protective layer to intercept exploitation attempts, it changes the vulnerable code, configuration, or component so the specific flaw is no longer present.
This can involve updating an open-source library, applying an operating system security fix, rebuilding a container image with patched packages, or backporting a correction into an older software version.
Consider Log4Shell (CVE-2021-44228), a critical vulnerability in the widely used Java logging library Log4j. During the attacks, Cloudflare deployed and updated WAF rules to block evolving exploitation attempts. This provided an important layer of protection, but the vulnerability itself remained in affected versions of the library. Real patching meant updating Log4j to a version that corrected the flaw, so applications running the patched library were no longer vulnerable to that specific issue, regardless of the exploit patterns attackers used.
Why real patching is essential
The primary advantage of real patching is that it addresses the root cause of a vulnerability. Rather than relying on security controls to recognize malicious activity, a successful patch removes the specific weakness that attackers could exploit.
Because the underlying weakness has been corrected, a properly validated patch can protect against multiple exploitation techniques targeting the same flaw, including techniques that existing security rules might not recognize. This makes protection less dependent on anticipating how attackers will attempt to exploit a vulnerability.
Another important advantage is that protection travels with the software. Unlike virtual patching, which depends on where security controls are deployed, a patched artifact contains the corrected code wherever it runs. Whether a container is deployed in production, a staging environment, an internal service, or a developer's laptop, the specific vulnerability remains fixed without requiring separate protective rules for each environment.
Real patching is especially important for software supply chain security. When a vulnerability exists in a widely used open-source component, correcting it at the source creates an opportunity to protect every downstream application that adopts the fixed version. Instead of independently defending each deployment against the same weakness, organizations can incorporate the corrected component into their existing build and deployment processes.
Real patching also helps reduce the long-term operational burden of vulnerability management. Once a vulnerability is corrected, organizations can reduce their reliance on vulnerability-specific compensating controls rather than maintaining an expanding collection of protective rules. Patched components can also be verified through scanners and accompanying advisories, providing clearer evidence of remediation for audits and compliance.
The challenge with real patching is often getting a validated fix into the software organizations actually run. Updates may require compatibility testing, application rebuilds, or coordination with upstream maintainers before they can be safely deployed. But these challenges only reinforce the need to make remediation faster and easier, rather than relying indefinitely on protective rules that leave the underlying vulnerability in place.
These challenges help explain why vulnerabilities can persist long after fixes become available. The difficulty isn't always developing a patch, but getting that patch safely into the software organizations actually run.
Virtual patching vs. real patching: What's the difference?
Although both approaches aim to reduce security risk, they operate at different levels. Virtual patching focuses on preventing exploitation, while real patching focuses on correcting the vulnerability itself.
The distinction becomes particularly important during the vulnerability lifecycle. When a critical flaw is first discovered, virtual patching can provide valuable protection while a software fix is being developed or deployed. Once a validated fix becomes available, however, correcting the vulnerable software provides a more durable solution.
Virtual patching can help manage immediate exposure, but it doesn't replace the need for real remediation. Correcting the underlying software provides protection that doesn't depend on maintaining vulnerability-specific rules or intercepting every potential exploitation attempt.
Why AI makes real patching more important than ever
Real patching becomes especially important when vulnerabilities are discovered before public disclosure. At that point, there's no CVE for a scanner to flag and no published exploit for a WAF rule to recognize. The vulnerable code is still present in the software, but security teams may have little information to develop targeted protective rules. Correcting the underlying flaw allows organizations to deploy patched software before the vulnerability becomes public.
The emergence of frontier AI models capable of discovering previously unknown vulnerabilities is accelerating this challenge. AI models can now analyze large codebases, identify suspicious behavior, and propose potential exploitation paths at a scale that was previously difficult to achieve.
In Echo's research comparing three frontier AI models analyzing the same open-source codebases, 83% of distinct bugs were identified by only one model. The findings demonstrate how much vulnerability discovery can vary between models, and why identifying potential weaknesses is only the beginning. Turning those findings into meaningful protection still requires validation, patch development, testing, and delivery.
This creates an enormous opportunity for defenders, but also puts growing pressure on security teams responsible for remediation. As discovery accelerates, organizations face more vulnerabilities requiring investigation, prioritization, and ultimately a permanent fix.
Virtual patching can help reduce immediate exposure, but relying on it as the primary response introduces a scalability problem. Each new vulnerability may require additional rules, testing, monitoring, and maintenance, while the vulnerable software continues to circulate throughout the ecosystem.
The challenge is particularly significant for widely used open-source components embedded across thousands of downstream applications. A network-level rule might protect a specific deployment, but it doesn't correct the vulnerable dependency being distributed throughout the software supply chain.
As AI makes vulnerability discovery faster and more accessible, delivering validated software fixes becomes the bottleneck. The challenge now is ensuring that remediation can keep pace.
Using AI to accelerate remediation, not just discovery
The same AI capabilities transforming vulnerability discovery can also help accelerate the development and validation of real software fixes. But for security teams, the real value comes from receiving software that's already been patched, rather than another vulnerability to investigate and remediate.
Echo Frontier puts this into practice by using frontier AI models to discover vulnerabilities in open-source libraries, validate findings, and develop and test fixes. Before a patch is delivered, Echo verifies that the original proof of concept no longer succeeds, runs the library's test suite, and requires approval from a security researcher. Customers can then receive the corrected library build before the vulnerability is publicly disclosed, while Echo coordinates disclosure with upstream maintainers.
These fixes aren't limited to the latest upstream releases. Echo backports patches across affected versions it builds from source, allowing organizations to stay on their existing software versions without disruptive major upgrades or vulnerability-specific security rules.
Because the fix is already incorporated into the library build customers consume, downstream teams don't need to develop or maintain their own patches. They receive corrected software through their existing workflows, reducing the time and effort between vulnerability discovery and protection.
The future of vulnerability management depends on fixing software faster
Virtual patching will continue to play an important role in software security. When vulnerabilities are actively being exploited, permanent fixes are unavailable, or organizations need time to safely deploy updates, protective controls can provide an essential layer of defense.
But as AI accelerates vulnerability discovery, the limitations of relying on protective rules alone become increasingly apparent. Security teams cannot indefinitely compensate for vulnerable software by adding more signatures, policies, and monitoring requirements.
Virtual patching can block known exploitation techniques while attacks are underway, but lasting protection comes from real patching: removing the vulnerability from the software and delivering the corrected artifact through the source organizations already use, even before a vulnerability is publicly disclosed or an exploit is available to write a rule against.
Frontier models can now find and exploit zero days in your code
Find out what to do when there's no CVE, scanner alert or fix available yet.
What are the 7 blind spots in your vulnerability scans?
Discover when "0 vulnerabilities" doesn't actually mean you're clean.





.avif)
.avif)