Home Blog Why Governments Shut Down Their Websites to Counter Two Critical Security Flaws

Why Governments Shut Down Their Websites to Counter Two Critical Security Flaws

TahaSite Editor
Oct 27, 2026
187 Views
Why Governments Shut Down Their Websites to Counter Two Critical Security Flaws

The discovery of two critical security flaws, collectively named PHP2Shell, in the PHP engine has forced organizations and websites to shut down some of their digital services to prevent unauthorized access.

On Wednesday, October 21, 2026, the website of the Dutch National Cyber Security Centre went offline. Simultaneously, the MijnOverheid government services portal and the website of the Dutch House of Representatives were also taken down. However, the attackers did not crash these websites; the administrators themselves decided to cut off access.

The root of these preventive shutdowns in the Netherlands traces back to two dangerous vulnerabilities in PHP, a widely used programming language upon which a large portion of the web is built. The flaws allowed attackers to execute commands on vulnerable servers under specific conditions without needing a user account. The risk was so severe that in one proven attack vector, the exploit could be triggered even before the website's code was executed. The Dutch government preferred to take some services offline until security patches were installed.

The two vulnerabilities, identified as CVE-2026-109618 and CVE-2026-109619 and collectively known as PHP2Shell, have received a severity score of 9.2 out of 10. But the story of PHP2Shell did not begin in October 2026. Join us as we explore how a flaw in a language engine led to the temporary suspension of government services in at least 12 countries—from Dutch citizen portals and 32 UK government services to the website of the Presidency of South Africa.

Where does PHP fit into our digital lives?

The shutdown of several government services in the Netherlands was just one of the consequences of a crisis that could have affected a large portion of the web. Many websites use PHP behind the scenes; for example, WordPress, Drupal, Joomla, and MediaWiki—the software that powers Wikipedia—are all built with PHP. According to W3Techs statistics on October 22, 2026, approximately 69.3 percent of websites with an identified server-side programming language were using PHP.

Nearly 70 percent of websites with an identified server-side programming language use PHP.

It is important to note that the PHP2Shell vulnerabilities were found within PHP itself, not in WordPress, a specific plugin, or a programmer's error on a website. In fact, any website running on a vulnerable version was at risk, even if its own code was flawless. According to Wiz, even a simple "Hello World" program on a vulnerable version could have been a victim.

Of course, the provided statistics represent the ceiling of the vulnerability, not the number of sites that were actually attacked; however, the widespread use of PHP explains why, when news of the two vulnerabilities broke, everyone from government organizations to hosting providers and content delivery networks scrambled simultaneously.

What happened inside the PHP engine

To understand what the danger really was, consider a simple analogy. Think of the PHP engine as a kitchen where several chefs work. Each chef acts as a "worker process," and they prepare orders—that is, user requests—one after another.

The root of both vulnerabilities stems from the fact that a chef processes multiple orders in succession; because if anything from the previous order is left on the table, it might find its way into the next order. Both weaknesses can be considered related, as they are both memory management errors, especially when memory runs out mid-process.

When you fill out a form on a website and click the "Submit" button, the information does not reach the application code directly. On websites that use PHP, the language's engine first reads the request, organizes the data in memory, and then provides it to the application. Everything seems simple and routine; however, one of the most dangerous attack vectors of PHP2Shell was hidden precisely in this stage.

Incomplete memory management between requests was the weak point of the PHP engine and the root cause of the recent vulnerabilities.

PHP usually has a specific amount of memory available to process each request, which is called memory_limit. If the memory consumption of a request exceeds this set limit, the engine sometimes interrupts the current operation to clean up the information created up to that point. The problem began when this sudden interruption left some internal data in an invalid state.

In one of the vulnerabilities, PHP relied on information that had not yet been fully constructed while sanitizing the same request. In another, invalid data remained from a previous request and could potentially affect the processing of the next request. Security researchers demonstrated that these errors could be exploited to manipulate the behavior of the PHP engine and even execute commands on the server.

First Vulnerability: The Half-Built House

When a browser sends web form data via a POST request, PHP reads the names and values of the fields before executing the application code and places them in an internal table called $_POST. This table has slots and counters within the engine. Datadog researchers discovered that in one of the paths for adding data to the table, PHP first increments the counter for used slots and then allocates the necessary memory for the new field name. If memory runs out exactly during the interval between these two operations, the counter points to a slot that has not yet been constructed.

Now, imagine the chef from the previous example who has an order logbook; before writing the details of a new order, he increments the order number and writes it at the top of the page. If he has already recorded 10 orders, the eleventh order arrives and he writes 11 at the top of the page, but he runs out of paper before he can write the actual details of the eleventh order.

PHP sometimes identified an incomplete slot in memory as valid.

The next chef looks at the number at the top of the page, even though only 10 orders have actually been placed. When they reach the eleventh order, instead of valid order information, they might encounter old notes, scribbles, or irrelevant data. This exact mistake created an opportunity for an attack. The engine relied on the counter during cleanup and read the contents of the half-finished slot as valid data. Researchers demonstrated that an attacker, by carefully crafting requests and manipulating memory layout, could place their own data into that half-finished slot.

In the Datadog experiment, this same chain on Apache with mod_php led to the execution of an operating system command; PHP executed the attacker's command before reaching the website code and without user input—a situation technically known as Remote Code Execution (RCE), which, if successful, can pave the way for data theft, site manipulation, or malware installation.

Second Vulnerability: Information That Should Not Have Remained

The second weakness related to what happened between two requests. A PHP worker process can process multiple requests during its operation. Information for each request should be freed at the end of the task, and the process's internal state should be properly prepared for the next request; however, sometimes a fatal error would leave the process incomplete, and while the memory belonging to the previous request was freed, some pointers—the addresses that PHP uses to find information in memory—remained.

Some memory addresses remained after the previous request's information was freed.

In such a situation, the next request reaching the same process might use old addresses; as if information that no longer existed was still valid. Software engineers call this error a use-after-free. On the other hand, if an attacker could fill the freed memory location with their own arbitrary data, PHP might consider that data as part of its internal structure.

An attack that makes no noise: Memory leakage

فیل رباتیک با بدنه از قطعات الکترونیکی در میان ذرات درخشان
siliconangle

The PHP2Shell vulnerability also posed another risk, for which the attacker did not even need to reach the command execution stage. Wiz researchers demonstrated that one of the vulnerability paths could expose part of the PHP process memory to the attacker; memory that might contain passwords, authentication tokens, API keys, and credentials of other users or the server itself.

In the kitchen analogy, you can imagine the chef accidentally putting a piece of a previous customer's order into your dish. In this path, after an out-of-memory error, the address related to the user session ID pointed to memory that had already been freed. When the next request reached the same process, PHP might read the information present in that location and place it inside the PHPSESSID cookie in the response to the browser; thus, the attacker would receive data that did not belong to their own request.

In one of the attack paths, the attacker could read information from PHP's memory without executing a command.

Unexpectedly, according to Wiz's testing, this path worked even when the web application itself had not called the session_start() function, because the process related to file upload progress could begin before the application code was executed. Wiz compares this risk to Heartbleed, the famous 2014 vulnerability that allowed reading portions of server memory.

Wiz researchers reported a total of four exploitable paths under two PHP2Shell identifiers: use-after-free in file upload data processing, process memory leakage, use-after-free in fatal error information, and a "type confusion" error in OPcache, the mechanism PHP uses to store pre-compiled code. The company warned that other variants of this same pattern, whether tracked or untracked, still exist in PHP code.

Why security plugins did not help

Why did service owners shut down their sites until the patch was ready, despite having standard security measures in place? Because both PHP2Shell weaknesses reside at a layer below the application.

Some attack paths were activated before the code and security tools within the website were executed.

In some attack paths, by the time a security check within WordPress or any other application is executed, PHP has already passed the vulnerable stage; therefore, a security plugin running within the application itself cannot stop the attack on its own.

Of course, web firewalls and security tools deployed at the network edge could identify and block some malicious patterns before requests reached PHP. Cloudflare and other infrastructure companies implemented such measures; however, these tools could not cover all attack vectors. The primary solution was to patch PHP itself.

The bug that waited two years

The root of the story goes back to a seemingly harmless bug in 2024, when the PHP Foundation, with financial support from the German Sovereign Tech Agency and through the OSTIF organization, commissioned an external security audit of the language's code to the company Quarkslab. While fixing one of the audit findings, a developer working with the Foundation observed concerning behavior during low-memory conditions; the same abrupt termination of operations we explained earlier.

At that time, the possibility of exploitation was raised; however, no one could find a clear way to turn it into an attack. Fixing the problem was not easy either, as the proposed solutions either threatened backward compatibility, could create new disruptions, or required changes to a large number of other extensions.

The root of the vulnerabilities was identified in 2024

A small group of engineers who had mastery over the internal parts of PHP had to reach a consensus on a solution while juggling other tasks, and the work was stalled multiple times. The Foundation later described this delay as a "structural failure" in its resources and decision-making process, as reported by TahaSite.

Perhaps you have already noticed a major contradiction. PHP is open-source software, and any researcher can read its code; however, the maintenance of a sensitive part of the engine remained dependent on the deep knowledge and time of a very small group. In 2024, it was still unclear how far this bug would go. In August 2026, researchers finally demonstrated that it could be exploited to execute commands on the server.

When AI turns on the exploit-generation engine

The vulnerable code had existed in PHP for years, and some of the affected versions dated back as far as PHP 5.4, released in 2012. Some sources trace the architectural roots of these flaws even further back to the release of PHP 5 in 2004; what changed in 2026 was not the bug itself, but the ability to turn it into an efficient and practical attack.

Constructing such an attack required identifying and combining several errors along with numerous tests. According to the security firm Wiz, advanced AI models made this difficult process much faster. The company used Wiz Atlas, Gemini 4 Argon, and GPT-5.6 Sol to create and adapt functional exploits for several different applications. According to Wiz, a single researcher accomplished in one week what previously took a top-tier team months to complete.

According to Wiz, AI has drastically reduced the time required to build and adapt exploits.

The discovery timeline also seemed busy. The PHP Foundation formed the Ecosystem Security team in May 2026, and the security firm Calif began auditing PHP as part of the Patch the Planet program on July 30, 2026. On August 11, a researcher named Ryan A from the same company reported that they had managed to use the same issue identified in 2024 to execute commands on the server. OpenAI reported the same root cause independently and simultaneously. Wiz identified and reported other exploitation paths on August 24, followed by OpenAI on September 18.

Note that the progress made has a flip side. The tools that helped defenders and security researchers can also assist attackers in comparing patched versions with previous code, reproducing vulnerabilities, and automating the search for unpatched servers.

In fact, artificial intelligence could make both finding security issues and exploiting them easier; just as one researcher told a Luxembourg publication that advanced AI tools now make intrusion easier for attackers.

October 20 and 21; When the Window of Opportunity Narrowed

نمودار و آمار مربوط به سرویس‌های آسیب‌پذیر PHP2Shell در پنل CENSYS
داشبورد شرکت امنیت سایبری Censys، شمار سرویس‌های اینترنتی دارای نسخه‌های آسیب‌پذیر PHP و روند به‌روزرسانی آن‌ها پس از افشای PHP2Shell را نشان می‌دهد. این آمار به معنای تأیید نفوذ یا آسیب‌پذیری قطعی تمام سرویس‌های شناسایی‌شده نیست.Censys

PHP patches were scheduled to be released on Thursday, October 22, 2026; however, on Tuesday, October 20, around 15:00 UTC, identifiers for two vulnerabilities were leaked on forums and social media. The published information even contained some errors, including a risk score of 10 out of 10, while the actual score was 9.2. According to the PHP Foundation, technical details of the attack had not yet been disclosed at that stage, but the coordinated patch release schedule was disrupted.

The PHP Foundation issued a statement that same night and moved the release date of the patches one day earlier. An immediate release was not possible, as distributors still had to convert the corrected code into packages that administrators could install on their servers. Shortly after the announcement, the security firm Calif mistakenly published a video demonstrating an example of the attack. The video was quickly removed, but copies remained on social media.

Early disclosure of vulnerability information moved up the release of patches by one day

On Wednesday morning, the company Chainguard also made images containing the patches available ahead of the coordinated time. The PHP Foundation protested this decision because an attacker could analyze the changes in the patched version and reconstruct the vulnerability, while many administrators were still waiting for the official package.

In the Netherlands, the National Cyber Security Centre advised organizations to assess the risk for each of their services and, if necessary, disconnect access to their websites until the patch was installed. Several government agencies made the same decision. The patches were finally released on Wednesday, October 21; however, restoring the websites depended on installing and testing them.

The subsequent report pushed the threat timeline even further back. Amazon, in its security honeynet data, discovered a suspicious attempt to exploit PHP2Shell dating back to October 17—four days before the public disclosure of the vulnerabilities. It is still unclear how the perpetrator obtained the necessary information, but it indicated that suspicious activities had begun even before the official news was released.

Millions of attacks in a few days; a hot market for exploitation after patch release

Four patched versions of PHP, namely 8.5.12, 8.4.27, 8.3.36, and 8.2.35, were released on Wednesday, October 21. Changes to the source code were also provided for older versions; however, these versions no longer have standard support, and installing a patched older version depends on a valid distributor package or extra work by the server administrator.

The patch for the first vulnerability changed how PHP handles memory exhaustion so that semi-constructed data is never left in a dangerous state. For the second vulnerability, the state belonging to the previous request is cleared before reuse. The important point for server administrators was that changing settings does not replace the patch; only installing the patched version solves the problem at its root.

Attackers continued their assaults even after the patch was released; for example, Cloudflare observed traffic designed to attack its customers and reported that attackers were changing the format of the sent data to bypass protections. Cloudflare's statistics show how quickly attempts to exploit PHP2Shell increased. According to Matthew Prince, the company's CEO, thousands of attack attempts were recorded on the Cloudflare network in the 10 hours before the official public announcement of the vulnerabilities.

According to security reports, by October 22, the number of attack attempts had reached millions.

Just 45 minutes after the official announcement, the number of attempts reached tens of thousands and exceeded hundreds of thousands within two hours. By the time the Cloudflare CEO released these statistics on October 22, the number of attempts had reached millions.

Reports from other companies also indicated the rapid spread of the attacks. By October 22, Wordfence had blocked more than 74,000 attack attempts, vulnerability scans, and related activities; however, these statistics do not mean successful breaches, as security firms report the number of suspicious requests observed across their networks.

On October 23, the PHP team announced another related vulnerability with the identifier CVE-2026-115560, which was not covered by the October 21 patches. Developers assessed the probability of practical exploitation as low and stated that they would provide a fix in the next release.

The path to staying secure; what should server administrators and users do now?

If your website is on shared hosting, the hosting company is usually responsible for updating PHP. You can check the PHP version through your hosting control panel and ask support whether the PHP2Shell patches have been installed. Note that some companies provide security patches without changing the main version number.

WordPress users can check their installed version by navigating to "Tools → Site Health → Info → Server."

If you manage the server yourself, you must update PHP to one of the patched versions mentioned above. After installation, PHP processes must also be restarted so that the old version does not remain active in memory. If you are using containers, check their updates separately as well.

For older and unsupported versions of PHP, first check whether your Linux distribution or hosting provider offers a valid security package. If no patch is available, you must restrict public access to the server and plan for a migration to a supported version. Tools like firewalls can mitigate the risk, but they do not replace the need for installing patches.

The PHP team specifically recommends disabling the session.upload_progress.enabled setting and restarting PHP processes. Take this recommendation seriously even after the patches are released; on October 23, the PHP team announced another potential vector for malicious code execution under specific conditions, which is scheduled to be fixed in the next update.

If you have delayed the update, it is also important to check web server logs for suspicious activity. Installing the patch prevents further exploitation of the two main vulnerabilities, but you must determine whether a breach has already occurred.

Unusual requests for data submission or file uploads, frequent out-of-memory errors, suspicious 500 responses, and sudden termination of PHP processes can be signs that warrant further investigation. The execution of unknown commands, unexpected connections to external servers, and modifications to sensitive files should also be examined.

Perhaps the biggest lesson from the PHP2Shell incident is that the danger does not immediately disappear even after a vulnerability is identified and fixed. There is a gap between the release of a patch and its installation on thousands of servers, which attackers can exploit. The shorter this gap, the less opportunity there is for exploitation.

From other members of the TahaSite family

Removal of 15.5 million people from the electronic subsidy voucher (Kalabarg) is finalized

متن انگلیسی درباره قطعی وب‌سایت‌های دولتی کانادا به دلیل آسیب‌پذیری امنیتی
اطلاعیه‌ی اختلال خدمات در وب‌سایت دولت کانادا، ۲۱ اکتبر ۲۰۲۶.wikimedia commons/ Government of Canada

Best French films of 2026 | From acclaimed dramas to surprising works + IMDb ratings - Filmzi

Israel elections; what happens if no one wins?

Documentary "You Can See Everything"; when the line between reality and performance disappears

What to do if your flight seat is changed without permission

رابط کاربری ابزار PHP2Shell برای اجرای دستورات و کشف خودکار هدف
The Hacker News

Driving experience with the new BMW X5; a close look at specifications and technologies

The magic of the electronic manual transmission in the Ferrari 12Cilindri Manuale

Comparison of Dongfeng M-Hero 2 and BAW 212, the best imported off-road SUVs

From Bruce Lee to Abbas Kiarostami | Introducing films completed after the director's death - Filmzi

لوگوی بنیاد ویکی‌مدیا (Wikimedia Foundation) در کنار پیام خطای سیستم
Wikimedia Foundation Creative Commons Attribution 4.0 International

Off-road test and review of the electric Range Rover; how is the most luxurious electric SUV?

PlayStation 5 security breach only 8 hours after the new update

Can GTA 6 break the historic record of Expedition 33 at The Game Awards?

5 decoration mistakes that ruin the beauty of your home

A new plan for Iran's internet; is the third "Protection Bill" being initiated in Parliament?

IRIB's lawsuit against Aida Panahandeh and the series "Badnam" in the ethics court

Tags:
cybersecurity security flaws PHP vulnerability government websites data protection
TahaSite

TahaSite

Since childhood, I have always been fascinated by computers and technology. My passion for programming and web development has driven me to constantly learn and create. At TahaSite, my goal is to provide the latest tech insights and build cutting-edge software infrastructure.

Comments

No comments yet. Be the first!