But Is It Open?The online edition
Type & theme

Make yourself comfortable

Page color
Text size
20 px
Reading width
Ask about this chapter ↗

Your settings and place stay in this browser.

Chapter 5 · Timothy O’Brien

Transparency, Security, and Trust

7 minute read17 source notesFree online edition

Open-source and proprietary software both get bugs and backdoors. What differs is what you can do about them, and how much you’re allowed to know.

The incidents below come from late October 2026. They show the distinction between discovering a flaw, establishing that it can be exploited, and getting a fix to the people running the software.

One bad stretch

On 20 October 2026, details of two critical PHP vulnerabilities became public before the coordinated release, the agreed date when the fix and the details are meant to go out together. PHP shipped emergency updates the next day for CVE-2026-109618 and CVE-2026-109619 (CVE numbers are the public IDs given to known vulnerabilities). CERT-EU said the flaws allowed unauthenticated remote code execution, meaning an attacker with no login could run their own code on the server. Proof-of-concept exploits started circulating. On 23 October, PHP disclosed a third flaw, CVE-2026-115560.1 CISA added the first two to its Known Exploited Vulnerabilities catalog on 26 October, and governments and other organizations took websites offline or restricted access while they worked out where PHP was running and whether their systems were patched.23 The bugs were in the PHP runtime itself, the engine that executes the code, not in a plugin. Servers using affected PHP versions and configurations needed assessment and, where applicable, the emergency updates.2

The same stretch brought CVE-2026-98432, a use-after-free in the Linux kernel’s IPv4 TCP code. A use-after-free is a memory bug where a program keeps using memory it has already handed back. According to CloudLinux, Anthropic said its AI model had built a remote-root exploit, one that takes full control of a machine over the network, against a server with a Multipath TCP listener. CloudLinux’s kernel team couldn’t reproduce the claim, and no one had reported exploitation in the wild.4 Those caveats distinguish a developer’s claim about a lab exploit from observed attacks. They do not establish the cost or reliability of attacks elsewhere.

None of this shows that open source is uniquely broken. For contrast, go back to SolarWinds. In December 2020 it came out that attackers had slipped malicious code into updates for Orion, SolarWinds’ commercial network-management product. The company said fewer than 18,000 customers may have installed the compromised updates.5 Customers received a signed vendor update. The signature established who signed it; it did not establish that the build was free of malicious changes.6

Many eyes, and where they fall short

The classic argument for open-source security is Linus’s law, which Eric Raymond named after Linus Torvalds in The Cathedral and the Bazaar: “given enough eyeballs, all bugs are shallow.”7 It’s easy to poke holes in. Eyes have to actually look, and most don’t. Heartbleed sat in OpenSSL, one of the most widely deployed libraries on the internet, for about two years before anyone caught it.8 Chapter 10 follows the work needed to turn a disclosure into a shared fix.

The XZ Utils backdoor, discovered in March 2024, is the harder example. A contributor who had spent a couple of years earning a maintainer’s trust planted it, and one engineer, Andres Freund, found it after he noticed SSH logins taking longer than they should.910 You can read XZ as the many-eyes model failing: the code was public, and the backdoor went in anyway. You can also read it as the model working, because the public code is what let one curious person pull the thread. I think both readings are true.

So the slogan overpromises. I still believe the argument underneath it. For anything that matters, if I have to choose between a system whose code I can’t see and one whose code I can, I’ll take the one I can see. I don’t think AI changes that choice.

The part of the argument I care about most has less to do with bug counts than with what software does when nobody is watching. Proprietary code comes with no guarantee that it isn’t doing things nobody advertised. You often can’t tell what a vendor is measuring: what telemetry goes home, which identifiers get collected, what gets kept. With open source, you or someone you trust can read the code and find out what it does on your behalf. For sensitive uses, that’s the point.

Most of us won’t read that code ourselves, of course. Our trust runs through maintainers, distributions, auditors, and the researchers who do read it. But trusting something inspectable differs from trusting a vendor’s word, because when that trust fails, someone can see how.

What attackers gain

The old security-through-obscurity argument, that hiding how a system works makes it harder to attack, has more to it than open-source people like to admit. Withholding source does slow casual scanning, and keeping a flaw quiet buys defenders time to patch. AI makes the objection sharper.

It goes like this. Openness helped defenders when reading code was expensive and both sides had roughly the same supply of skilled people. That’s no longer the situation. If a model can read every line of a public repository and chain low-severity bugs into a working attack, then publishing source hands that capability to anyone with such a model, including open models with fewer safeguards. Meanwhile a well-funded vendor with a large security team can patch its own product on its own schedule, without waiting for a volunteer maintainer to find a free weekend. On this view, many eyes worked because of what it used to cost to read code, and AI just changed that cost.

But attackers don’t need the source. They have binaries, observed behavior, and fuzzers (tools that throw malformed input at a program until something breaks), and models can work with all of those too. Hiding source raises a barrier for independent defenders too. A fix to an open component can flow to downstream projects and products, rather than depending entirely on one vendor’s release process. These are advantages of inspectability and shared repair, not proof that every open project is safer than a proprietary alternative.

A hump, maybe

My working theory is that we are passing through a backlog of old defects. Models can inspect far more code and exercise many more cases than a small human team can. That does not make testing exhaustive: possible inputs, states, and execution paths quickly exceed what any test campaign can cover.11 They are being pointed at decades of human-written code. Faster discovery could create a temporary surge in repair work. Whether that surge subsides depends on patching capacity and how quickly new defects appear.

The numbers fit that story, though they measure different things. In June 2026, FIRST raised its forecast for the year to about 66,000 CVEs, up from a February median of 59,427, and attributed part of the jump to AI-assisted discovery.12 Sonatype reports that CVE submissions to the NVD rose 263% between 2020 and 2025.13 Anthropic’s November 2 dashboard reported 5,087 disclosed findings across 680 open-source projects, with 629 findings patched upstream. Its October total had been higher, but the company removed duplicate and withdrawn findings from the count.14 Some of the rise comes from better reporting and from changes in how CVEs get assigned. A count of records isn’t a count of defects.

The hoped-for result is that models help assess code before it ships, reducing the flow of new defects. Attackers’ tools keep improving too, and AI-generated code could add bugs as fast as old ones get fixed. The bottleneck may remain with maintainers who must triage, patch, and release, and with downstream users who don’t update. For critical infrastructure, that is an argument for more supported contributors, not fewer.

What turns openness into security

Open code is a capability. Turning it into security takes practice and institutions. Responsible disclosure gives maintainers time to fix a flaw before the world knows about it, and that time is what PHP lost when its details leaked early. A software bill of materials, or SBOM, is a parts list that tells you whether the vulnerable component is in your product at all.15 Provenance tools like Sigstore and frameworks like SLSA, much of that work now gathered under the Open Source Security Foundation (OpenSSF), let you check that what you’re running was built from the source you think it was.1617 These controls depend on the builder’s integrity and the verification performed; a signature or an open repository alone does not prove that a binary matches the intended source.

Chapter 10 returns to these institutions in detail, along with Log4Shell and the work needed to turn a finding into an installed fix. The narrower point here is that transparency makes trust possible without supplying it. People supply it, and they need time and support to keep doing it.

Those practices require people. Chapter 6 asks who pays them.

Notes

  1. CERT-EU, “Critical Vulnerabilities in PHP,” Security Advisory 2026-018, v1.0 20 October 2026, updated 21 and 23 October 2026, https://cert.europa.eu/publications/security-advisories/2026-018. Covers the 20 October announcement, the 21 October fixes, unauthenticated remote code execution, circulating proofs of concept, and the third flaw (CVE-2026-115560) disclosed 23 October, which PHP said affects only unusually configured applications. ↩

  2. CISA, “Critical Vulnerabilities in PHP Require Immediate Patching,” alert, 21 October 2026, updated for the addition of both CVEs to the Known Exploited Vulnerabilities catalog on 26 October 2026, https://www.cisa.gov/news-events/alerts/2026/10/21/critical-vulnerabilities-php-require-immediate-patching. ↩1 ↩2

  3. Industrial Cyber, “Critical PHP vulnerabilities raise worldwide concerns as government websites go offline, researchers report AI-assisted attacks,” 26 October 2026, https://industrialcyber.co/vulnerabilities/critical-php-vulnerabilities-raise-worldwide-concerns-as-government-websites-go-offline-researchers-report-ai-assisted-attacks. Secondary source for the precautionary shutdowns, citing Australian authorities and other national cybersecurity agencies. ↩

  4. CloudLinux, “CVE-2026-98432 Linux kernel IPv4 TCP flaw: status for CloudLinux,” CloudLinux blog, last updated 3 November 2026, https://blog.cloudlinux.com/cve-2026-98432-linux-kernel-ipv4-tcp-flaw-status-for-cloudlinux. ↩

  5. SolarWinds Corporation, Form 8-K, U.S. Securities and Exchange Commission, 14 December 2020, https://www.sec.gov/Archives/edgar/data/1739942/000162828020017451/swi-20201214.htm. ↩

  6. FireEye (now Mandiant), “Highly Evasive Attacker Leverages SolarWinds Supply Chain to Compromise Multiple Global Victims With SUNBURST Backdoor,” originally published 13 December 2020, Google Cloud blog, https://cloud.google.com/blog/topics/threat-intelligence/evasive-attacker-leverages-solarwinds-supply-chain-compromises-with-sunburst-backdoor. Describes the trojanized component as digitally signed by SolarWinds. ↩

  7. Eric S. Raymond, The Cathedral and the Bazaar, section “Release Early, Release Often,” http://www.catb.org/~esr/writings/cathedral-bazaar/cathedral-bazaar/ar01s04.html. ↩

  8. OpenSSL Project, “OpenSSL Security Advisory [07 Apr 2014]: TLS heartbeat read overrun (CVE-2014-0160),” 7 April 2014, https://openssl-library.org/news/secadv/20140407.txt; Zakir Durumeric et al., “The Matter of Heartbleed,” ACM Internet Measurement Conference 2014, https://jhalderm.com/pub/papers/heartbleed-imc14.pdf, which dates the flawed code’s release in OpenSSL 1.0.1 to 14 March 2012. ↩

  9. Andres Freund, “backdoor in upstream xz/liblzma leading to ssh server compromise,” oss-security mailing list, 29 March 2024, https://seclists.org/oss-sec/2024/q1/268. ↩

  10. CISA, “Lessons from XZ Utils: Achieving a More Sustainable Open Source Ecosystem,” 2024, https://www.cisa.gov/news-events/news/lessons-xz-utils-achieving-more-sustainable-open-source-ecosystem, which calls the compromise “a multi-year effort by a malicious threat actor to gain the trust of the package’s maintainer”; see also Piotr Przymus and Thomas Durieux, “Wolves in the Repository: A Software Engineering Analysis of the XZ Utils Supply Chain Attack,” arXiv:2504.17473, 24 April 2025, https://arxiv.org/abs/2504.17473. ↩

  11. D. Richard Kuhn, Raghu N. Kacker, and Yu Lei, Practical Combinatorial Testing, NIST Special Publication 800-142, October 2010, https://nvlpubs.nist.gov/nistpubs/legacy/sp/nistspecialpublication800-142.pdf. Exhaustive testing of all input combinations and execution paths is infeasible for real-world software; combinatorial testing targets selected interactions. ↩

  12. FIRST, “FIRST Mid-Year Vulnerability Forecast Confirms Historic Surge, Projects ~66,000 CVEs in 2026,” press release, 15 June 2026, https://www.first.org/newsroom/releases/20260615. ↩

  13. Sonatype, “The AI Vulnerability Storm,” https://www.sonatype.com/resources/research/ai-vulnerability-storm. Sonatype attributes the 263% figure to NIST. ↩

  14. Anthropic, “Anthropic’s coordinated vulnerability disclosure dashboard,” snapshot of 2 November 2026, https://red.anthropic.com/2026/cvd/; “About this dashboard,” section “Changes between updates,” https://red.anthropic.com/2026/cvd/about/. The November update removed duplicate and withdrawn findings from several totals; an earlier count should not be treated as a count of distinct confirmed defects. The 2 October snapshot is retained at https://red.anthropic.com/2026/cvd/snapshots/2026-10-02-1947/. ↩

  15. CISA, “Software Bill of Materials (SBOM),” https://www.cisa.gov/sbom. ↩

  16. OpenSSF, “Sigstore,” https://openssf.org/projects/sigstore. ↩

  17. SLSA, “Supply-chain Levels for Software Artifacts,” https://slsa.dev/. The site describes SLSA as part of the OpenSSF. ↩

From But Is It Open? by Timothy O’Brien (Discursive, 2026). © 2026 Timothy O’Brien. All rights reserved.

Chapter 57 min leftNext →

The book, chapter by chapter.

Source note

Go to the notes & sources ↓

The vocabulary.

A short guide to the book’s recurring terms. Follow each chapter for the argument and its sources.

Open weights
A release makes a trained model’s learned parameters available. The accompanying terms decide what you can do with them. Access to weights alone does not provide the training data, code or recipe. Read the chapter →
Copyleft
A way of using license conditions to preserve recipients’ freedoms when covered software is passed on. The obligations depend on the license and on what you distribute or make available. Read the chapter →
Permissive licenses
Licenses such as MIT and Apache 2.0 grant broad reuse rights with comparatively few conditions. Notice obligations still apply, and a software license does not automatically cover a release’s data or other components. Read the chapter →
Reproducibility
The ability to reconstruct and examine how an artifact was produced using the resources that are published. Running an existing checkpoint is a different achievement from rebuilding its training. Read the chapter →
Governance
Who can participate, who makes decisions, and how authority over a project or release is shared. A right to use the code does not by itself create a voice in upstream decisions. Read the chapter →
Training data
The examples used to train a model. Publishing the data, documenting its provenance and describing how it was filtered are distinct kinds of disclosure; privacy and other rights may limit what can be shared. Read the chapter →

A passage worth sharing.

Select a passage in the chapter, or share the one you’re reading.