Your Apache server could be hacked right now — no password, no login, no warning. If your website runs on Apache HTTP Server with HTTP/2 turned on, an attacker on the internet can send a specially crafted request and potentially take over your server. That is not a hypothetical risk. That is what is CVE-2026-119618 in plain terms, and it is why security teams called this a patch-now event the moment it was disclosed.
So, what is CVE-2026-119618 exactly? It is a critical race condition in Apache HTTP Server’s HTTP/2 module that allows unauthenticated remote code execution. It was disclosed on 11 November 2026 and fixed in Apache HTTP Server 2.4.71.
The flaw carries a CVSS score of 9.8 out of 10 — the highest severity band — and a reliable public exploit has already been demonstrated. In short, what is CVE-2026-119618 is a patch-now emergency, not a routine update. If you run Apache, this article gives you the full picture: what the flaw is, which versions are affected, how to check whether your server is exposed, and exactly how to patch it today.
The bottom line up front: if you run Apache 2.4.55 through 2.4.70 with HTTP/2 enabled, update to Apache 2.4.71 now. If you cannot patch today, disable HTTP/2 as a temporary workaround. Do not wait for the weekend. Do not wait to see whether anyone attacks your server first.
What Is CVE-2026-119618 in Plain English?

When people ask what is CVE-2026-119618, they usually want a simple answer, not a wall of security jargon. Here it is: CVE-2026-119618 is a bug in the way Apache handles HTTP/2 requests that have no body. Under the right conditions, two parts of Apache fight over the same piece of memory at the same time. The winner of that fight corrupts the server’s memory, and an attacker can use that corruption to run their own code on your server — with the same privileges as your web server.
The technical name for this kind of bug is a race condition, tracked as CWE-362. It lives in a function called assign_headers() inside mod_http2, the Apache module that handles HTTP/2 traffic. HTTP/2 is the faster, modern version of the protocol your browser uses to talk to a website, and it is enabled on a huge number of Apache servers by default or by choice.
The key point is who can exploit it: anyone. The attacker does not need an account on your website. They do not need to log in, guess a password, or trick a user into clicking a link. They only need to reach your server over the internet and send the right kind of HTTP/2 request. That combination — no authentication plus remote code execution — is exactly what makes a vulnerability critical. It is also the first thing to remember about what is CVE-2026-119618.
To understand what is CVE-2026-119618 at a deeper level, it helps to know what remote code execution means. Remote code execution, or RCE, means the attacker can run commands on your server as if they were sitting at its keyboard. They could read files, steal data, install malware, use your server to attack others, or deface your website. On a web server, that is about as bad as it gets.
CVE-2026-119618 at a Glance
Here is the essential information about what is CVE-2026-119618, summarized so you can share it with your team in under a minute.
| Fact | Detail |
|---|---|
| CVE ID | CVE-2026-119618 |
| Disclosed | 11 November 2026 |
| Fixed in | Apache HTTP Server 2.4.71 |
| Vulnerability type | Race condition (CWE-362) in assign_headers() in mod_http2 |
| Severity | CVSS 9.8 Critical (Red Hat); CISA scored it 8.1 |
| Impact | Unauthenticated remote code execution |
| Affected Apache versions | 2.4.55 through 2.4.70 |
| Affected standalone mod_h2 | 2.0.8 through 2.0.42 |
| Requirement | HTTP/2 must be enabled |
| Public exploit | Reliable exploit demonstrated; proof-of-concept code reproduces heap corruption and crashes |
| In-the-wild exploitation | No confirmed exploitation as of 20 November 2026 |
| Workaround | Disable HTTP/2 (remove h2 and h2c from the Protocols directive) |
| Also fixed in 2.4.71 | CVE-2026-106023 and CVE-2026-109163 |
Takeaway: a CVSS 9.8 score, no login required, and a working public exploit is the textbook definition of a patch-now vulnerability. Anyone asking what is CVE-2026-119618 should start from that severity, not from the technical details.
Why What Is CVE-2026-119618 Matters So Much
Apache HTTP Server is not a niche product. It powers a huge share of the world’s websites, from small business sites and blogs to large enterprise applications. When a critical flaw lands in Apache, the blast radius is enormous, because so many servers share the same code.
That scale is the first reason the question of what is CVE-2026-119618 matters. The second reason is the severity. Most vulnerabilities need something extra to be dangerous: a logged-in user, a specific configuration, or a victim clicking a malicious link. This one does not. That is why every explanation of what is CVE-2026-119618 starts with the same warning: no authentication is needed. An unauthenticated attacker can target any Apache server with HTTP/2 enabled and try the exploit directly.
The third reason is timing. A reliable public exploit has already been demonstrated, and public proof-of-concept code reproduces heap corruption and crashes. That means attackers do not need to reverse-engineer the bug from scratch — the hard research work is already public. History shows that once a reliable exploit exists for a critical Apache flaw, mass scanning and exploitation attempts follow quickly, even if no confirmed in-the-wild exploitation had been reported as of 20 November 2026.
The window between disclosure and exploitation is the window you have to patch. Every day a vulnerable server stays online with HTTP/2 enabled is a day an automated scanner can find it.
How Does CVE-2026-119618 Work?

You do not need to be a C programmer to understand what is CVE-2026-119618 and how it works. The mechanism is surprisingly specific, and that specificity is also what makes the fix reliable.
The Trigger: A Bodyless Request With a Content-Type Header
The flaw is triggered when Apache receives an HTTP/2 request that has three properties at once: it has no body, it carries a Content-Type header, and it has no Content-Length header. That is a strange combination, but it is perfectly legal HTTP, and an attacker can craft it deliberately. This trigger is the detail most guides skip when they explain what is CVE-2026-119618, yet it is the detail that makes detection possible.
When Apache sees that combination, a worker thread steps in and adds a Content-Length: 0 header to a table of headers. The problem is where that table gets its memory. The table draws memory from the connection’s shared, lock-free allocator — a pool of memory that the connection thread also uses, without locks to stop both threads from touching it at the same time.
The Race: Two Threads, One Piece of Memory
A race condition happens when two threads access the same shared resource at the same time and the result depends on who gets there first. In the case of what is CVE-2026-119618, the worker thread adding the Content-Length: 0 header races the connection thread for the same memory in the shared allocator.
If the worker thread wins the race in the wrong way, the memory gets corrupted. Apache’s heap — the area of memory where it stores data while it runs — ends up in an inconsistent state. A corrupted heap is dangerous because an attacker who can control what goes into that memory can often turn the corruption into code execution.
Public proof-of-concept code reproduces this heap corruption reliably enough to crash the server. A practical patching and hunting guide for what is CVE-2026-119618 walks through detection steps and the update process.
A crash is a denial of service on its own, but the deeper danger is that the same corruption can be steered toward remote code execution with web-server privileges. Full weaponized RCE code had not been publicly released as of mid-November, but the demonstrated heap corruption is the hard part — and it is already public.
Takeaway: the flaw is not a misconfiguration or a weak password. It is a memory-safety bug deep inside Apache’s HTTP/2 code, and only a code fix — or turning HTTP/2 off — removes it. That is the core answer to what is CVE-2026-119618.
Who Discovered CVE-2026-119618?
What is CVE-2026-119618 is also a story about how modern vulnerability research works, because this flaw was found independently by two different teams around the same time.
Anthropic’s OSS Scanner reported the vulnerability on 26 October 2026. Google Cloud Vulnerability Research reported it independently on 3 November 2026. Both teams found the same race condition in mod_http2, which tells you something important: the bug was findable, and it was only a matter of time before someone — friendly or hostile — found it.
Apache disclosed the vulnerability on 11 November 2026 and released the fix in Apache HTTP Server 2.4.71 on the same day. Orca Security published the definitive technical research on what is CVE-2026-119618, explaining the race condition in detail.
That fast turnaround is good news, but it also means the clock started ticking for defenders on 11 November. Attackers had the same disclosure to work from. When teams ask what is CVE-2026-119618 in a briefing, the discovery timeline is part of the answer: two independent research teams found it before it was disclosed.
Which Versions Are Affected by CVE-2026-119618?
Version numbers are where most people get confused about what is CVE-2026-119618, so let us be precise. The affected range is wider than it first looks, and it includes some versions you might assume are safe.
Apache HTTP Server 2.4.55 Through 2.4.70
All Apache HTTP Server versions from 2.4.55 through 2.4.70 are affected, provided HTTP/2 is enabled. If you run any version in that range with mod_http2 loaded and HTTP/2 active, you are vulnerable. The fix is Apache 2.4.71, which patches the race condition in assign_headers().
Versions older than 2.4.55 are not listed in the affected range for this specific flaw, but that is not a reason to feel safe on an old version. Older Apache releases have their own long list of known vulnerabilities, and running an unsupported version is a risk in itself.
Standalone mod_h2 2.0.8 Through 2.0.42 — With No Fix Available
The standalone mod_h2 project — a separate distribution of the HTTP/2 module — is also affected, in versions 2.0.8 through 2.0.42. Here is the catch: the standalone mod_h2 project was archived in June 2026, and there is no fixed standalone release. If you still run standalone mod_h2, you cannot simply update it to a patched version, because no patched standalone version exists.
If you run standalone mod_h2, you must move to the mod_http2 bundled with Apache 2.4.71 or to a distribution package that includes the fix. Staying on the archived standalone module leaves you exposed with no patch path.
The Ubuntu Surprise: Older Versions Are Affected Too
Here is the detail that catches many administrators off guard when they ask what is CVE-2026-119618 and whether it affects them. Ubuntu 22.04 ships with apache2 2.4.52, and Ubuntu 20.04 ships with apache2 2.4.41. Both version numbers fall below the 2.4.55 start of the affected range — yet both are also affected.
The reason is backporting. Ubuntu backported a newer version of mod_http2 into those releases, so the vulnerable code is present even though the headline Apache version number looks old. If you run Ubuntu 22.04 or 20.04 and assume you are safe because your version is below 2.4.55, you are wrong. Check your distribution’s patched package instead of relying on the version number alone.
Takeaway: do not decide you are safe from the version number alone. Check whether mod_http2 is loaded, check whether HTTP/2 is enabled, and check your distribution’s security advisory. That version check is the first step in answering what is CVE-2026-119618 for your own servers.
How to Check If Your Server Is Affected
Before you patch, you need to know two things: which Apache version you run, and whether HTTP/2 is actually enabled. Here is how to check both in under a minute.
Step 1: Check Your Apache Version
On Debian and Ubuntu systems, run:
apache2 -v
On Red Hat, AlmaLinux, Fedora, and Amazon Linux systems, run:
httpd -v
Look at the version number in the output. If it is between 2.4.55 and 2.4.70, you are in the affected range and need the 2.4.71 update. If you run Ubuntu 22.04 or 20.04, remember the backport warning above — check your patched package even if the version looks older.
Step 2: Check Whether mod_http2 Is Loaded
Run this command to see whether the HTTP/2 module is loaded:
apache2ctl -M | grep http2
On Red Hat-style systems, the equivalent is:
httpd -M | grep http2
If the output shows http2_module, the module is loaded. If it shows nothing, mod_http2 is not loaded, and this particular flaw does not apply to your server — though you should still keep Apache updated.
Step 3: Check Whether HTTP/2 Is Enabled in Your Configuration
A loaded module is only half the story. HTTP/2 also needs to be enabled in your configuration, usually through the Protocols directive. Look for a line like this in your Apache configuration:
Protocols h2 http/1.1
If h2 or h2c appears in your Protocols directive, HTTP/2 is enabled and your server is exposed if the version is affected. If neither appears, HTTP/2 is not active on that virtual host.
Step 4: Check Your Distribution’s Patched Package
Most servers do not run Apache compiled from source — they run a package from their Linux distribution, and distributions backport security fixes into their own package versions. Check your distribution’s security advisory for the patched package: RHEL 9 and 10, AlmaLinux, Fedora, Debian 12 and 13, Ubuntu 22.04 through 26.10, Alpine, and Amazon Linux 2 and 2023 all have fixes available. Install the patched package from your distribution rather than waiting for the upstream version number to change.
Takeaway: version plus loaded module plus enabled protocol is the full check. Any one of those alone can mislead you. Running those three checks is how you turn the question of what is CVE-2026-119618 into a yes-or-no answer for your server.
A Real-World Example: The Small Business That Almost Missed It
Imagine a small US business — a local accounting firm with a WordPress website, a client portal, and an online booking form. The site runs on a virtual private server with Apache 2.4.62 and HTTP/2 enabled, because the firm’s web developer turned HTTP/2 on years ago for speed. Nobody on the team is a security specialist. The server has not been updated in months because everything works fine, and nobody wants to risk breaking the booking form.
On 11 November 2026, the flaw behind what is CVE-2026-119618 is disclosed. The firm’s owner never hears about it. No alert reaches the inbox. The server keeps answering HTTP/2 requests exactly as before — and every one of those requests is a chance for an automated scanner to test the exploit.
This is not a fictional edge case. It is the normal state of thousands of small business servers. The fix takes minutes: update the Apache package, restart the service, and verify the version. The cost of not fixing it could be a breached client portal, stolen customer data, a defaced website, or a server conscripted into a botnet. For a small business, that is not just a technical problem — it is a reputation and legal problem too.
If that sounds like your setup, use the checklist at the end of this article. Patch first, then worry about whether anything else needs attention. And if you manage websites for clients, check every Apache server you are responsible for, not just the ones you remember setting up. For that firm, what is CVE-2026-119618 was not an abstract security story — it was an unpatched server with customer data on it.
How to Patch CVE-2026-119618: Step by Step

Patching what is CVE-2026-119618 is straightforward. The exact commands depend on your distribution, but the sequence is the same everywhere: update, restart, verify.
Step 1: Back Up Before You Patch
Before any update, back up your Apache configuration and your website data. A patch should not break anything, but a backup turns a bad day into a minor inconvenience. Copy your configuration directory and confirm your most recent site backup is complete.
Step 2: Update Apache to 2.4.71 or Your Distribution’s Patched Package
On Debian and Ubuntu, update the package list and upgrade Apache:
sudo apt update
sudo apt install --only-upgrade apache2
On RHEL, AlmaLinux, and Fedora, use:
sudo dnf update httpd
On Amazon Linux 2 and 2023, use the same dnf or yum update path for the httpd package. On Alpine, update the apache2 package with apk. In every case, the goal is the same: get Apache 2.4.71 or your distribution’s patched build that includes the fix for what is CVE-2026-119618.
If you run standalone mod_h2, remember there is no fixed standalone release. Migrate to the mod_http2 bundled with Apache 2.4.71 or to a distribution package. Do not keep running the archived module and hope for the best.
Step 3: Restart Apache
The new code does not take effect until Apache restarts. On Debian and Ubuntu:
sudo systemctl restart apache2
On Red Hat-style systems:
sudo systemctl restart httpd
Confirm the service came back up cleanly before you move on:
sudo systemctl status apache2
or the httpd equivalent on your system.
Step 4: Verify the Fix
Run the version check again:
apache2 -v
or httpd -v. Confirm you now run 2.4.71 or your distribution’s patched package version. Then confirm HTTP/2 still works as expected by loading your website in a browser and checking that pages serve normally. A quick check of your error log after the restart is also worth doing:
sudo tail -n 50 /var/log/apache2/error.log
If the log is clean and the site loads, the patch is in place.
Takeaway: update, restart, verify. Skipping the restart is the most common patching mistake — the vulnerable code stays loaded in memory until Apache restarts. Following those three steps is the practical fix for what is CVE-2026-119618.
What If You Cannot Patch Today? The HTTP/2 Workaround
Sometimes patching immediately is not possible. A change freeze, a legacy application that needs testing against the new version, or a maintenance window that is days away can all delay the update. In that case, there is a safe temporary workaround for what is CVE-2026-119618: disable HTTP/2.
To do it, find the Protocols directive in your Apache configuration and remove h2 and h2c from it. For example, change:
Protocols h2 http/1.1
to:
Protocols http/1.1
Then restart Apache. With HTTP/2 disabled, the vulnerable code path in mod_http2 is not reachable, and the flaw cannot be exploited.
Be honest about the trade-off: disabling HTTP/2 will make your site slightly slower for visitors, because HTTP/1.1 cannot multiplex requests the way HTTP/2 can. That is a real performance cost, but it is a small price for closing a critical remote code execution flaw. Treat the workaround as temporary. Re-enable HTTP/2 only after you have patched to 2.4.71 or a patched distribution package.
Takeaway: if you cannot patch today, disable HTTP/2 today. A slower site is better than a compromised server. That workaround buys you time while you plan the full fix for what is CVE-2026-119618.
What Else Did Apache 2.4.71 Fix?
Apache 2.4.71 is not a one-bug release. Alongside the fix for what is CVE-2026-119618, it also fixes CVE-2026-106023 and CVE-2026-109163. That is another reason to update rather than applying only a workaround: the update closes three vulnerabilities at once, not just the headline one.
If you are already planning a maintenance window, use it to bring Apache fully up to date. The 2.4.71 release is the complete answer to what is CVE-2026-119618, not a partial one, because it closes all three flaws at once. While you are there, check for other pending updates to PHP, your content management system, and any server-side applications. Attackers rarely stop at one vulnerability when a server offers several.
How to Tell If You Were Already Attacked
No confirmed in-the-wild exploitation of what is CVE-2026-119618 had been reported as of 20 November 2026, but that does not mean you should skip checking. Logs are your best friend here, and a quick review costs little.
Look for signs of exploitation in your Apache access and error logs: unusual crashes or worker restarts, especially around the time of the disclosure; a spike in HTTP/2 requests with no body and a Content-Type header; unexpected processes running as your web-server user; or new files in your web root that nobody on your team created.
If you find evidence of compromise, treat it as an incident, not a patching task. Knowing what is CVE-2026-119618 helps here too, because it tells you what to look for in the logs: HTTP/2 crashes and strange bodyless requests. Isolate the server, preserve the logs, rebuild from a known-good backup or a clean image, change credentials that may have been exposed, and consider bringing in incident-response help. Patching a compromised server without cleaning it leaves the attacker’s access in place.
For a broader look at protecting yourself after any suspected breach, see our guide on how to check if your email has been hacked — many server breaches lead to credential theft, and checking your accounts is a sensible next step.
CVE-2026-119618 vs Java4Shell: The Same Pattern, Again
If what is CVE-2026-119618 feels familiar, there is a reason. Just days earlier, the security world dealt with another critical unauthenticated flaw — Java4Shell, tracked as CVE-2026-114938. Our guide on what is Java4Shell (CVE-2026-114938) covers that one in the same plain-English style as this article.
The pattern is worth noticing. Both flaws are unauthenticated. Both affect widely deployed infrastructure software. Both drew a patch-now response from security teams. And both reward the same defensive habit: keep your server software updated, know what is running on your servers, and patch critical flaws the day the fix lands — not the day after an incident.
The lesson is not that software is hopeless. It is that the window between disclosure and exploitation keeps shrinking, and the organizations that patch fast are the ones that stay out of the breach headlines. If your patching process takes weeks, this is the moment to shorten it. The Java4Shell story and what is CVE-2026-119618 teach the same lesson in the same month.
Your Patch Checklist for CVE-2026-119618
Use this checklist as a sysadmin’s quick reference. Print it, paste it into your ticket, or run through it now.
- Check the version with
apache2 -vorhttpd -v. Affected: 2.4.55 through 2.4.70, plus Ubuntu 22.04 and 20.04 via backported mod_http2. - Check the module with
apache2ctl -M | grep http2. Ifhttp2_moduleis loaded, continue. - Check the configuration for
h2orh2cin theProtocolsdirective. If HTTP/2 is enabled, you are exposed. - Back up your Apache configuration and website data.
- Update to Apache 2.4.71 or your distribution’s patched package. Standalone mod_h2 users must migrate to bundled mod_http2 — there is no fixed standalone release.
- Restart Apache so the patched code actually loads.
- Verify the new version and confirm the site loads normally.
- If you cannot patch today, disable HTTP/2 by removing
h2andh2cfrom the Protocols directive, restart, and schedule the patch as soon as possible. - Check the logs for crashes, restarts, or unusual HTTP/2 requests since 11 November 2026.
- Repeat for every server. Check staging, development, and forgotten test servers too — attackers scan everything, not just production.
Takeaway: the checklist takes minutes per server. The breach it prevents can take weeks to clean up. Work through it once for every server, and you will know exactly where you stand on what is CVE-2026-119618.
Protecting Your Server After the Patch
Patching what is CVE-2026-119618 closes this hole, but good server hygiene closes the next one faster. A few habits pay off far beyond this single vulnerability.
First, keep a list of every server you run and what software it runs. You cannot patch a server you forgot exists. Second, subscribe to your distribution’s security announcements and to Apache’s announcement list, so critical fixes reach you the day they land. Third, automate updates where you safely can, or at least schedule a weekly window for security updates.
Fourth, reduce your attack surface. If you do not need a module, do not load it. After you have fixed what is CVE-2026-119618, that habit is what protects you against the next module flaw. If you do not need a service, do not run it. Every enabled feature is a potential target, and HTTP/2 is a good example: it is useful, but if you ever decide you do not need it, turning it off removes an entire class of risk.
Finally, think about the wider resilience of your site. A server compromise is one kind of attack; a flood of traffic is another. Our guide on DDoS attacks and how to protect yourself covers the defenses that keep your site online when someone tries to overwhelm it rather than break into it.
Frequently Asked Questions About CVE-2026-119618
What is CVE-2026-119618?
What is CVE-2026-119618? It is a critical race condition (CWE-362) in the assign_headers() function of Apache HTTP Server’s mod_http2 module. It allows unauthenticated remote code execution on servers with HTTP/2 enabled. It was disclosed on 11 November 2026, carries a CVSS score of 9.8 Critical, and is fixed in Apache HTTP Server 2.4.71.
Which Apache versions are affected by CVE-2026-119618?
Apache HTTP Server 2.4.55 through 2.4.70 is affected, along with standalone mod_h2 2.0.8 through 2.0.42. Ubuntu 22.04 (apache2 2.4.52) and Ubuntu 20.04 (2.4.41) are also affected because Ubuntu backported a newer mod_http2 into those releases. The fix is Apache 2.4.71 or your distribution’s patched package.
Do I need to worry about CVE-2026-119618 if HTTP/2 is disabled?
No. The flaw is only reachable when HTTP/2 is enabled, because it lives in the HTTP/2 module’s code. If mod_http2 is not loaded, or if h2 and h2c are not in your Protocols directive, this vulnerability cannot be exploited on your server. You should still keep Apache updated, but this specific flaw does not apply to you.
Is there a public exploit for CVE-2026-119618?
Yes. A reliable public exploit has been demonstrated, and public proof-of-concept code reproduces heap corruption and crashes. Full weaponized remote code execution code had not been publicly released as of mid-November, but the demonstrated heap corruption is the critical part. No confirmed in-the-wild exploitation had been reported as of 20 November 2026.
How do I fix CVE-2026-119618?
Update Apache to version 2.4.71 or install your distribution’s patched package, then restart Apache and verify the new version. If you cannot patch immediately, disable HTTP/2 by removing h2 and h2c from the Protocols directive and restarting Apache. Standalone mod_h2 users must migrate to the bundled mod_http2 in Apache 2.4.71 or a distribution package, because the standalone project was archived in June 2026 and has no fixed release.
What is the CVSS score of CVE-2026-119618?
Red Hat scored what is CVE-2026-119618 at CVSS 9.8 Critical, while CISA scored it 8.1. Both scores place it in the high-to-critical range. The difference reflects different scoring assumptions, but the practical message is the same: treat it as a critical, patch-now vulnerability.
Conclusion: What Is CVE-2026-119618 Tells Us About Patching Fast
So, what is CVE-2026-119618, in the end? It is a critical race condition in Apache’s HTTP/2 module that lets anyone on the internet potentially run code on your server — no login required. It affects Apache 2.4.55 through 2.4.70, standalone mod_h2 2.0.8 through 2.0.42, and even some older Ubuntu releases through a backported module. It was found independently by Anthropic’s OSS Scanner and Google Cloud Vulnerability Research, disclosed on 11 November 2026, and fixed in Apache 2.4.71.
The fix is simple, the workaround is simple, and the risk of waiting is not. Check your version, check whether HTTP/2 is enabled, patch to 2.4.71, restart Apache, and verify. If you cannot patch today, disable HTTP/2 today and patch as soon as you can. Then check your other servers, check your logs, and make a habit of patching critical flaws the day they land.
Apache runs a huge share of the web, and that is exactly why what is CVE-2026-119618 matters. Your server is one of the many — and that is also why patching it takes only minutes. Do it now, before someone else finds your server first.