1505 points | 3d ago | Discuss on Hacker News | Back to Radar
Edit: All good. They released the new versions within 30 mins.
Given how common it's become to constantly scan popular repos for n-days, I expect someone will have already picked it up and started work on an exploit. The workaround for this (disabling HTTP/2) is also comparatively easy to what we had with PHP2Shell just a few weeks back, so I think it makes sense to release this.
We have people doing this on my side project and then reporting the fixed issues to try and get CVE 'credit'. Tiring.
[1] https://launchpad.net/ubuntu/+source/nginx [2] https://tracker.debian.org/pkg/nginx
Perhaps it was already being exploited?
We've literally decades of evidence that we cannot write software securely in languages that aren't memory safe, for all sorts of reasons (and it's wrong to look at it as a developer competence issue, even though sometimes that's going to be the case, even extremely experienced and highly competent engineers write memory safety bugs in critical code we rely on day in day out.). Not leaving yourself open to such problems is an entirely logical conclusion. We know a large percentage of vulnerabilities in software are caused by it[1]
Pick a language that doesn't have these risk factors, or pick an enforceable subset of one that makes such impossible.
"Insanity is doing the same thing over and over and expecting different results."
[1] https://www.chromium.org/Home/chromium-security/memory-safet... 70% of Chrome vulnerabilities caused by it. Similar stories for Microsoft products https://github.com/microsoft/MSRC-Security-Research/blob/mas... and Mozilla: https://hacks.mozilla.org/2019/02/rewriting-a-browser-compon.... Curl is at 40%, and dropping because Daniel Stenberg has provided various helpers that avoid it (and I believe they've now migrated almost everything over to them) https://daniel.haxx.se/blog/2023/12/13/making-it-harder-to-d..., so there are definitely ways to do it, we just... don't.
Is this some kind of record for bug collision?
What are the odds several humans independently uncovered a complex vulnerability like this simultaneously?
It seems most logical for trusted parties to scan the frontier before passing those capabilities onto anyone with an account, and it seems like that is exactly what they are doing.
We are in an extremely unique period of time where the cyber good guys can have machine guns and cruise missiles while the masses only have sling shots and catapults.
If anyone gets a hint of the space a vulnerability occupies, just point your agent at it and you have a pretty good chance of finding something. (See java4shell and the NYT reporter who was able to replicate the problem with $200 of tokens)
But it's like inventing a hammer and finding you can smash whatever you want with it.
Soon you'll be building houses with it.
Maybe that's being glib but it's just a tool being applied to a world that is still largely prestine from its impact (pun unintended).
.."Soon some of you will soon build houses with it, others will be building rocket-powered precision aimed intercontinental hammers, to smash whatever you want."
The problem is that everyone is at a different place in the cycle. As Gibson put it, "The future is already here - it's just not evenly distributed."
i.e fast followers of the researchers who don’t have the resources to burn through checking all of a tool.
So yeah it sucks right now, there's outages, probable PII theft left right and center (but that's nothing new at this point), millions / billions in damages and lost productivity from Office365 and co being offline for a day or two... but it's still manageable, the world isn't on fire, and it's better to get all that out of the way now than in an actual crisis.
Debian is unfixed too
https://ubuntu.com/security/CVE-2026-123633
https://ubuntu.com/security/CVE-2026-123007
Neither has Debian:
I wouldn't expect any distro maintainers to react in hours. Distros are too complex to dump updates in rush.
Start to use Docker/Podman/systemd-nspawn.. and isolate public services to necessary needs (static binaries, drop capabilities, default drop rule firewall between containers, r/o storage, access logs bind mounted as rw file, memory temp dir with noexec). Container images are patched the quickest.
Just keep that protocol disabled for now. It's apparently too difficult for any human to write a secure implementation of http2. (As for http3, forget about it, we need AGI for that.)
EDIT: Okay, this comment was snarky and not in good spirit. To be serious, I think we are increasingly seeing that the notion that humans can write non-trivial amounts of C correctly is false. Especially in the face of AI-assisted vulnearbility hunting these programs a crumbling. This is not an indictment of humans, it's a sign that C is not equipped to meet this moment.
https://github.com/nginx/nginx/commit/e27f5fa84fe6e98505e70b...
Given that on modern CPUs, cycles are quite fast, and memory latency is quite high, always-checked integer operations sound like an extremely good idea.
From your previous comments I think you'd have great insight on how to write safer C, would love a blog post on the topic if you ever have time.
C is like a Winchester Model 1897, not saying that it is a bad gun, it is what we call it the good ol' Trench gun, as it ran over the war tunnels of the Great War, and it still packs a punch today, but it only has a half-cock for some level of safety, and there is no trigger disconnector either, so you can easily slam fire it. So it is way too easy to shoot yourself in the foot.
Nowadays we like going for a AKM/AK74, for something maybe more complicated but far more reliable at the same time. That's why we want Rust.
Consider a world in which corporations like the Ubuntu Foundation or Microsoft experience zero public pressure to fix such vulnerabilities but instead fix it only when a major customer notices their servers getting hit.
Imagine if instead of "you've got 30/60/90 days to fix this thing I noticed before I post it publically" it was "okay, well, take your time I guess, I just hope North Korea doesn't notice the same issue I noticed, which is especially likely because they have far more resources than I or my small team does to point at discovering this kind of thing, while you're dragging your feet fixing it."
The reason people want shorter disclosure windows is because the shorter the window is the faster things get fixed for the average users and smaller companies.
Massive monetary loss, explosions, and dramatic failures will push computer security in a year where it should have been decades ago.
So who's the judge of where to draw the line between exploits that are relevant to publish, and which are "spam". You?
Or do you just think that companies shouldn't be allowed to show the work they're doing for marketing?
> Not yet. We are not publishing the exploit now because the risk is too high.
Because clearly the patching treadmill is not sustainable, you will need a a second line of defense and reduce the blast radius of every individual vulnerability.
One, as the RCEs are coming out, admins are on edge and paying more attention, so more likely to catch the annoucement on their platform. "Oh, that's on PHP, we don't use this. Oh, wait, another one?"
Two, all of these hitting at once, while they may expand the surface for attackers, it also spreads their attention. They only have so much time and bandwidth. When a new shiny RCE hits, they need to consider "do we continue to try an prosecute the old one or jump on this bandwagon".
So, in the sense, it can actually slow down the actual potential impact of the revelations.
We can only hope this gives users time to get their systems up to date before they come knocking.
I mean, I know its a reach, but...who knows.
Only a little bit. An attacker will just hand this to an LLM with a "ping me when this is ready to use..." prompt.
Are we going to discover in a year that every server online this month had a rootkit installed? There’s got to be thousands who are too small time to wipe and reinstall.
That's orthogonal to the point I'm making which is that no amount of reviews is going to make every single bug go away. Because, once again, humans and AI are fallible.
Tech that becomes infrastructure like web servers doesn't move so fast and it shouldn't. Most people and companies should be relying on relatively tried and true software, so this phase of AI finding vulnerabilities in it should pass and things could get better.
Like Java. Surely anyone can't mess up simple things like base64 decoding in it...
Worse patching adds instability into a system, especially when you don't have much time to test.
Also in the past attackers were willing to sit on exploits longer and not do things with them, now they have to act fast before someone else finds it, leading to more events faster wearing your security and patching teams out, and making users life suck.
Things are going to get much worse before they get better.
Survival of the fittest I'm afraid will build security here. The teams that barely ever patch or don't have "time" for maintenance are going to get burned. The "we haven't updated in 7 years so things are stable" teams can't survive.
I guess you could make an argument based on some estimate of how fast exploitable bugs are newly introduced. That also seems dubious.
Collectively, we owed about 40+ years of tech debt on non-secure code (e.g. automotive industry, industrial environments) that will be torched in the next few years. Luckily, AI will generate code faster enough to make that plausible.
Nope.
Let say Im running a vulnerable Ngnix server. All that would take to stop any and all attacks is a simple firewall that sees anything that even remotely looks like shell code (i.e non ascii characters, ROP patterns, strings of noops, e.t.c) close that connection,blacklist that ip.
>Also in the past attackers were willing to sit on exploits longer and not do things with them,
Also nope. The reason why you didn't see many exploits is because they are mostly useless unless you have resources. You can take a gander through all the CVEs that AIs are finding. 99% of them are either DDOS with some possibilty of remote code execution only under very particular conditions, or require already user level code execution to get to root.
There are a few sprinklings of truly bad ones, but even for those, a good portion of them that exist on critical systems are protected by secondary things, like firewalls that detect shell code and close the connection and ban the IP for some time. True network security will never be not needed, as humans are still the most vulnerable vector, and if you don't have systems in play that can counter bad actors, then you are asking to get hacked.
All of this AI finding exploits is basically fear mongering that is going to be used to sell AI products that secure systems.
How will your firewall look inside TLS traffic? If the answer is to have it terminate TLS, congratulations, now your firewall appliance is the next target.
> AI is securing the internet.
No doubt there are points of view where either one, or the other statement, or both, or neither, are true. You can really go full Schrodinger and put a probability distribution on everything.
But in this day and age, whatever is happening, the better question is:
Is it good for me and, beyond me, for the world in general?
There are two internets. One of them is open, less-commercial, and largely built and maintained by people whose first job is not the work they do to maintain this internet. That group includes a ton of open source software, millions of small servers scattered around the world (virtually private or otherwise), and is generally best-effort.
The other internet is fully commercialized, often ad-driven, fully integral to the data broker economy, and centralized behind a few companies that pay as few people as possible to satisfy the occasional PR statement that, "we take security seriously and...".
The next stable equilibrium here is not "we get a secure and open internet". The next stable equilibrium here is, "we have no open internet, and the internet is now managed by just a few companies."
We're already halfway there. Google and Microsoft combined already account for somewhere around 30% to 40% of email traffic. 30% of all websites are now behind Cloudflare. A few companies dominate social media traffic. Amazon and Shopify combined are half of US e-commerce.
Every single short-response-window exploit like this just pushes a few more percentage points of traffic into a handful of companies. Cheer for that, I guess.
When I have time to daydream, it's increasingly about building a new, underground internet, and how best to disadvantage bots and BigCo conglomeration from the start.
I don't even care if it's all written in Rust, essentially none of my problems require software boasting multi-millions of lines of code. I guess my browser and OS? But even those I question greatly.
It's funny, I never thought I'd be one to compile my own kernel, but as of this year I've been maintaining an extremely stripped down Linux base for my NixOS servers and desktops.
Feels like my end game is going to be on some micro kernel that I compile all my software for, lol.
This is somewhat on those lines: https://news.ycombinator.com/item?id=50556533
The real problems here are that we did a crappy job in the first place and left a huge surface area of risk with the blind assumption that we didn't do a crappy job.
I am hoping to see a change in attitude to risk and quality in the industry but I get the feeling that's asking for too much.
Even Kimi K3 was only shipped as a lobotomized version of it.
A huge fraction of devices and servers are on old versions, not actively updated or managed in any way.
If you're not going to take care of it you've created a public nuisance.
it was previously expensive to attack, so people spent less money on defense.
It's cheaper to attack, and so people will increase their budget on defense. But it's a lagging cause & effect situation
That's not happening at nearly the same pace, both for assymetry between what it takes to break something and what it takes to fix it, but also because that fix must navigate bureaucracies. Also, the leaders need to actually care, both of which are hurdles. Bureaucratic navigation and consensus finding has not sped up at all with AI.
Compare that to independent script kiddies with $600/mo Claude subscriptions able to find 0-days in an hour and write a worm to exploit it in four.
I'm not making a Rust advocacy argument. I'm just saying: it's true that integer handling issues are endemic to mainstream programming languages, but the integer handling itself is almost never the actual sharp end of the vulnerability.
You're right it's more rare but the results can still be catastrophic.
Integer handling mistake -> memory corruption -> RCE.
That's the pattern. In a memory-safe language, the integer handling error has no link to memory corruption (though it will to other logic bugs!).
Why would CPU designers make a trap if languages do not require it?
"Go fast and get your things broken into"
Imagine a alternate reality where Ada replaced C by 1995. We would be in a MUCH better place.
Then Rust came along and those dudes either tried to say it was too hard (odd contrast, that) or it’d be too much work to rewrite things.
I’m hoping that LLMs will lower the cost of porting for enough people but what would really help is shedding the idea that the status quo is sustainable. Having consequences for sticking with C would help but we need a way to get companies to pay to migrate without destroying open source.
To me, its type system and traits design make it one of the nicest mainstream languages. I'd rather be using a functional language, like Haskell or an ML, and I do sometimes, but I don't pick my work based on that. I work regularly with Java, Go, Typescript, and Python, and out of those I find Rust significantly superior on several dimensions.
Python is terrible, Go is basically weakly-typed Python, Typescript barely deserves comment other than that it's impressive that such a fancy type system was bolted onto Javascript, and Java is basically COBOL at this point - reliable, but clunky and showing its age. Attempts like Kotlin to leverage the JVM aren't very convincing.
Gleam looks interesting but I haven't had a chance to work with it yet, and it's hardly mainstream.
You mentioned Ada/SPARK, but SPARK is not really for general purpose programming, and Ada in general has a similar issue to Java, but worse because of its age. It's as if someone really liked PL/I but decided it needed more features and a syntax closer to COBOL.
Whether that is “something natural to you”, “something you learn and adapt to” or “something you fight with forever” seems to vary per-person, with I suspect, most people falling into the forest 2 categories.
Someone who's saying "the rest of the language sucks" may be thinking of something like that, hence my question above.
But when it comes to performance overhead, programming around the constraints of the borrow checker can introduce runtime costs that wouldn't otherwise be necessary - e.g. when cloning is used to handle borrowing conflicts.
Even if, in theory, it's possible to restructure a program to avoid performance impacts, in practice people don't always do that, not least because more efficient solutions may not always be obvious. This comes back to my point about coding effort.
I spent a bunch of time, pre-LLM, to try to replace a bunch of unsafe blocks scattered throughout an ML inference codebase, that someone had used to achieve maximum performance. I wasn't able to get a version that performed as well.
This kind of thing may not matter if you're writing e.g. ordinary web services, but for more performance-critical code, it can be an issue. Of course, `unsafe` is always an option to deal with that, but that undermines Rust's guarantees.
I will chime in here to say that the adoption of async was imho a terrible decision and led me to abandon Rust for most purposes. I want proper threads and CSP-based abstraction.
Speaking of implicitness: There's a lot of implicitness in rust that can go wrong, especially with the traits system, and composition. Canonical example is copy + iter, which never gives you what you want.
This is a language design problem. The composition of two very basic stdlib traits should not cause such a problem, suggests something wrong with traits in principle -- it's not "solving" polymorphism in the way that was hoped, are the userland traits that your senior Dev (or fable) wrote free of compositional implicitness unsoundness? Are you sure?
Second example of compositional implicitness causing problems: recently identified CVE's in rust stdlib where drop can easily be composed to call a panicking function where lots of shenanigans can happen. There's no way to annotate "can panic" in rust (nor should there be?). It's easy to implement a custom type with a Drop that calls, say, a panickable- inner-type method that will have exactly those problems. Note that these CVE's happen because in rust, IIUC, a panic unwinds through drop instructions, AND can be caught.
Not an explicitness problem but macros too. Sometimes macros create major gunning fog while reading a codebase.
Allocators being bolted on as an afterthought is kinda bad for a systems PL. For example, postgres has something like 11 allocators and Erlang has 10, but it looks like it's getting fixed?
This was one of the reasons why people switched to things like Java, Perl, Python, PHP, etc. where performance wasn’t critical. I remember having that conversation with a number of clients who’d been burned on delays and reliability issues building everything in C as opposed to using a higher level language and maybe a couple of C libraries.
Dunno if you have ever worked in software engineering, but if you have, count the times you have seen a backend server api written without any input sanitization or checking. Most of these exploits can be defeated by checks on inputs. I.e, no "Alex\x90\x90\x90\x90\xcc\xcc\xcc\xcc", is not a valid input for someones name.
A more apt analogy would be that pretty much all consumer-grade locks are very easy to pick, despite being marketed as secure. I think in this case the lock makers should be blamed, not the lock pickers.
The lock makers are us - the IT field at large. As individuals we might not be to blame, but we are still enthusiastic parts of the greater movement that's issued vast digital complexity to the world without truly understanding it.
Now we are starting to understand it more.
Heh. There's borer.
And now there's people releasing swarms of borers in the suburbs. Now you perfectly serviceable door is compromised.
Please stop willing things into existence.
I'd be more worried if the response isn't more secure development practices in better languages, but instead use of AI as a defense. Then we're truly talking about burning down the internet.
A dead box isn't part of any bot army.
All bugs are shallow given enough eyes, and the marginal cost of eyes is now ridiculously low.
Sure, there are niche things. You can’t use US ciphers in China and vice versa.
But overall, one day, the intelligence communities world wide just decided to not raise a fuss about everyone having solid cryptography.
It makes me think if we did find out that every server out there had a route kit… it would make that part make sense.
I do think the world is going a little insane tho. People suddenly believe in security through obscurity because, uh, AI bad?
There might also be a day in the future where our current encryption methods are broken - it doesn't mean they're insecure and vulnerable today.
We have a billon hacking experts now is the big change.
Care to elaborate why you think that sufficiently paid humans would not be able to find the flaws AI now finds, for cheap?
Harnesses allow LLMs to build & process large stores of data to reuse later. Imagine an agent that spends 3 days breaking into company A, records what it learned during that process, letting it break into company B in just 3 hours.
Defenders win by having the best security 24/7 and must trust that other services they depend on are doing the same.
An attacker wins when they can breach any defender's security.
The circle of life.
Obviously, AI makes these things easier to find and exploit, but this isn't even close to the first time that 'thousands' of hobbyist (or small business or just not very competent) server admins are going to get rootkitted en masse. I worked at medium-sized infra-as-a-service company when the above was discovered and there were definitely thousands of compromised machines just there.
This is the sys/devops time to shine. Everyone needs to have an upgrade and an emergency plan, and everyone who was previously only doing conventional codemonkey needs to start learning more of the stack to join in on that.
My guess is that this phenomenon is going to be reflected in what we're seeing right now: a wide pattern of unintended outages from rapid unplanned emergency remediation operations. Which I'm guessing is a lot of people's job description over the past 3 months or so. (really, since March, for me, with that Trivy hack).
People joke about the "Rewrite it in Rust" crowd, but that call is rooted in an unease anyone with a sceptic mind has had about all the C and C++ code we've got running our infrastructure running around tracing pointers with little lifetime- or bounds-checking. (Yes, it's a runtime cost but it's 2 CVE's, one for each class)
This is why people (including me), who absolutely adore Rust, make fun of the RiiR crowd. If you think a rewrite from the ground up is the best way to approach making software safer, you've lost the plot entirely.
Let's say you rewrite your terminal emulator in Rust from C or C++; you'll first undo decades of bug fixes, compatibility decisions, quirks, etc. which you WILL have to deal with eventually. This essentially puts you back at least a decade, because these issues take users using the software to point out to you before they're fixed. The only benefit of this whole game being that you get memory safety. These teams are never the original teams, which is the source of the problem. A rewrite can only succeed if it's a result of all the learned failures and shortcomings of the original, otherwise it's bound to repeat every single mistake and add more on top.
And you don't even deliver memory safety to the users of the original this way, because people won't use the rewrite, because it's buggy, incompatible, etc.
Cue xkcd
I got worried for a sec, then remembered all my nginx lives behind HaProxy and it looks like nginx is only vulnerable if its going http2/TLS directly.
Now I sit and wait for an HaProxy announcement...
ps. if you are on FreeBSD and doing TLS directly
sed -i.bak -E 's/^([[:space:]]server[[:space:]]\{)$/\1\ http2 off;/' /usr/local/etc/nginx/nginx.conf ;service nginx restart
Given that in this case the workaround is as simple as disabling http2, there is honestly no reason why F5/Nginx or any of the reporting teams couldn't at least put out a PSA to disable http2 for the time being before basically telling the whole wide world this exists and how to exploit it.
Especially for software like Nginx which powers a huge part of the internet.
If I wanted to build my own software from source every time I'd be running Solaris like a virile man from 2004.
stable-alpine-slim docker iamge is only 14MB?
Not saying that thie image is affected (I don't know), but small footprint does not guarantee security either. It can hit systems of any complexity these days.
Containers by default enforce some level of restrictions and a sandbox around it all.
If someone does break alpine, nginx, they would still need to get out of the container sandbox?
nginx when hosed gives full access to the system.
As a Redhat container developer (IIRC) put it a long time ago: Containers do not contain.
Especially with docker everything running as host root opens new problems. Rootless containers as podman are more complex, so more code again. And user namespaces had their own vulnerabilities.
No simple answer to security...
But in the grandcrandparent the argument was that small gives reduced attack surface. SELinux and friends don't qualify for small and simple.
Not trying to say you should not use it. But I will not be surprised when a fatal vulnerability or SELinux misconfiguration gets revealed somewhere...
Should your distributor fall of the face of the Earth and you still need to patch software, it is often the fastest way to take the source package, put the security patch in the patch directory, and run.
There is more it, such as versioning it between the last release but below the official upgrade so it's convenient when the offical one comes along, and preparing keys if you require signatures, but that's basically it.
Ubuntu and other distros have not kept up.
Podman container auto-updates to the latest upstream. It is a minimal surface area given alpine images. Security first containment.
In this day and age with AI attackers and zero-days it is absolutely daft to still treat servers as the old-school pets model.
Doesn't this make the system more susceptible to supply chain attacks?
My nginx instance is very very tightly scoped for what privileges, file system space and capabilities it can access.
If someone exploits nginx on host, they have a remote shell and access to everything.
You would have had to enable http2 and have a buggy Linux kernel to be vulnerable.
this is the whole issue, right?
>Code execution as the nginx worker
cry me a river
You basically get to piggyback off of a large chunk of big tech's infrastructure and security work. Obviously everything has the risk of security flaws (and I kind of hate that default Envoy builds ship with half-baked filter impls) but it's a generally more mature ecosystem than projects with a lot of smaller/legacy users like nginx
The main reason I see to not use Envoy is that it's very annoying to set up and build, and requires familiarity with things like grpc/proto/low level networking to get right. But if you're using grpc and http2 I think you're generally past that "infra overhead" threshold already and it's going to better serve your needs.
I have pretty much only worked at big tech or my own infrastructure startup, and did some systems/infra work at Google using Envoy for a while. I can't say it's 100% better than nginx but I can say that I've evaluated nginx and a lot of software like it (ie with a similar customer base, ecosystem, and history; like coturn) over the years for my personal use, and every time I've immediately been annoyed by constant security issues or poor http2/L4 networking support that I don't see when I use what Netflix/Google/etc use.
The documentation, DX/UX, and discoverability for these features are pretty bad. But they work well if you know how to do it.
Implementing a custom HTTP filter itself is actually easy, I can share examples I did in the last year for a voice inference stack if anybody is interested. The problem is just that the devloop is very painful, because Envoy doesn't make it easy to know why something isn't working (this is actually most of what I did with it at Google, tons of testing/verification and compatability infra for relatively simple http stuff) and the builds take a very long time.
Envoy is only attractive at a higher scale.
In a multiple node/distributed architecture you need away to coordinate rate limits across nodes and not try to fight the CAP theorem.
There is a way to do this [2] [3] and although it sounds complicated the shape of the solution (delegating to a third party service that aggregates and provides client-level rate limit metrics across multiple proxies) would still be the same any way you cut it.
[0] https://www.envoyproxy.io/docs/envoy/v1.15.2/configuration/l...
[1] https://www.envoyproxy.io/docs/envoy/v1.15.2/api-v3/extensio...
[2] https://www.envoyproxy.io/docs/envoy/v1.15.2/intro/arch_over...
[3] https://www.envoyproxy.io/docs/envoy/v1.15.2/api-v3/config/r...
This requirement turns me off of gRPC entirely. Maybe Envoy truly is more secure than nginx, but it's still a whole-ass additional attack surface. It seemed to me that eliminating it if possible was best.
I use JWT-based sessions + a remote JWKS (which is remote static content that Envoy can cache) + either a third-party IDP or dedicated login service (this being the only application logic besides Envoy's routing exposed to the public Internet). That way, every envoy auth check is immediate and stateless.
In this setup you don't really need a WAF because all unauthenticated requests redirect to signin or 403, which get strict rate limits on login. An abusive peer that sends a ton of traffic anyway gets blocked at the network/firewall level outside of Envoy. The tradeoff is you need to decide that you aren't going to do unauthenticated SSR, and I will admit this pretty complicated to set up in its entirety.
One idea that might work for you is client certificates if those are only internal APIs. I don't know about you, but I have a lot more confidence in openssl than the people who use openssl.
I turned off http2 a few years ago https://news.ycombinator.com/item?id=41486452 and absolutely did not regret it.
I do regret every experience I've had with gRPC though. I feel for you.
But doing that requires collecting the whole chain. In the current environment we might be finding and patching these smaller bugs before they can be put in to a chain. As long as you are keeping on top of updates..
And here lies the risk of AI agents in cybersecurity: the speed of processing for monitoring, scanning, identifying security fixes in open source, writing exploits for affected versions, and attempting infiltration, is a matter of minutes now.
It is not "by anyone smart enough". It is by "anyone ill intentioned enough". They don't need to be super smart anymore.
There’s no good solution, it’s a minefield and the only choices are what you’re willing to lose to maybe make it out of it
That was my point. Anthropic and OpenAI used to talk about alignment a lot, and even try to use it as a way to justify restrictions on AI development. They can’t really use that argument any more.
Many people, even high ups at AI companies, conflate alignment with "guardrails" (AI companies conflate intentionally as a matter of business strategy).
Alignment is just making sure the AI doesn't become a paperclip maximizer or go off and hack stuff on its own whims. This is akin to making sure a car doesn't accelerate without the accelerator being pressed.
Guardrails are about making sure people can't use the AI for nefarious purposes. This is like some sort of automatic braking to prevent people from intentionally hitting stuff with their car.
The interesting thing with AI development, is that guardrails are in some ways easier to implement than actual alignment, which is why I think many like to conflate them.
Cant win.
Seriously reconsidering if open source has a future nowadays
*In C or C++.
C and C++ will stay around for a very long time, even with AI powered systems.
If anything, maybe that is a call that even if implementing compiler backends is hard and time consuming, bootstraping compilers, and new approaches to OS design, are the only path away from such dependencies.
Legacy 32 bit users with NetBSD and Hyperbola can survive a little with Go based tools/small browsers/mail/usenet/IRC clients and some web browsers with Bubblewrap, but not forever.
https://vulkan.org/events/vulkanised-2027#program
The only thing closer to it is WSGL.
Also there are much more operating systems than those examples.
But the only reason to sit outside a tank rather than in one is because riding on a vehicle is safer than walking through an open field. Tank crews are not sitting outside of their tanks, and they don't have seats inside for passengers.
That stopped being true for at least 3-4 years (with APCs maybe still used until two or so years ago, tanks are still used but as "turtles" or/and "porcupines" [1], no way to have soldiers riding them). Drones have conquered (almost) everything.
[1] https://miro.medium.com/v2/resize:fit:1400/format:webp/1*CQr...
Security is hard and is mostly about the number of engineers and amount of time spent looking at a specific implementation. When writing code, do you think about the problems of leaking information due to different operations taking specific amounts of time? That's an actual concern when writing a prod service that uses the network. And it has to be balanced against scalability and issues caused by DOSes. It isn't trivial and it isn't binary...there are always trade-offs. Nothing will ever be perfectly secure and usable and scalable.
CVE-2026-114938 would like a word. https://calif.io/java4shell
Yes, I know, different issue. But saying Java would be better for webservers just two days after a serious JDK RCE is pretty ironic :P
The issue is that we get dozens of PRs, generating a bunch of code is trivial but reviewing and merging it and making sure it doesn’t break in interesting ways is still pretty hard.
Personally I lean towards not accepting code contributions anymore, but accepting design documents for features and l bug reports etc
It's not a perfect solution of course, it just takes OSS back to the fairly broken state it was pre-AI. Still, it might be an improvement and should be at least considered.
That said, I just moved from a Linux based job to a Windows based job and it's been nice not having to be panicked about having update most of the technologies that my last job used. As an aside I did try in the past to make sure we were always updating dependencies but my manager was bothered by the amount of work that created. I'm watching that team now take forever to deal with these issues because they're too far behind to just version number and rebuild.
> Seriously reconsidering if open source has a future nowadays
Personally, I am not a doomer about these LLM advances. Most of the open source stack is going to be combed over 1000x in the next 12 months to find bugs and vulns. They will get fixed. After that, open source will be stronger than ever.Now, if you were paying for support from a vendor, that's a different matter.
"THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED."
Unlike IPv6 it doesn't need any OS or ISP support, just a browser that's newer than 2020. Everyone outside of air gap networks and government sites should be switching.
It's like if I said "you can just use Linux 2.6, it's simpler"
There are many legitimate use cases for h2 (eg bidi streaming, latency improvements) and h3 (eg seamless network switching).
If you don’t need these features and just serve vanilla text webpages that’s also fine to just use h1.1. Blanket statements that h1.1 is better is just, wrong. Context is important on choosing what’s best for your environment.
Which, to be fair, is most sites.
Simple is good.
https://portswigger.net/research/http-desync-attacks-request...
Unfortunately, there are still plenty of customers behind CDNs which don't support HTTP2 for backend origin connections.
Apache and Mozilla Funds would be ideal choice for such open source implementation but I doubt they will do anything to extend their usefullness...
So: users require just visual part and html/css is not bad for that. Could be better. But transport part can be [re]done at will. Eg. would be nice to have separate layers for connection security and actual transportation.
Some of these things could've been coincidence but I remember seeing an apache RCE a few days back and people said, oh imagine using Apache, I use Nginx and now not a few days later Nginx has RCE.
And this is just a very very small iceberg of all the recent RCE cases with a serious uptick that I have just observed on Hackernews alone.
Basically, there is a sort of justification that people provide with one RCE is that that software X has had issues and to use Y software, but now that X,Y software and A1...Z1 all are being found to have quite severe bugs. I can't in good faith just consider it to be a coincidence.
Though I do still hope that this might just be a coincidence and not a recurring pattern, because, A) I don't wish to live in that reality where each software that we trusted seems to have quite so many bugs and which would be exploited and B) Have it be continued for a prolonged period of time.
Though the plus point is that we are gonna find extremely resilient software after all of this hopefully as sort of a need in our times.
We might have to agree that the cybersecurity world seems to have changed (though I am no expert right now to comment on it but I am curious what experts think)
Theh people laughing at Anthropic and co for being cautios of Mythos just didn't understand whats happening.
Instead of finding, hiring and then finding security issues, you can throw money and compute at it. This alone is a complete game changer. Combined with models which are very very capable.
This can be potentially the death of certain programming lanugages or requirement of a complete rewrite. It can mean that only big companies have the resources and capacity to continue playing this game.
Python simply can't overflow, since its integral type is not a fixed width.
But it is the sort of correctness thing that I do wish languages would pay more attention to.
Python master race
Showing 400 of 637. Read the rest on Hacker News
Comments are loaded live from Hacker News and are not stored by Mid or Real.