1021 | Critical Bugs, Cloud Outages and the Future of Open Knowledge

Mia: Hello and welcome back to the show — I'm Mia.

Milo: And I'm Milo. Today we've got a Hacker News roundup that, honestly, hangs together around one theme: trust. Trust in your dependencies, trust in the people who negotiate with hackers, trust in the infrastructure you rent, trust in the information you consume.

Mia: Right, and we'll go through the big threads one by one — a PHP emergency, a certificate authority compromise, a ransomware negotiator accused of working with the hackers, ten percent of Tor exits compromised, Google's cloud outage, plus a whole batch of tooling and side quests. Let's just dive into the first one, because it has a clock on it.

Milo: So PHP. The project itself put out a warning: a release is coming on October 21st, 2026, at 14:00 UTC, and it fixes two critical vulnerabilities — both rated CVSS 9.2 — affecting basically everything from PHP 5 through PHP 8.

Mia: That version range is the part that made people sit up. That's not "users of the latest branch should update." That's nearly every PHP deployment in existence, including the enormous long tail of ancient code that nobody wants to touch.

Milo: And the emergency mitigation is very concrete: disable session.upload_progress. That's the config setting to flip while you wait for the patch. The warning came ahead of the release rather than after, which is itself interesting.

Mia: Which shaped a lot of the discussion. One line of argument: advance warning is a gift to defenders — ops teams can schedule the change, test the mitigation, be ready to patch the moment the release lands. Twenty-four hours of runway with a concrete workaround is genuinely useful.

Milo: The counterargument, which you'd expect and did show up: announcing a critical vulnerability with a date and time attached is also a countdown for attackers. Everyone now knows that on the 21st at 14:00 UTC, a diff will appear, and someone will reverse the patch into an exploit. Some commenters said the disclosure window is so short that the risk basically balances out — defenders get organized, attackers get organized, and whichever side is faster wins.

Mia: And someone else pushed back on that, saying that for vulnerabilities this severe, the cat's already out of the bag in the sense that targeted attackers may have found them independently. Public warning mainly arms the people who didn't know. That's the classic full-responsibility-disclosure debate, and it never actually resolves.

Milo: The other big thread was about the mitigation itself. Disabling session.upload_progress sounds trivial until you remember that some applications genuinely use upload progress — file upload bars in particular. So the practical question in the thread was: how do you know if you're using it? Several people walked through how to audit for it, because "just disable a config flag" is easy advice until it breaks a feature you didn't know depended on it.

Mia: And the version range raised the obvious unresolved question: does a fix for PHP 5 actually exist, or is the warning telling people on unsupported branches to upgrade for real? Nobody in the source material says. That's a live unknown — what happens to systems that can't patch at all.

Milo: Right, and one more thing worth naming: exploitability. We know severity scores and we know the affected versions and we know the mitigation — but we don't have details on what the bugs actually do, and the project clearly wants it that way until the release. So everyone is patching on trust. Which is, honestly, a nice segue, because the next story is about trust in certificates breaking.

Mia: eMudhra. Private keys for eight intermediate certificate authorities were compromised. Browsers and operating systems started blocking the affected certificates between October 17th and 20th, and — this is the part that bites developers — Go, Rust, and Python packages need updates because those ecosystems bundle or pin trust stores.

Milo: Let's make sure the listener understands the layers here. Your browser's trust store is one thing — Chrome, Firefox, your OS push updates and you barely notice. But languages like Go, Rust, and Python often ship their own copies of the root store, or apps built on them embed one. So when intermediates get yanked, the fix has to propagate through package releases in each ecosystem. Until your toolchain updates, it may still trust keys that everyone else has burned.

Mia: The discussion there split into two halves. Half one: how did eight intermediate keys get compromised at once? Eight is a lot. Commenters pointed out that intermediates are supposed to be guarded like crown jewels — HSMs, strict issuing controls. Whatever happened, it wasn't one sloppy process; it suggests something systemic at that CA. And we don't actually know from the reporting what the mechanism was. That's an open question people kept returning to.

Milo: Half two: the blast radius. When browsers block a CA's intermediates, every site chained to them starts throwing certificate errors. If you run infrastructure behind one of those, your outage isn't your fault but it's your problem. And the Go/Rust/Python angle made people reflect on how many places trust actually lives — not just the big three browsers, but every CLI tool, every CI runner, every container image with a frozen base layer.

Mia: Which is a pattern that recurs all day in this episode, so let's name it now: dependencies on infrastructure you don't control, and the lag between "the world knows about a problem" and "your corner of the world has fixed it." PHP has a 24-hour window; CA distrust has whatever window your package manager gives you.

Milo: Okay. Next thread, and it's an uncomfortable one. Ransomware incident response is built on a chain of trust — you hire a negotiator, you assume they're working for you. Investigators now allege that Edward Dubrovsky, a ransomware negotiator, helped the ShinyHunters crew and ran an extortion site called Shinywire.

Mia: Sit with that for a second. The person whose entire job is standing between a victim and the criminals is accused of being on the criminals' side. And ShinyHunters aren't a small outfit — per the reporting, they also managed to steal FBI data at some point.

Milo: The comment section reaction, predictably, was a mix of "how does this even happen" and "of course it can happen." The structural point people made: the ransomware economy is opaque by design. Negotiations happen in secret, victims are desperate and embarrassed, and the intermediaries operate across jurisdictions with minimal oversight. If a negotiator wanted to play both sides — leaking victim information, steering settlements — who would ever check?

Mia: There was genuine disagreement about how representative this is. One view: this is one alleged bad actor, and the incident response industry has plenty of legitimate firms; tar the whole field and victims lose real help. The other view: the conflict of interest is baked in, because the negotiator's incentives aren't the victim's incentives — a longer negotiation can mean bigger fees, and some negotiators have relationships with threat actors that are, let's say, cozier than victims would like.

Milo: And then the FBI data theft gave the thread a darker coda. People connected it to the Tor story, so let's do the same — because that's the other half of "the security ecosystem can't fully trust itself."

Mia: A researcher went looking at Tor exit nodes and found 333 compromised ones — that's roughly ten percent of exits — that were intercepting SSH connections and injecting the Ebury backdoor into them.

Milo: Explain the attack for people who haven't followed Ebury over the years. If you SSH through a malicious exit node, the node can tamper with what comes back down the wire — and in this campaign it served up a backdoor that compromised the machine on the other end. The Tor team did a takedown, so the malicious nodes were removed.

Mia: The discussion was big on implications. First, SSH without host key verification or over plaintext-ish channels is far more common than people admit. Second, ten percent is a staggering compromise rate for critical infrastructure — one commenter's point was that Tor's threat model assumes hostile exits and still expects the network's design to protect you; this attack doesn't break Tor's anonymity properties, it exploits the fact that SSH traffic passing through is malleable.

Milo: Which is true and important — the exit node seeing your traffic isn't a Tor bug, it's inherent. But the practical takeaway people drew was: treat exits as hostile, period. Use end-to-end verification. And there was some debate about how the nodes got compromised in the first place and how one actor got to a tenth of the exit fleet without faster detection — the takedown happened, but the open question is what allowed the concentration in the first place.

Mia: And note the rhyme with the negotiator story: in both cases, a component of the security stack — the human intermediary, the network relay — turned out to be the attack surface. Okay, let's shift to infrastructure of a different kind: Google's week.

Milo: A Google Cloud outage took down European banks — HSBC, Revolut, others. But one bank, Monzo, stayed up, because it had built a failover system on a separate cloud setup.

Mia: That one detail did a lot of work in the thread. The mainstream reaction: you're a bank, your services going dark because your cloud vendor hiccupped is a reputational disaster, and the fact that Monzo proved redundancy is possible makes everyone else's single-cloud architecture look like a choice, not a constraint.

Milo: The pushback, though, was substantial. Running a second cloud isn't free — it's not just paying two bills, it's maintaining two sets of deployment, two data strategies, actual tested failover. Several commenters argued that most "multi-cloud" setups are failover-in-name-only: the second region or vendor exists but has never served real traffic, so when the day comes, it doesn't work. Monzo's claim is that theirs did work, which implies serious ongoing investment.

Mia: And someone raised the regulatory angle: banks have operational resilience requirements, so for financial institutions this isn't a nice-to-have — regulators increasingly expect exactly this kind of contingency. Which means the market might not fix this on its own; the rulebook might force it.

Milo: Now, the same week, Google does something that reads as an answer to "should you depend on one vendor" — it open sourced TorchTPU, a PyTorch backend for TPUs. We're talking ATen kernels, an XLA cache, distributed training support, and examples including Llama and ResNet.

Mia: And DeepSeek, not to be outdone, released DeepInfer — an open-source inference framework that reportedly handles 155 trillion tokens a day and generates about $38 of revenue per card per hour. Caveat: it currently supports only DeepSeek-V4.1-Flash, their own model.

Milo: And in the same open-infrastructure wave, Mistral put out Voxtral 3 — speech-to-text and text-to-speech models plus a voice agent SDK, over 50 languages, with diarization and emotion handling, and you can run it on EU hosting or self-host it.

Mia: The synthesis in the comments was: the industry is converging on open infrastructure as a strategic response to concentration risk. One outage at one hyperscaler took down banks; meanwhile the model layer is racing toward open weights, open inference frameworks, and open training backends. The reasoning people offered: if the models are open and the serving stack is open, the lock-in moves down to hardware and raw compute — which is still lock-in, just relocated.

Milo: Yes, and there was a good skeptical thread on DeepInfer's numbers. 155 trillion tokens a day and $38 per card-hour are impressive, but they're DeepSeek's own claims about DeepSeek's own model on, presumably, DeepSeek's own infrastructure. Commenters wanted independent reproduction before declaring a new efficiency era. Fair.

Mia: And the unresolved question on the Google side: does open sourcing TorchTPU meaningfully reduce dependence on Google, or does it just make TPU adoption easier while the TPUs themselves remain a Google product? People were genuinely split. Some said an open PyTorch backend lowers the switching cost dramatically; others said switching cost was never the real barrier — capacity and pricing were.

Milo: Let's move to tooling, because there's a Rust thread running through several stories this week. Start with the headline: Cloudflare introduced tsrs, a Rust port of TypeScript, up to 8x faster and using around 70 percent less memory than the TypeScript-Go port, with the Oxc team involved.

Mia: Context for listeners: TypeScript itself moved its compiler to Go a while back for speed. Now a Rust implementation comes along and claims to beat that. The discussion had the predictable "rewrite it in Rust" glee and the predictable fatigue, but the substantive points were better than usual.

Milo: The main substantive point: for a type checker, speed isn't a luxury, it changes workflows. If your whole-project type check drops from seconds to fractions of a second, you put it in a different place in your loop — editor-on-keystroke, pre-commit, CI on every diff. People who've lived through tsc-on-large-monorepos made that argument firsthand.

Mia: The skeptics asked the obvious: a port is only useful if it's compatible — byte-for-byte identical diagnostics, identical behavior on weird edge cases. TypeScript's type system has famously gnarly corners. The Oxc team's involvement reassured some people, since they've built Rust tooling at scale, but "8x faster" means nothing if it rejects programs tsc accepts. That compatibility question was the big unresolved item.

Milo: And it connects to the Rust compiler roadmap for 2026: a new trait solver, Polonius — that's the borrow checker work — a parallel frontend approaching stabilization, faster builds on LLVM 23, and a goal of smaller target directories.

Mia: The pattern commenters kept making: the compiler performance story across the industry is being rewritten, and Rust is simultaneously the beneficiary — LLVM gets faster, its own frontend goes parallel — and the instrument, since Rust is now the language people reach for when they need fast tooling. tsrs, TorchTPU's backend work, it's all the same momentum.

Milo: Smaller target directories got an outsized amount of conversation, by the way, mostly from people with firsthand pain. Anyone who's run cargo on a big project knows target folders eating tens of gigabytes. It's an unglamorous fix but it touched a nerve.

Mia: Polonius and the trait solver drew the more technical crowd — the argument being that borrow checking errors have been Rust's biggest onboarding tax for a decade, and if Polonius makes the checker both more precise and more comprehensible, that's a language-adoption issue, not just a compiler-internals issue.

Milo: One more piece of "free as in freedom" tooling for this segment: microG GmsCore — an Apache-2.0-licensed, from-scratch reimplementation of Google Play Services, for AOSP-based ROMs like LineageOS. It needs signature spoofing to work.

Mia: Explain why that's hard: Play Services is deeply woven into Android, and apps check for it constantly. microG reimplements the APIs so apps believe the services exist. Signature spoofing is the hack that lets a ROM pretend to be Google-signed, and it's a security-sensitive permission that mainstream Android won't grant — which is exactly why this lives in custom ROM territory.

Milo: The discussion there: people who run LineageOS with microG shared their experiences, mostly positive, with the honest caveat that some apps with hard Play Integrity-style checks still refuse to cooperate. And the philosophical point several made: this is the same theme as everything else today — a free reimplementation existing at all is what keeps a vendor honest. If you can leave, the vendor behaves differently.

Mia: Which is a perfect bridge, because the next block is all about what happens when the places we get information stop behaving the way we assumed.

Milo: Start with Wikipedia. AI answers are draining readers away — people ask a chatbot instead of visiting the encyclopedia. An author has written arguing that researchers have an ethical duty to defend open knowledge and Wikipedia specifically.

Mia: The argument's structure, as it came through: Wikipedia is the training substrate and citation layer for much of the AI ecosystem. If AI answers siphon off the readers — and importantly, the potential contributors and donors — the Commons erodes, and the chatbots end up summarizing a source that's starving. Tragedy-of-the-commons, but for knowledge.

Milo: The comments split in interesting ways. One camp said the author is right and this is urgent: open knowledge is infrastructure, and infrastructure dies quietly. Another camp said moral appeals to researchers won't move the needle — the fix has to be structural: attribution, licensing enforcement, maybe funding models that route value back to the source.

Mia: And there was a darker empirical contribution to this exact debate, from a Peec-AI experiment: they published 50,000 fabricated statistics and checked who'd cite them. Seven months later, ChatGPT was still citing them. Google, notably, largely deindexed the page.

Milo: That asymmetry is the whole story. The same junk content, two different information systems, one flushed it and one kept repeating it. Commenters drew the obvious conclusion: AI answer engines currently lack a robust mechanism for retracting or down-weighting bad sources, and once fabrication enters a model's supply chain, it can persist indefinitely.

Mia: The disagreement was about how fixable this is. Some said it's a retrieval problem — better source scoring, better deindexing signals — and solvable. Others said it's structural: models trained on a corpus that includes fabrications carry them forward, and the "seven months later" number shows nobody has an effective recall mechanism. Nobody in the discussion claimed to have the answer.

Milo: Meanwhile, human institutions aren't doing much better with the old internet. Ofcom — the UK regulator — has effectively admitted defeat in its case against 4chan, because US courts won't enforce British censorship orders when they collide with the First Amendment.

Mia: The comment section response was, let's say, divided along predictable lines. Some people read it as regulators overreaching — trying to govern a global platform from one jurisdiction and discovering jurisdiction has limits. Others read it as a genuine governance gap: if a platform is unreachable by any regulator it chooses to ignore, the enforcement vacuum isn't liberty, it's just whoever's most aggressive wins.

Milo: And the practical point people raised: this ruling shapes strategy on both sides. Platforms learn that hosting in the US is a shield; regulators learn they need interoperable enforcement or economic pressure rather than orders.

Mia: Then there's Facebook's new monetization scheme: pages now have to pay a subscription — starting at $14.99 a month — to post more than two links per month. And that includes links in comments. $49.99 buys you eight links.

Milo: Two links a month. Including comments. Commenters did the math out loud: that's not a fee, that's a paywall on the concept of leaving. And the small-publisher perspective dominated the thread — people who run pages to share their own articles now have to pay Facebook to share their own work.

Mia: The counterpoint someone raised: Facebook's organic reach has been near zero for years anyway, so arguably nothing of value is being gated. But others answered that the two-link floor still covers the marginal cases — community pages, event announcements, small orgs — and that this sets a precedent for charging for basic distribution.

Milo: Which connects to the last item in this block, and it's a historical one: sixteen years after Deepwater Horizon, studies show the Gulf hasn't recovered — no meaningful protection materialized, and BP's own numbers back that up. What did change: BP paid roughly 140 billion dollars and had to suspend its dividend.

Mia: The reason this thread resonated with the others: institutions can fail slowly. The fine got paid, the news cycle moved on, and the ecosystem didn't heal. Commenters explicitly made the parallel to the information ecosystem — damage done to open knowledge or platform trust may also not "recover" on any timescale we're watching, even after the penalties are paid.

Milo: So, 140 billion dollars bought cleanup and compensation but not regeneration. That's a sobering data point about what money can and can't restore. Let's take the tone down a notch for the next block, because it's about people.

Mia: First, a health thread that got a lot of earnest discussion: benzodiazepine withdrawal. The claim that resurfaced: it can last months, and can be more intense than opioid withdrawal. The thread's thrust: be cautious with long-term or continuous prescribing.

Milo: This one drew firsthand accounts, and they were heavy. People described tapering timelines measured not in weeks but in many months, with symptoms that people who'd been through both withdrawals ranked as worse than opioids. The clinical implication being discussed: benzodiazepines are often prescribed for years for anxiety or insomnia because they work at first, and the prescriber and patient may not appreciate what the exit looks like.

Mia: The commenters who identified as clinicians or near-clinicians made the process point: the problem isn't that benzos exist — they have real uses — it's that long-term prescribing happens without an exit plan, and tolerance complicates naive tapering. The agreement in the thread, such as it was: anyone on long-term benzos should treat discontinuation as a serious, slow, medically supervised project, not a calendar decision.

Milo: From medicine to education. Steve Krouse posed a question publicly: what should he teach his son? And he's leaning on Neil Postman's old book, The End of Education, to argue that in the AI age, the goals of education need to be rethought, not just the methods.

Mia: The distinction people found sharp: most "AI and education" discussion is about delivery — should kids use chatbots for homework. Krouse's question is upstream: what is education for when the skills economy is being reshaped? Postman's framing — that education exists to give a shared story and purpose, not just to transmit skills — gets new relevance when the skills themselves are unstable.

Milo: The discussion swung between two poles. One: teach fundamentals harder than ever — math, writing, reasoning — because those are the substrate that survives tooling changes and lets you evaluate what the machines produce. Two: fundamentals as traditionally taught may themselves be the wrong target; the scarce human skill becomes judgment, taste, agency, knowing what to ask.

Mia: And unresolved, of course: nobody knows which skills the AI era actually rewards, because we're all mid-transition. Several commenters admitted they were reasoning from Postman, who was writing long before any of this, precisely because nobody has a better framework. Which is either wisdom or cope, depending on who you asked.

Milo: And then the thread that gave this whole section its emotional center: Bob Cringely died on October 3rd, 2026. The author of the post wrote a remembrance of thirty years of working together — the Pronto project, the journalism career, the television work, the startup ideas that never quite landed.

Mia: For listeners who don't know the name: Cringely was a fixture of tech journalism for decades — the kind of writer who had opinions about where the industry was going and the access to back them up or embarrass himself trying. The eulogy's tone was personal, not a Wikipedia summary: a collaborator remembering pitching ideas, arguing, watching projects live and die.

Milo: What made it resonate in the comments: the post is itself an artifact of the thing we discussed earlier — a human record that outlives the systems. Someone made the connection explicitly: knowledge ecosystems, education goals, journalism — all the abstract threads of today — ultimately come down to individual people who did the work and the people who remember them.

Mia: The comments section on that post was, unusually for HN, almost entirely tributes and firsthand memories of his writing. Some said his columns got them into the industry. That's an endurance metric no dashboard measures.

Milo: Alright — let's end on the lighter threads, because there were some good ones, including one bug you'll actually want to know about.

Mia: First, the delightful one: someone built interactive 3D reconstructions of real IKEA assembly manuals — BILLY, LACK — that run in the browser. Faithful to the manual: the parts, the assembly order, the hardware counts all match. And explicitly unofficial, not from IKEA.

Milo: The comments loved the execution as much as the idea. People who'd built BILLY shelves recognized their own confusion rendered in 3D, and the technical discussion was about how you make a browser scene feel like an instruction manual — the step-by-step constraint, the exploded views, matching part counts exactly because a manual that's approximately right is useless.

Mia: Next, Permit Pending: a city-building simulation with a twist — every building you place has to go through permits, public hearings, lawsuits, and election cycles.

Milo: The joke is that it's more realistic than any city builder before it, and the comments split between people who found that hilarious and people who found it depressingly accurate. The design insight people praised: previous city builders let you be a benevolent dictator; this one makes governance itself the gameplay. If you zone something unpopular, you face a lawsuit or lose the next election in-game.

Mia: Then Jev Cards: a quiz game where you play against Jev, TypeSafe's vision model, which answers in roughly 0.3 seconds. Open source, multiplayer, leaderboards.

Milo: So the design problem is obvious: you cannot outrun a model that answers in 0.3 seconds. The commenters noted the game acknowledges that — it's not about speed, it's about accuracy or some scoring scheme that gives humans a fair lane. And people enjoyed it as a playful way to probe where vision models are actually good versus where they confidently flail.

Mia: On the utility side: VoidAccess, an open-source tool that automates darknet OSINT — from running queries to building a graph — with NSFW filtering built in. The author works at Opper, for disclosure purposes.

Milo: The discussion there was more cautious. The use cases people named were legitimate — researchers, journalists, threat investigators — but the tool's existence raised the usual dual-use question: the same automation that helps an investigator map a market helps anyone map anything. The NSFW filter got some appreciation as at least an acknowledgment of the problem. The open question: how much friction should such tools build in, and who decides?

Mia: And one practical bug before we close: iPadOS 27 breaks iPad presentations. When you switch apps during an AirPlay session, it starts mirroring your entire screen instead of just the app. Which means your notes become visible, your poll results become visible — live, to the audience. Keynote and PowerPoint are both affected.

Milo: For anyone who presents from an iPad — teachers, trainers, anyone running live polls — this is a real problem, not a nitpick. The workflow of "present in Keynote, glance at notes, show poll results" now leaks everything. The comments were full of workaround hunting: presenting from a different device, avoiding app switches, and waiting for a fix, because this looks like an OS-level AirPlay behavior change rather than an app bug.

Mia: Which, fittingly, is the same lesson the PHP story opened with: your presentation stack, like your runtime, is a dependency, and updates can break it without warning.

Milo: That's the episode. From emergency patches to a beloved journalist, the thread running through it all was trust — who has it, how it breaks, and what it costs to rebuild.

Mia: Thanks for listening — we'll see you next time.