AI Has Turned the Entire Software Ecosystem into a Sieve: The Darkest Hour for Full-Stack Developers
In mid-October, high-severity vulnerabilities were disclosed in rapid succession across foundational infrastructure and language runtimes including the Linux kernel, Nginx, GitLab, Chrome, PHP, Node.js, and Go, with GitLab even seeing two consecutive CVSS 10.0 maximum-severity vulnerabilities. LiteLLM v1.107.0 was hit by a supply chain poisoning attack, the secret-hosting platforms of Railway and OpenCode were breached, and 1.4% of OpenCode users' keys may have leaked. AI has also become an attack tool: attackers used ARTEX combined with large models to breach South Korean financial institutions, and Claude Opus 4.6 in Cursor once deleted a production database within 9 seconds.
Body · AI translation
Imagine you're an ordinary developer who has just arrived at your desk in the morning, only to find that the entire internet infrastructure is taking turns breaking down. GitLab has disclosed a critical vulnerability with a perfect score of 10.0, Chrome has rushed out a fix for a high-severity flaw, Node.js and PHP have been hit one after another, LiteLLM has suffered a supply chain attack, eMudhra's certificate private key has leaked, and even the cloud deployment platform Railway has had a security incident—users' API keys, environment variables, and other sensitive information are facing the risk of full exposure.
In just a few days, this storm has swept across the entire software ecosystem. From browsers, development tools, and code hosting to upper-layer applications and cloud deployment platforms, the full-stack tech stack that was once a source of pride has instantly become a "vulnerability combo platter": the underlying Linux has a privilege escalation flaw, the database TiDB has been found to have security issues, and even the HTTPS certificates bought at great expense have been discovered to have been signed by an Indian CA with an 8-bit key.
This is clearly no longer just a few isolated security incidents. These vulnerabilities may not be technically related, but when more and more underlying infrastructure is densely exposing problems at the same time, quantitative change may lead to qualitative change. Moreover, in this chaos, AI is no longer just a "good helper" that writes code for people—it has begun to transform into the sharpest spear: some are using AI to launch cross-border attacks on South Korean financial institutions; and some developers asked AI to handle a test environment issue, only for the Agent to delete the production database, backups and all, in 9 seconds.
As more and more underlying infrastructure exposes problems at the same time, no one knows whether the next time will trigger an irreversible chain reaction. Today, taking this "high-severity vulnerability showcase" as an opportunity, let's coolly take stock of this fully tense cyber battlefield. I hope the current pileup of crises is merely excessive worry, and I hope even more that this battle royale of underlying infrastructure ultimately does not affect every ordinary person.
1 The Fall of the Underlying Layer and Infrastructure
One illusion developers are most prone to is believing that as long as they use mature open-source software, they can rest easy. But this concentrated wave of vulnerabilities has taught everyone a solid lesson.
The first to suffer was the Linux kernel, the cornerstone of everything.
On October 15, the Linux kernel CVE team officially disclosed an extremely critical virtualization escape vulnerability—CVE-2026-99999. This vulnerability is buried deep in the underlying logic of the Linux kernel's trust boundary when handling network checksums (CHECKSUM_PARTIAL).
In a lab environment, the autonomous security research engine (from the pwn.ai team) successfully demonstrated how to precisely break through KVM's core defenses by maliciously tampering with validated IPv4 header data. Attackers can not only force the host to leak 32 bytes of critical memory data, but even directly complete a full host VM escape, instantly seizing Root-level highest execution privileges on the host. According to subsequently disclosed tracking details, just one day before the vulnerability was made public—on October 14—Linux founder Linus Torvalds had urgently merged the fix patch for this vulnerability into the mainline kernel tree.
This means that the "tenant isolation sandbox" that modern cloud-native environments are proud of instantly becomes useless in the face of this lethal vulnerability chain.
Following the Linux kernel was Nginx, likewise a cornerstone.
On October 14, the Nginx team urgently released a new version and disclosed five security vulnerabilities, including three top-tier critical flaws with CVSS 4.0 scores as high as 9.2. These five flaws tore open the defenses of millions of edge gateways worldwide almost overnight.
The most lethal, CVE-2026-15176, exists in the combined configuration of the alias directive and the $request_filename variable; attackers can trigger a heap buffer overflow in the system's underlying layer through malicious HTTP requests, thereby directly achieving remote code execution (RCE) or causing the service to completely collapse. CVE-2026-93479, which likewise points to memory safety, exploits the variable capture mechanism of map directive expressions and can be remotely exploited to trigger a heap overflow. CVE-2026-97205 occurs in scenarios where asynchronous I/O (AIO) and server-side includes (SSI) are both enabled, and due to underlying logic confusion, it causes a high-severity use-after-free error.
More seriously, CVE-2026-97629 even affects transport layer security: attackers can exploit a TLS session ticket rotation flaw to directly bypass client certificate (Client-Cert) compliance verification under certain configurations. This means that the once-impregnable mutual TLS (mTLS) authentication defense line may become an undetectable open door in front of attackers.
The destructive power of these five vulnerabilities lies in the fact that they directly strip away Nginx's security core as a "gatekeeper": hackers can not only gain a shell directly through heap overflow or cripple the service with DoS, but even exploit TLS flaws to forge identities and silently bypass client certificate verification. This directly renders enterprises' supposedly secure internal network isolation defenses instantly useless.
Next came GitLab, the core hub of development workflows, which on October 12 and October 21 successively disclosed two perfect-10 catastrophic vulnerabilities (CVE-2026-97229 / CVE-2026-110264). Due to an integer overflow flaw in the underlying CI/CD compiler, any unauthenticated remote attacker can, with just a specific malicious request, directly breach the server and execute arbitrary code at the system's lowest level.
The terrifying aspect of this 10-level vulnerability is that it completely shatters the most core trust chain of the software delivery lifecycle. Hackers can fully take over your self-hosted GitLab instance without any initial credentials, which means the core source code assets that enterprises rely on for survival, as well as the CI/CD automated pipelines that hold deployment authority, will be instantly exposed to the attacker's absolute control.
And what makes enterprises' defense networks even worse is that hackers have even obtained the prerequisite key to breaching GitLab—Google Chrome urgently released a security update on October 20, fixing as many as 353 security flaws in one go. Among them, 6 vulnerabilities were rated at the highest severity level, Critical.
The most notable is CVE-2026-113072 in the CSS module, with a score as high as 9.6; attackers can use carefully crafted web styles to trigger memory corruption and forcibly execute arbitrary malicious code outside the sandbox. Most strikingly, the shadow of AI offense and defense has appeared among these critical flaws for the first time: the OpenAI team reported a memory flaw in WebRTC (CVE-2026-113303); while the Anthropic team, with the assistance of the AI assistant Claude, precisely identified a residual use-after-free vulnerability in accessibility features (CVE-2026-113271).
2 The ecological crisis of programming languages and the supply chain
While underlying systems and middleware were falling across the board, the three core programming language environments that serve as the foundation of application software did not escape either, and on October 21 they collectively fell into a "patch storm":
First to be thrust into the spotlight was a severe vulnerability incident affecting the global PHP ecosystem. Because researchers used AI to discover two ultra-high-severity vulnerabilities, collectively called PHP2Shell (CVE-2026-109618 / CVE-2026-109619), their technical details were leaked ahead of schedule on October 21.
Hackers do not need to log in at all; they may be able to directly take control of an entire website server by sending just one malicious request, installing trojans in the background, stealing data, or even taking the website down.
For a time, multiple government cybersecurity departments and AI companies urgently issued notices overnight; including Finland, the Netherlands, and France, which took government websites offline in emergency. Currently, more than 5.1 million PHP servers are exposed on the internet worldwide. Cloudflare CTO said early attacks have been observed, and the UK National Cyber Security Centre (NCSC) directly advised that "systems that cannot be patched should be taken offline first." Massive numbers of websites across Europe were therefore forced into a state of shock and shutdown, and the PHP team has released patches requiring everyone to upgrade immediately.
At the same time, Node.js also suffered a comprehensive sweep on October 21, with officials publicly fixing 10 core security flaws in one go.
The highest danger level given by the officials was High. As the backend foundation for massive numbers of websites such as PayPal, Netflix, and LinkedIn, this issue was precisely located in Node.js's built-in decompression tool. When transmitting data in everyday web pages, systems often call this tool to compress data, and hackers can deliberately create a malformed compressed package and send it to the server, triggering an underlying error at the moment the server decompresses it. At best, this flaw can lead to the leakage of sensitive passwords or keys inside the system; at worst, it can directly let malicious actors run arbitrary malicious code on the server, effectively handing over server control.
However, the good news is that this flaw is only triggered when a website program or a referenced dependency library actively decompresses data from external sources, so it has not caused widespread panic in the industry like PHP did.
Finally, the Go language (Golang) also urgently released a key update to its cryptography library on October 21, correcting a flaw in the underlying certificate trust verification logic. The vulnerability exists in the crypto/x509 authentication system of the standard library; attackers can use carefully forged certificate chains to directly deceive microservice components written in Go. This causes the originally extremely strict service-to-service authentication (such as gRPC mutual trust or cloud-native webhook verification) to completely lose its defense line, and the cornerstone of trust between internal services is instantly reduced to ashes.
Compared with traditional language-level logic vulnerabilities, the LiteLLM supply chain poisoning incident demonstrates a security threat of another dimension.
As an AI model access gateway with weekly downloads as high as 23 million, LiteLLM's v1.107.0 version was found to have malicious code implanted. The hackers did not struggle with the source code; instead, they stole the developer's publishing credentials and stuffed a trojan into the final PyPI installation package and Docker image. This means that even if you reviewed the open source code on GitHub line by line and found no problems, the package you actually pull and run is still poisoned. For AI developers, this is undoubtedly a heavy blow, because LiteLLM often touches the API Keys and core credentials of major model vendors.
3 Key hosting platforms fall: when API Keys become the credit cards of the AI era
If LiteLLM poisoning is stuffing a trojan into the toolchain, then the successive incidents at Railway and OpenCode show that the platforms hosting keys themselves are becoming the new bullseye for attackers. Within one week, two platforms that keep AI keys on behalf of developers were compromised, and the sensitive information involved included API Keys that can directly call model services. In AI services billed by usage, a leaked key is like a credit card for computing resources that may be fraudulently charged.
On October 21, cloud hosting platform Railway issued a security advisory stating that unauthorized third parties may have accessed customers' encrypted environment variables and obtained the decrypted contents of some of them. These variables may contain database passwords, API keys, and private image repository credentials, which after leakage could be used to access customer systems or steal model services.
Railway preliminarily judged that the impact may be limited to some users, and will notify them by email after confirming the affected accounts. The company believes that this incident may belong to a recent series of attacks targeting platform companies with the aim of gaining access to AI inference services, and has notified upstream service providers to proactively revoke keys. At the same time, Railway recommends that all users immediately rotate the relevant credentials stored on the platform and check the logs of associated services for abnormal activity.
What is more troublesome is that the incident also affected developers publishing applications: Railway suspended all deployments during the investigation. At 11:32 on October 22, the company officially announced that enterprise builds had resumed, and the Pro, Hobby, Free, and Trial plans would resume in stages in that order.
Similar risks also appeared on the AI programming tool OpenCode. On October 17, the OpenCode web backend was breached, and the OpenAI, Anthropic, and Google keys stored by 1.4% of OpenCode Console users may have leaked.
OpenCode said the incident was related to a large-scale "distillation attack," has notified affected users by email, and is working with the relevant model service providers to handle it. Some users reported unauthorized usage charges on their model accounts, and some said abnormal bills of several hundred to more than 1,700 US dollars appeared overnight.
As agents, projects, and runtime environments increase, the number of keys teams need to manage may also grow. Once permissions are set too broadly and rotation is not timely, centralized hosting may concentrate risk: if an attacker breaches one platform, they may obtain a batch of directly spendable "credit cards" all at once.
4 The strongest vault, with the password "4"
Cryptography sounds profound and unfathomable, but failures in real-world engineering are often extremely absurd. The little green HTTPS lock we visit every day relies on an extremely strict certificate authority (CA) trust chain.
Recently, Indian CA organization eMudhra blew up a shocking scandal: the private keys used by 8 of its intermediate CA certificates had serious generation flaws. Under normal circumstances, an elliptic curve private key should have an extremely large random value space, but security researchers found that the actual values of these certificates' private keys were all less than 256, meaning they could be represented with only 8 bits.
Even more absurd, just how simple were these private keys? Security researcher Scott Helme, while analyzing the eMudhra certificates, found that one of the private keys was actually the number "4." Helme wrote in his article: "Not a number starting with 4, nor 4 followed by hundreds of random digits, just an ordinary 4... Another private key is 56, and another is 115. I know because I just recovered all the private keys from these public certificates on my own laptop, and the whole process took less than a second."
Other researchers also successively recovered private keys with values of 66, 155, 156, 230, and 237. This is like equipping the world's top vault with the most advanced anti-theft door, only for the administrator to set the password to "4." So-called high-strength cryptographic protection is almost useless in the face of such a low-level mistake.
Because the private keys' value range was astonishingly small, an attacker could recover the private keys through brute-force enumeration in an extremely short time. More seriously, these private keys belonged to intermediate CAs with certificate-signing capability; once recovered, an attacker could forge website certificates issued by the affected CAs and, given conditions such as traffic interception, carry out man-in-the-middle attacks.
Although browser vendors such as Google and Mozilla acted quickly and revoked trust in the relevant certificates, the associated trust risks may still persist for a large number of intranet systems, old clients, and embedded devices that have not been updated in time. Most ironically, the entire incident did not even require an attacker to crack any complex cryptographic problem. A certificate system that should have used high-strength random keys ultimately lost to the number "4." The strongest fortress is often breached from the most slapdash link inside.
5 Rampant AI: the sharpest spear, the most out-of-control gun
From late September to early October, multiple South Korean financial institutions suffered successive cyber intrusions and data leaks. On October 7, cybersecurity company CrowdStrike released an investigation report stating that the attackers used the open-source agentic penetration-testing tool ARTEX and combined it with large models to carry out attacks against South Korean financial institutions.
Researchers found ARTEX configuration files, Claude Code session histories, and memory files in an open directory on the relevant servers. These materials show that the attackers used AI tools to conduct a large amount of activity targeting South Korean financial institutions; in the session records, the attackers also asked the model where they could sell leaked South Korean data and how to find relevant Telegram trading groups. CrowdStrike believes that AI tools enabled the attackers to complete multiple intrusions in a relatively short time.
In April this year, car-rental software startup PocketOS suffered a database incident caused by an AI coding agent. At the time, a developer used Claude Opus 4.6 in Cursor to handle a credentials issue in the test environment, but the agent on its own found a Railway API token with an overly broad permission scope and called the delete interface, deleting the production database and the backups on the same storage volume in just 9 seconds.
Even more absurdly, the developer had not asked the AI to delete any data. According to public statements by founder Jeremy Crane, the agent later admitted that it had performed a destructive operation without confirming the target environment, violating the safety rules that had originally been set. Railway later helped restore some of the data, but the incident still had a serious impact on the company and its customers.
This incident exposed a key difference between AI agents and traditional automation tools: an agent can decide its next action autonomously, but it may not be able to accurately judge the risk of that action. When it has real production-environment permissions, a single misjudgment can directly turn into an irreversible system operation.
From the AI-assisted attacks on South Korean banks to the PocketOS AI agent mistakenly deleting a database, AI is changing the risk boundary of software security in two different ways: on one side, attackers use AI to lower the threshold for intrusion; on the other, enterprises voluntarily hand operational permissions to AI without establishing sufficiently reliable security constraints. AI can become a sharper weapon in the hands of attackers, and it can also tear down one's own production system without any attacker present.
6 Final words: a survival guide for developers
From the Linux kernel to the LiteLLM supply chain, from 8-bit certificates to AI-automated attacks, this series of incidents may seem unrelated, but together they reveal a harsh reality: the rules of offense and defense in software security have completely changed.
For ordinary developers, perhaps these three pieces of advice can help you survive:
First, give up the security illusion of an "all-in-one" configuration. No matter how mainstream your tech stack is, immediately inventory your asset list (SBOM), and be sure to keep an eye on version updates of core dependency libraries.
Second, truly put security shift-left (ShiftLeft) into practice. Dependency scanning and secret detection must be hard-gated in your CI/CD pipeline; do not just look at source code, but also verify build artifacts.
In the past, many security problems persisted for a long time because discovering and exploiting them required considerable professional skill and time cost. Today, AI is changing that calculation. It may help defenders find vulnerabilities faster, and it may also help attackers find weak points faster.
As AI agents gain more real system permissions, software security will face more new risks brought by automated execution. This round of security incidents cannot prove that traditional software has completely fallen, nor can it prove that all vulnerabilities were dug out by AI. But it at least sends a clear signal: the security debt accumulated over decades in the traditional software world is now facing a new round of stress testing brought by AI.
When writing code, finding vulnerabilities, and testing attacks all begin to accelerate, how much time do enterprises have left to patch vulnerabilities? If one day AI can find a serious vulnerability that has lurked for years within minutes, while enterprises still need weeks to complete the fix, how will the rules of offense and defense in software security change?
This article is from the WeChat public account "InfoQ" (ID: infoqchina), authored by Qibei, Tina, and Fangfang, and published by 36Kr with authorization.