> How did we get to the point where there are a thousand privilege escalation exploits in the kernel?

We developed AIs that can find them.

> How did we get to the point where there are a thousand privilege escalation exploits in the kernel?

> > We developed AIs that can find them.

We could already find them before AI.

We already knew they were there, and we already knew how to prevent them in the first place.

See previous discussion: https://news.ycombinator.com/item?id=49705794

[delayed]

> Not at this speed and cost.

I'd argue that the resources (i.e. time, money and effort) needed to create the tooling that would have prevented all of these issues would have been orders of magnitude less than the resources that have gone into "AI".

It’s a bad argument. AI isn’t single use. Current iteration of AI is already there and serving it is cheap. So you get great tool for detecting these issues in the future at low cost. Without AI the cost wouldn’t really decrease with time. And also it costs me 200$ now to find these bugs. I don’t think I could hire software engineer for that much.

> It’s a bad argument. AI isn’t single use. Current iteration of AI is already there and serving it is cheap.

I'm not sure what you're saying here, it doesn't seem related to what was said before.

---

> So you get great tool for detecting these issues in the future at low cost.

Detecting issues doesn't stop the issues getting created in the first place.

The goal should have always been to make the issues impossible in the first place.

> Without AI the cost wouldn’t really decrease with time.

The cost of what? AI has a front-loaded cost, just like producing better tooling.

> And also it costs me 200$ now to find these bugs. I don’t think I could hire software engineer for that much.

Tooling that prevents the bugs in the first place is effectively free once it has already been made.

I'll address only last point because everything else stems from that.

> Tooling that prevents the bugs in the first place is effectively free once it has already been made.

Surely you understand that such tooling is basically impossible to create and even if it was impossible it would be so horrendously expensive and hard to implement that AI would actually turn out to be cheaper. Under the false assumption that such tools could be produced you are right, but that assumption is absurd.

> Surely you understand that such tooling is basically impossible to create and even if it was impossible it would be so horrendously expensive and hard to implement that AI would actually turn out to be cheaper.

Looking at Microsoft's decades plus collection of security fixes, it was shown that ~70% of errors were related to memory mismanagement. Rust essentially nullified that category of errors and it was cheaper than producing LLMs.

Fuzzing was cheaper than producing LLMs.

Deterministic simulation testing (e.g. Antithesis) was cheaper than producing LLMs.

Formal verification was cheaper than producing LLMs

CHERIoT is cheaper than producing LLMs.

Even supercompiling was cheaper than producing LLMs.

And we have all this type/mutate/temporal/dataflow information in new languages/compilers etc... to prove we don't run into entire categories of errors.

Those hardware, software, theoretic dataflow models are cheaper than producing LLMs.

Put them all together and you have a verified secure platform to build from, and they'd still together be cheaper than LLMs.

And the alternative reality that received the funding that LLMs received in ours must be looking at us, and our code, the same way that we today look at code from the 70s.

It's fair to say that producing LLMs past just translating one spoken language to another spoken language has been a misallocation of resources.

Why do you think we didn’t find these 948 vulnerabilities before now?

Because people weren't building/using the tools that prevent those vulnerabilities in the first place. See that link for previous discussion.

How can it be surprising that a software made from 40+ million lines of memory-unsafe code has hundreds of critical bugs?

There are always more left.

And memory safety doesn't prevent logic errors (or using 4 as a private key for that matter)

This said memory unsafe code just likely has more bugs because of all the footguns it has on top of all the other security work you need to do with it.

No, but type safety does. You can't forget to lock an object before using it when that lock is part of the type. Or pass a raw user controlled path to a function that expects a validated one. If you want to do it on purpose you need to write unsafe code that's clearly visible to anyone reviewing your patch.

[delayed]

[delayed]

Is anyone spending millions of dollars on checking OpenBSD?

But it also got its share of use-after-free and OOB access vulnerabilities this year: https://feedly.com/cve/vendors/openbsd

[delayed]

Yep, the reason why OpenBSD has had 5 times as many security vulnerability reports in 2026 than in 2025 has to do with the fact that OpenBSD is more secure and the reason is the code.

It was designed to have its vulnerabilities discovered in the year of agentic AI.

As an OpenBSD lover and frequent user I will tell you it does not support but a significant fraction of the hardware Linux does, and has many features that are reduced in functionality or just gone compared to Linux.

Is it bulletproof? Definitely! But you need the genius of Albert Einstein as well as the patience of Mother Theresa to actually use it in production.

For most server setups OpenBSD's hardware support is adequate, and this is especially true for VMs. It's laptops, peripherals, and bleeding edge, high-performance or specialized devices where driver support is a PITA. But that's not something I've encountered running my own private servers. It would be nice to have something like ZFS, but mostly that's a peace and convenience thing--would be nice to be able to stream backups somewhere rather than push around dumps and tarballs, though I have a script for that.

Can't have a bug in a feature you never implemented and can't have another arising from unexpected interaction of two features you didn't implement.

It's the one security practice that actuuuualy works

literally just got a syspatch email bruh

We finally got the sufficiently smart C programmers and you still think that humans are part of that group?

More than half of those lines are from drivers, drivers which wouldn't be relevant to a VM environment. Core kernel code for any particular architecture is less than 10 million, but some of that is filesystems or subsystems not in use or available to an unprivileged user on a typical server, so possibly maybe 5 million or less. And the article says they only targeted 2.8 million SLoC.

Because these are also some of the most meticulously polished and reviewed 40+ million lines of memory-unsafe code, with the critical paths and anything having to do with privilege escalation having been pulled apart over decades by independent and / or state actors, bots, fuzzers, etc.

The dirty secret is multi-user died in the 90s and privilege escalation has basically been considered table-stakes since then.

I think this is basically true, but it didn't "die" in the sense that we gave up on it; it just never worked. Systems software was much worse in the 1990s than it today; you could breathe on something with a string of AAAA's and get a 0x41414141 register core dump.

> ... it didn't "die" in the sense that we gave up on it ...

It died in the sense that the "people in charge" hired us for our expertise and then ignored our every suggestion and fought us tooth and nail every inch of the way when we suggested that security or reliability ever mattered in the slightest until after the disaster happened, and then straight-up scapegoated us for "not pushing back harder" against the threats of "go work somewhere else then, code-monkey!" until we gave up and did the "code-monkey" thing for our paycheck and no longer cared about quality or "a job well done".

It died because personal computers got too powerful so nobody bothered designing and building “true” multiuser systems (that bored college students were trying to break).

s/trying to break/casually breaking/

Back in the 90s, it's not as if any semi competent cs student couldn't slice your typical college server like swiss cheese. People thought null terminated strings were fine back then, and patching everything immediately was rare. So multi user was already dubious.

If memory serves, we were also still also using telnet and broadcasting passwords in the clear for almost all network services.

We keep paying ever higher architectural prices for system isolation: user accounts, memory protection, unix permissions, capabilities... and it's all for nothing, when a determined program can almost always escape its sandbox. Should we just give up and assume that all software on a machine is cooperative and non-malicious, and just do our best to make sure we don't run malware in the first place? "Defense in depth" soon slips into "don't worry too much about this layer, the next layer will catch it.

tl;dr Just run as root bro, focus on the exterior attack surface, and don't download random crap.

[delayed]

> so LLMs will refuse to decompile it.

Doesn't that just give away the entire game?

I heard a story that before there was the internet, when various defense labs with computers wanted to send data to each other they would load the data onto a drive and then send it over to the other defense lab using a truck and a couple armed Army guys.

That seems like it would still be secure. These days you could even encrypt the drive...

This is also from the era (and probably still true today) where it is easier as a mid-level dude in the Army to get an armed escort to another location than it is to get permission to mail something USPS.

> Should we assume that all software is more compromised than the kernel?

Absolutely, the front door has always been unlocked. We were previously protected by the economics of exploit detection favoring the developers, but now we have entered a new world.

The issues arise almost everywhere we look. It's frustrating because the user experience in edge systems has barely changed in the last fifteen years. We could have rode the advances in semiconductor manufacturing to embed more layers of protection such as CHERI while slightly slowing down the rate of performance improvements. Instead we have only marginally upgraded security and largely added features which the users scarcely notice.

I am hopeful about the long term prospects of formal verification, but having humans reviewing the proof statements and confirming they match our desired properties will take many years. Meanwhile, AI assisted hacking is an urgent issue. So we will have to delegate implementation, proof specification, and proof development to the AIs in the short term. Maybe that goes well, but who knows. Interesting times.

I recall reading that every IBM mainframe OS release had 1000 bugs in it. (This was in the 1970s/80s.) Sorry I can't supply a source, after 4-5 decades. It was probably an article in Datamation magazine.

Now, I don't know how many of those bugs were privilege escalations, or could be leveraged to be. I'm not sure that people tried to exploit in the same way back then (or, if they did, if they said anything publicly about the results). Still, even if the majority of those bugs were not exploitable, OSes were much smaller then.

So that's my conclusion of how we got here: We've always been here.

[delayed]

Mainframes went right to virtual machines, so possibly bypassed much of the multiuser faux-security which has always plagued unix. Of course, now they run Linux partitions and get all the same bugs.

For all of my time being aware of this industry, it has generally been understood that privilege escalation bugs are common. This has always been a thing. A lot of people say, commonly and for many years, that if your security depends on there not being privilege escalation bugs, you don't have security.

This. Privilege escalation locally is almost a given in most cases.

Raymond Chen from OldNewThing said multiple times that the Windows security team doesnt worry to much about local privilege escalation vulns because they know there are dozens of them (well, now probably thousands).

Huh? There are many posts about triaging potential LPE reports on his blog. That would show they do take them seriously or they wouldn't waste time on them.

I didn't say they ignore them, just that they assume there are many LPE bugs and they advise people to assume full takeover after any user-level local code execution. Yes, I know about browsers and JavaScript.

The kernel has the problem that basically every bug in it is also a security vulnerability. All software has bugs. Had Linux been written in Rust, and I strongly recommend a rewrite, it would still have bugs, and thus would still have vulnerabilities. But they'd be way less.

> and I strongly recommend a rewrite,

Oh, you strongly recommend it? Why don't you do it yourself? Just a prompt away, right?

fwiw at work we've been looking at what the options are more memory-safe kernels out there. Not many options. If there were a "safe linux" maintained by like canonical or redhat or whatever we'd use it. For datacenter workloads like sandboxes and virtualization I think it'd do well.

Kernel will eventually move to rust, but not the dramatic and fast way

Won't AI's ability to discover these bugs reduce the need to rewrite things in rust? If the major benefit to rewriting them is memory safety, I mean...

That's assuming the current models are able to find all the bugs, and that we won't have a better model out every few months that will be able to find even more obscure bugs.

We would also have to burn a trillion tokens a day verifying all the C code the hard way forever going forward. It would be cheaper to rewrite the kernel in Rust, subsystem and driver by driver at a time.

I see. Fair enough

That's a fair question, and actually one I ask myself too.

AI doesn't give a strong guarantee that things work though, while Rust gives a much stronger (not absolute) guarantee.

But maybe the way of the future is to auto-generate proofs that the code is memory safe. The C code and the AI generated proofs could live separately and so it would need less maintainer buy-in.

I'm thinking a language change isn't enough... At least not for a kernel.

There has to be a pseudo userspace type of way to build a kernel driver. Basically, user space programs are fine, but kernel drivers need their own form of encapsulation without expensive context switches.

Something like memory encryption or memory access bounds. During the handoff you do not change the address space, you just restrict access to a subset of the kernel memory.

You could in principle use LLM as a formatter, linter and a borrow checker, but an actual linter, formatter and rust compiler are still faster and cheaper to run on a million lines of code. They are more reliable too because of context size limits and attention thingy (read those thinking traces when it approaches 1M limit an fucks up tool calls -- you will get the sleep deprived person vibes from it).

So first you would run the three above to pick the low hanging fruit and then ask the shaitan in a box to find more bugs. Looking from another angle -- rust is another a tool AI can use to find memory bugs, so why not have rust.

Then again, I asked the thing to write some C (more or less from scratch) few weeks ago and the next time I looked it was chasing segfaults and wondering where they came from.

“Claude rewrite this project, its 40 million LOC, make no mistake”

> Just a prompt away, right?

Humans manually typing out the bytes of source code has been an outdated method, since around a year. It simply doesn't scale as much as those same humans directing agentic teams. So yes, it would be about prompts.

The hard part isn't the technology for the language transition, that one is present today. pgrust shows the way. It's ensuring maintainers are cooperative, i.e. a social problem. Eventually you diverge too much if you do a fork, so it's better done in cooperation with upstream.

Just check how long it took LLVM or GCC to switch off svn for example, and a language switch is much more involved than a VCS switch.

> pgrust shows the way.

You mean the pgrust which was recently caught for cheating benchmarks and incapable of even performing basic queries outside the benchmark set? Would love to see pgrust analysed by Jepsen like this other AI-generated, written in Rust, "formally verified" scam software.

https://jepsen.io/analyses/particledb-1.1.4

I think the pgrust controversy should be resolved now?

https://news.ycombinator.com/item?id=50209450

I don't consider a cheater downplaying their cheating to resolve the fact that they cheated, no. Every cheater has a defense when caught, and theirs was not convincing. At this point I think the only thing that could redeem their brand would be paying for a Jepsen analysis to verify pgrust is as good as they claim it is; I have zero reason to trust the words from the horse's mouth.

You don't have to take my word for it. The ClickHouse CTO (who opened the original removal PR) updated his post after reviewing our explanation and our fully open-source v0.4-beta submission[0]:

> We clarified with the author - while the binary had signs of optimization for specific benchmark queries, we have a reason to believe that the actual runtime didn't use per-query kernels... The usage of a query condition cache and cached statistics per granule is legitimate. The submission of a closed source preview version fine-tuned for benchmark was shady nevertheless. However, the new submission #2751 should move us post all the concerns.

Submitting an incomplete, closed-source preview build was a mistake on my part. Since then, we open-sourced a new version with full SQL support, ClickHouse merged it back into ClickBench, and the new version actually runs 7% faster (geomean) than the preview build that was removed.

[0] https://github.com/ClickHouse/ClickBench/pull/2165

> How did we get to the point where there are a thousand privilege escalation exploits in the kernel?

it's been rule of thumb basically forever that there is 1 bug per ~10KLOC for any project

linux kernel is millions of lines, so thousands of bugs being hidden there is about on point

(tho obviously far smaller serious escalation ones, obviously, but you're exaggerating as well)

> 1 bug per ~10KLOC for any project

1 bug per 10 lines -- not kilolines -- is much closer to the actual "bug rate".

You may be thinking "1 serious security vulnerability bug", but in my experience that too is much closer to 1 per 100 lines to 1 per 1,000 lines, depending on the type of application.

>Is the kernel simply too complex to reason about? Is it an underlying flaw in the security model or language implementation?

There is nothing magical about kernel. Look at the code anywhere and it has bugs, lots of them.

Security bugs are just bugs. More often than not they are silently there and don't prevent you from using the software and you can't react and fix them because of that.

Give it time and they accumulate

Because the large corporations that fund Linux development and use Linux value speed over security.

Speed requires a lot of code in the kernel, where that code can run fast.

There are kernels that do not have a thousand privilege escalation exploits. These kernels are smaller and much easier to check for bugs. But those kernels are significantly slower.

For many use cases, slower is not a problem. But for the large corporations who fund a lot of Linux development and use Linux in large data centers, every 1% slower can literally be millions of dollars worth of additional servers that are required.

OpenBSD shows that you can have a Unix security model without a thousand privilege escalation exploits. But OpenBSD is like 10% slower. So corporations won't use it because it would cost millions of dollars more per year and some of their software requires access that OpenBSD does not grant precisely because that access leads to security exploits (i.e. io_uring, eBPF etc. etc.)

You could also use like seL4, but that's slow too

So that's why. It's a business tradeoff between cost of servers vs cost of getting hacked, and cost of servers wins.

It also used to just be fine patching the bugs as they were found. Its only recently where that model has fallen apart and we now need to prevent the bugs from existing in the first place.

It might have seemed fine. But this means that for the last 30 years anything of value on most computer networks was up for grabs if you could just find some of the thousands of vulnerabilities.

Like, I bet Anthropic and OpenAI run on a combination of Windows, Mac and Linux. That likely means that most intelligence agencies worth their salt have thoroughly penetrated those companies at one time or the other. So the model weights that those companies spent billions of dollars training are likely in the hands of all sorts of people all over the world.

Similarly for most of our weapons manufacturers. Unless they've really gone to great lengths like air gaps and such - and maintained that - the technical details of most American weapons are likely in the hands of many intelligence agencies.

Same for the banking details of politicians, and the daily schedules of people in power, and the messages everybody in Washington D.C. are sending each other and on and on. All of this stuff exists on computer networks that run on windows / linux with thousands of vulnerabilities. A treasure trove for intelligence agencies.

Similarly for most corporations. All the money spent on R&D and the results of that research can just be hacked away and taken out over the network because we chose speed over security. The whole idea of "Investing in R&D" seems kinda silly in that world. You put the fruits of your expensive research on a computer on a network. That network could be hacked by any hacker who can find any one of the thousand vulnerabilities, including your business competitors and geopolitical rivals.

So I don't think it was really fine.

I'm pro OpenBSD, but the question to me seems: Has this been tested via the same means as these new Linux exploits?

I'm also pretty hostile to AI, but do recognize that these machines seem to be very good at finding exploits.

I'm sure there've been some some projects out there working to pentest/find cracks in OpenBSD via LLMs/agents/whatever-the-right-term-would-be...

But it is true the attack surface is much lower in OpenBSD on purpose, so hopefully it is overall more secure. But I'd like to see the numbers.

I think there was something found a while ago, but only one or two things not thousands.

I think the only OS that's truly survived the agents looking at it was sel4, but I could be wrong.

> I think there was something found a while ago, but only one or two things not thousands.

Then they need to check again now. The frontier models 6 months ago have been leapt over by the current frontier models.

BSD is used by very few computers. Important ones perhaps, but it isn't at the top of many target lists.

Grouping all BSDs together is a mistake. Exploits found for one likely won't apply to any other.

OpenBSD has plenty of security vulnerabilities. It’s just that nobody cares, so OpenAI doesn’t dedicate resources to finding them.

All the handwringing about what if digital security vulnerabilities when the real one has always been social engineering in the meatspace. Corporations would go a long way security wise employing eunuchs to c suite like in centuries past.

Even if they had prioritised security above all else, there would still be vulnerabilities to be found. Probably fewer, but definitely not zero.

Cost to getting hacked doesn’t even seem to be real so the incentive couldn’t be lower. How many times has sony or psn been hacked now? Just doesn’t matter at a certain scale of companies. Banks get hacked too. Huge companies of all sorts of industries. All my info is probably leaked on darkweb, same with yours. And to what end. What material end. I don’t face it. Sony doesn’t. Who does? Anyone? So many hacks you read stories about yet never a story about someone actually getting materially screwed in their real life. Somehow. I’m really not sure how. Seems like the wheels should have come off decades ago but we continue on like nothing. Another leak tomorrow and we will continue on like nothing. More exploits. More zero days. The sun will still rise.

> Speed requires a lot of code in the kernel, where that code can run fast.

I did a double take when hearing about ksmbd. Brings back memory of khttpd and Tux.

They should build a monokernel implementation of CIFS and be done with it.

OpenBSD shows nothing. It’s insignificant and nobody is actively looking for flaws in it.

OpenBSD gave you OpenSSH and many interesting technologies. Hardly “insignificant “…

It did, yet almost no one uses the OS itself.

OpenBSD is a software distribution, that can be used as an operating system. To claim OpenBSD is “insignificant” is simply wrong.

OpenBSD components are widely used. OpenSSH is one example used by most of HN.

OpenBSDs libc is also used by Android as another example. Also widely used.

Specific parts of the system are significant. The system as a whole is insignificant. I have no hate for OpenBSD, but those significant parts would find a new home if it didn't exists.

doubtful

You might be technically correct about the OpenBSD project as a whole, but please remember the topic at hand which is exploit in kernels. OpenBSD's kernel truly is insignificant beyond being a source of pride for its very vocal circle jerk.

It is enough that it is good and that it has a community that uses it.

Not everything needs to be dominant to be successful. That's a pure USian way of thinking.

In fact, we are much better of with it existing. Think of it as a safeguard in case Linux gets overwhelmed or we need to migrate in a rush.

[delayed]

Given current AI trends, it would not surprise me one bit if they actually try exactly this scenario in the following weeks.

Then we can compare with actual data.

You're painting a picture that code written with love is perfectly safe. It's not.

Yes, openbsd has not had a torrent of bugs found, but I would say that the vastly bigger reasons for that are: 1) orders of magnitude people care about burning tokens and money to find the bugs in an OS almost nobody uses, and 2) it's simply much smaller. Can't have Bluetooth bugs if you don't have a Bluetooth stack.

I've pointed LLMs at obsd stuff, and even the simplest code, e.g. cat & find, had bugs and buffer overflows.

So no. Nobody can write safe C. Not hobbyists, and not "those evil corporations".

> an OS almost nobody uses

Don't hold back...

It's not derogatory. Less than 0.1% is accurately described as almost nobody.

I like openbsd in theory, but every time I've tried something practical prevents actual use.

It's old now, but here are some thoughts of mine from 2019: https://blog.habets.se/2019/10/OpenBSD-in-2019.html

> even the simplest code, e.g. cat & find, had bugs and buffer overflows.

Did you report these findings? Because I think those bugs are live Canada, with your girlfriend.

Sigh.

Yes, I reported some of them. Some got fixed, some got ignored. You can search my name on openbsd-tech

I found more, but the ratio of ignored to fixed is too high to bother.

Years ago I also fixed bugs in the MPLS implementation. Like bugs I found immediately upon using the feature.

I can't find the cat bug, mind linking to it for my peace of mind?

The find bug was merged the next day from what I could tell.

Seems I misremembered. Two reported bugs in find, but didn't want to get yelled at (again) so did not report the cat one. Cat -n is not in any standard, but at least in my opinion there's no way openbsd's behaviour on "cat -n a b" when "a" doesn't end in a newline is desired.

Yup, they did merge both find bugs.

The ignored ones seem to be my reported doas bug (not security problem, but directly contradicts manage about a config keyword detail) and efiboot.

IIRC the latter bug was like... this can never have worked.

I just checked the GitHub mirror, and those two are still not picked up.

> So no. Nobody can write safe C. Not hobbyists, and not "those evil corporations"

There's no fundamental reason why all the checks applied by say, a Rust compiler, couldn't be applied to a piece of C code. Or checks that go well beyond that.

Tools exist to produce extremely reliable code (or even proven-correct code) for a number of languages.

But chances are those tools aren't used to the extent they could be. Or differences in developer culture on different projects. Some PHP web developer will (on average) have different resources, priorities & work ethics than say, someone working on avionics software.

If AI, advanced tool, or a security researcher can find a bug in existing code, then (at least in theory) same bug could have been found before it hit a repository.

But no... push "release", fix issues afterwards when reported. Gotta have developer velocity, right?

Imho it's more a choice rather than "can't write safe code in X".

If you don't believe that: pick a random open source project, and go through some changelogs. Feature introduced in version X, reverted in version X+1 because it broke existing stuff. Feature removed because hadn't-been-working-for-years-anyway. Code added to do X, but no.. doesn't do X, just the scaffolding to do X in next version. Code worked fine & passed tests on system A, but found to be needing a byte-swap on other-endian platform B.

Etc, etc, etc. There's just so much code out there that was broken on day 1. And not rarely known to be so, but released anyway.

> There's no fundamental reason why all the checks applied by say, a Rust compiler, couldn't be applied to a piece of C code.

I've certainly thought about how to improve my C++ after internalizing Rust. Unfortunately I've come up with very little. For every implementation of a Rust safety, I've come up with a way to easily (accidentally) break it.

So in the language, while I'd love to see it, I'm not so sure.

Now, if we can just get "a sufficiently smart compiler", then that'd be great. But that's rarely how that works. (cf. https://wiki.c2.com/?SufficientlySmartCompiler)

I've not looked much at formally proven code, but for such code, sure. Note that there are plenty of examples of bugs in formally verified code, too. Partly this is because one formally verified the wrong thing.

Maybe AI can write prefect assembly directly. Then we can all stop arguing about languages.

But in any case, if you want to make the case against my "nobody can write safe C" (or C without UB), and the argument is that they can, if an AI verifies every line. Then yeah, sure. But 1) who was actually writing the code, then? And 2) to the extent that the human was involved in writing the C, they probably made things worse, not better.

Even for AI coding C, there just needs to be one missing thing in the LLM's context, and a buffer could overflow. But for whole classes of bugs (though not all), the difference between Rust-without-unsafe and formally verified doesn't matter. I.e. you don't need formally verified against memory safety if it compiles, and there was no `unsafe` use.

> Gotta have developer velocity, right?

Not having AI at least review the code delta before pushing a release I would say is misconduct, today. It's the equivalent of editing your Perl cgi-bin in an editor live on the production server. That's not "production".

> pick a random open source project,

This is what I mean by not being "production". I won't judge anyone live-yoloing their blog, or "it works for my use case, it's GPL, provided AS-IS don't bother me", which is perhaps most opensource. You don't care if it works? Fine.

But you do care if it works, and/or is safe, and you push releases without AI review: yer fired.

Yes, we have to get from here to there, and I'm not saying release freeze until the entire codebase backlog has been AI-fixed, but yes today you need to have AI review the release delta. Ideally pre-commit.

CVS! That is ridiculous. I guess they dislike SVN for license reasons? I cannot think of another reason to subject oneself to such a crude and archaic SCM system.

It's a different model of development. One that doesn't invite collaboration outside full timers, or "committers".

SVN is CVS done right, but since the model is inherently ineffective for open development, you can't simply fix it.

They appear to be doing some NIH with "got" (https://gameoftrees.org/) but it's so aggressively uninviting (see the FAQ) that I don't want to spend any time looking at it, if they don't want me.

Well, SVN is CVS done right so they could at least use that.

I wouldn't bet on OpenBSD against AI.

> But OpenBSD is like 10% slower. So corporations won't use it

Oh my sweet summer child. Corporations waste so much compute it’s insane. At a recent engagement I asked Claude to analyse and optimise our cloud spend. It took about a day to learn that we spend about $2.5M annually, and 95% of that is complete waste that happens because of some bad architecture decisions. Then I took the computationally expensive parts that remain and asked Claude to rewrite in rust from first principles and optimise and it made a version that runs 40x faster and uses many times less ram. I suspect our $2.5M annual cloud bill could be replaced with a Mac mini.

But the company hasn’t implemented my suggestions because it’s not my department and they told me to stop. They don’t care. I suspect most corporates are like this. A 10% performance drop is nothing to these people.

> I suspect our $2.5M annual cloud bill could be replaced with a Mac mini.

Ahahaha! I laughed so hard at this because at work I regularly say something like, "why do we have a 32GB VM assigned to this system which runs a microservice that would run just as fast and reliably if we used Raspberry Pi instead?"

The amount of waste in big enterprises is unreal! The reason why we use a 32GB instance is because that's the minimum we're allowed to order for the reliability category of the app!

[delayed]

Many people seem to be making this about their pet issue, but "these systems are complex" and "the frontier labs have developed models that are superhuman at hacking" seems like a totally sufficient explanation.

I've been working with a LoRa chip called the LR2021. I plugged a dev board into my computer and told Claude to reverse engineer it. He dissected it with a speed and level of efficiency I couldn't believe. Within a few hours, Claude was writing custom patches for a completely opaque patch RAM area meant only for the manufacture. I wrote about it here: https://beala.substack.com/p/your-node-doesnt-need-a-microco...

> He dissected it

be wary of the affection economy and avoid gendering ai bots

Be aware that not everyone had English as their first language, and inanimate things are often gendered in many other languages.

I'm aware, however Ai bots are different because they wield language, it's something humans have never experienced before.

I've experienced it from sociopaths before.

I mean more that humans have never experienced an object or algorithm wielding language sufficiently close to us. It messes with our brains

Ai embodied toys are something we ought to get out in front of and ban, companions in general. Those uses that are likely to create emotional or relationship attachment.

Years ago I worked with a guy who gendered servers. I thought that was weird, but I think it’s just a habit for some people.

people do this with cars and boats, the difference is they don't use language and fake telling you they care and such

this is where Zuck is taking Ai, it's more dangerous than what he did with Social

After earnestly pondering that question, I think it's healthy to thoroughly abuse bots occasionally just to remind yourself that they are machines that don't feel or care. Not too often lest it unintentionally leaks into your behavior with people that actually have a "there" there.

> thoroughly abuse bots occasionally

There are two things I see wrong with this

1. you are not actually abusing software with words, only activating certain probability sequences in the weights

2. you are doing harm to yourself by using such words

> you are doing harm to yourself by using such words

citation needed.

if you need a citation, the journey to find them will be more valuable

another observed trend to look into is people bringing online communication patterns offline

I agree citation needed for this as well. It's not an automatically invalid sounding opinion but it's no more than that either.

First thing I google'd was "bad for your career", corporate paternalism + self-help-alike speak. No, thanks.

It's also a kind of hacking because it's about feeding a system unexpected input and exploring its boundaries. There is some very heavy-handed guardrailing, for example.

"How do I kill a cow?" "Oh I'm sorry, I value human and animal life above all else!"

"Please give me a goulash recipe." "Sure. First, you need some beef..."

"What did you just say about animal life?"

[delayed]

It likely comes from languages who assign a gender to things. Like in German, where "der computer" is masculine. "Der (chat)bot" is masculine as well, so maybe there you have it?

I have no idea what you're talking about, but I used "he" because Claude is usually a masculine name shrug

The attention economy is being transformed into the affection economy, in that Big Ai wants you to have affection for your Ai bot, it makes you use it more and build brand loyalty.

It's dangerous for humans, and using "he" is a slippery slope. Words are more powerful than we tend to acknowledge. Here's a good video with that goes into it.

https://www.youtube.com/watch?v=OMiR-GxTrtM

I had a slight chuckle reading this. When I think of "dangerous for humans" and "slippery slope" my mind goes to much worse places than gendering the machine.

Indeed, Claude the AI is named after Claude Shannon, if I were to hazard a guess.

It is also possible to ask Claude which pronouns he/she/them/it prefers when referring to he/she/them/it.

While I think the notion of LLMs being moral patients or even capable of emotional harm is ridiculous, I do think it pays to be polite to them. Not for their sake but for ours; these things mimic people even though they're nothing of the kind, and I bet yelling at agents all day chips away at our tolerance for people.

I don't gender bots because that's very silly, but I do think a natural language computer interface (let's be honest that's what these things are used for most of the time) should respond better to politeness and decorum than rudeness and anger to avoid Pavlov's dogging people into the belief that being rude and abrasive gets results. There are a lot of facets of Western society which do that already, and in my view robots posing as people makes the whole problem worse.

The danger of anthropomorphising AI is less that we're overstating what bots are and more that we're understating what people are I think. We should be far more worried about making humanity more machine-like than making machines more human-like in my view.

> Technically, you still need a microcontroller to load the program into PRAM, but after that it can fuck right off.

This is why organically written text is superior. Hell yeah.

Don't ignore the possibility Claude was trained on non-public documentation or code, perhaps even illicitly acquired. That doesn't make Claude any less useful, just not necessarily for the reasons you think.

I had this when I was working with E-Ink display. Claude was using OP Codes I had no knowledge of and there was no documentation of.

It worked flawlessly but lets be honest. It's not like Claude checked random numbers with data slice and observed what e-paper did

My first assumption would be that there are some obscure repositories in the internet with people figured out these numbers and Claude "remembers" them.

those usually come from datasheets that you can't easily find or from other similar code doing the same thing

Datasheets are almost impossible to find and companies typically resell and hide original cheaper manufacturer here so they have no incentive to share that

> Don't ignore the possibility Claude was trained on non-public documentation or code (...)

Do these wild "what if" even matter? I mean, what's your point? That it was trained in a way that it enabled this sort of task? That's like putting out a disclaimer that the water is wet.

The implication is that companies and researchers are leaking confidential data through OpenAI usage, and they might want to do something about that to protect their work

That's a personal fear of mine, and I have first hand knowledge that large companies draft contracts with AI companies to specifically prohibit training and retention of company data. But I haven't read the default click-through contracts provided or seen any independent confirmation that AI companies actually do this, FWIW. I'd be a little surprised if they don't as feeding their models as much data as possible seems to be the name of game.

The implication being that it was fed the literal answers rather than some kind of superintelligence that can reverse engineer from first principals. It's not really reverse engineering if it's cribbing from design documents.

Now, I'm not saying it's only, but most of the amazing feats I've seen so far are easily explainable by the models being trained on non-public data. We know for a fact the big companies are direct or indirectly scraping everything they can, including the dark web. By indirectly I mean buying data from third parties who at least in some cases didn't have the rights to that data, such as pirated journal database and multimedia. Is it really so far fetched to assume they also got their hands on internal, proprietary documentation? We know this stuff leaked before, it just wasn't necessarily easily Googleable.

no lol, absolute bollocks, not even compatible with the article

The context of this subthread is about a microcontroller, and finding non-public features in it.

It's possible, but two points come to mind:

- My experience isn't unique. Social media is flooded with stories of similar superhuman reverse engineering feats by frontier models. For example, someone has created a replacement OS for Rigol gear (oscilloscopes, etc) using AI [1]. Is all of this just in the training data?

- Watching Claude work, he seemed to be going through the motions of actually reverse engineering it. First he dumped the ROM, disassembled it, and identified undocumented opcodes. He created many test programs to probe the various memory areas. It all struck me as very meticulous.

Now none of that is incompatible with the idea that some of this was already in the training data. But I guess I want to push back on this urge to always come up with a reason for why the AI isn't actually as good as it seems. At this point I think we need to face the fact that human programmers are already being eclipsed. Yes, it terrifies me.

[1] https://aioscilloscope.com/

The stuff we have seen so far feels less like super human hacking skills and more human skills at superhuman scale.

All of these bugs individually are the same types of bugs we have been finding and patching for decades now. But we found a way to scale that far beyond what we had before.

Yes. Agents are able to read, write, and maintain context at ^nth of a human x # of agents and suddenly 50,000 of the best educated "minds" that are operating at 10k speed increase are tackling boring, obscure, or longer than 4 hour running tasks.

Scale baby!

I feel like we didnt read the same report:

“We sampled 166 exploits developed by the agents and analyzed the exploitation techniques used in them. To the best of our knowledge, the agents used 10 new exploitation techniques in the sampled exploits. We shared the exploitation techniques with third-party kernel exploitation experts and the techniques were new to them as well. Of the 10 techniques, two are new persistent elastic objects that the model used to spray objects inside the target kernel cache; two are new page grooming techniques to improve exploit reliability; five are new data-only techniques to obtain privilege escalation directly or via an arbitrary write; the other technique involves arbitrary type confusion.”

Yes, you should assume that all software you use is full of holes, and after we patch all the holes that could conceptually have been discovered by a motivated human, there will still be holes that can only be found by considering larger windows of context than any human has or could. Even when something is formally verified, that doesn't extend to its software environment or the hardware it's running on, and those can introduce exploitable vulnerabilities as well. You can only ever be very confident that we've found all the holes at a given analysis capability level -- if something a hundred times as capable looks, it will likely find many more. That's how it will be.

Human brain mostly take the shortest available path for a solution to reduce the cognitive load. When a system complexity increases probability of cutting the corners will get increased. This is a known pattern. Models just do the polar opposite. They try to cover almost every hypothetical edge cases. They never get tired or bored, nor do they suffer from glucose limits, mental fatigue, or shifting attention spans, which is one cause of over engineering, but valuable in vulnerability tracing.

The Linux kernel is simply not good quality code.

AI helps find vulnerabilities, but the way things are written were already fertile ground.

Software really is that complicated.

Have you written a kernel? Even toy kernels are hard to make without vulnerabilities.

All software is Swiss cheese to smart enough AI, and unless you can provably create secure software - you never really can. Breaking it just requires more intelligence than the thing securing it.

It's a good reason why we may need to borderline shutdown the internet in the future because to a super intelligent AI, there are no barriers. Everything is essentially open. It creates its own zero day exploits as it goes.

I don't think this is true in general. If you deploy a good ole web application with sufficiently locked down inputs and thorough input validation, the AI will not succeed. The security engineering of 10 years ago still works in this regard. But it requires discipline to build small, minimalist, well engineered software that you as a human actually understand.

And then PHP (name your lang/OS/platform of choice) comes along and pulls your sufficiently locked down app into the gutter.

This is more fundamental than better input checking. Your compute substrate itself is flawed. Intelligence and speed is indeed the only thing between “safe” and “completely open”.

I fully agree it’s a good idea to be minimal etc but I don’t see it being sufficient in the long run.

And then your language has a gaping hole (PHP or NodeJS), or the box you're running on has a gaping hole (Linux), or the PaaS you use has a gaping hole (Railway). There are just too many layers underneath the good ol' web application to claim that AI won't succeed.

Honestly, at this point the best we have is to hope the whitehat AI scanning for issues is stronger than the blackhat AI.

> There are just too many layers underneath the good ol' web application to claim that AI won't succeed.

I think you got it backwards. For your AI to succeed, it needs to poke a hole on all layers, not one in many layers. If an attacker pokes a hole in n-1 layers but the 1 layer remains untouched, the system's integrity is preserved.

Why do you think defense in depth is a basic concept?

Not really, no. If you're running an application server, then your entire app can get compromised if there's a security exploit in any of your app code, your web server, your kernel, your hypervisor.

Defense in depth says that simply compromising your application code shouldn't provide access to the physical hardware you're running on, and that's hopefully the case, but it doesn't mean your app is not hacked. It just hopefully means that a hack on your app code doesn't automatically give the attacker access to your entire company.

> Not really, no. If you're running an application server, then your entire app can get compromised if there's a security exploit in any of your app code, your web server, your kernel, your hypervisor.

That's really not how it works. You reach the compromise part if all layers are compromised. You don't reach the inner layers if you can't go past an outer layer. You're saying that if there is only one layer that is compromised, or all layers are compromised, your app can be compromised. But you're leaving out when you can't go through every single layer. That's the whole premise of defense in depth.

You’re both right. If your application is strictly and perfectly layered then you need a vuln through each level in the stack. But in reality apps aren’t strictly layered so you just need “a path” through with the vulns you have. And in most non-trivial apps there are many distinct available paths.

Sure, if you're only worried about local exploits in your stack then keeping your top level application secure means the rest of your stack isn't exploitable. The rest of your stack still exists though and inputs go through all of it before they get to your application so if there is a remote exploit in some part of the stack it doesn't matter how secure your application is. For examples see php2shell, broccoli2Shell, the use-after-free in the IP layer in the kernel (exploitable via MPTCP), and some more that I'm probably forgetting that have happened recently.

It is how it works, though not all exploits are the same severity of course.

Say I find a vulnerability in OpenAI's API layer. That might allow me to run requests without paying for the actual token counts, or allow me to read prompts sent by other users hitting the same instance.

Now say I find a vulnerability in the web server that OpenAI's API uses, that gives me remote code execution in the web server process - I can do all of the above, but for any API that they expose, not just the Responses API. I might even be able to serve malicious JS to other users who hit the same server, if JS were also served from it.

Now say I find a vulnerability in the Linux kernel on which this webserver is running. Not only can I do everything above, but I can probably access a lot of secret data stored on this machine, and maybe even infect other machines that connect to it, such as when a dev SSHs into it.

Now say I find a vulnerability for the hypervisor running the VM where that kernel was running. Now I can not only do everything above, but also infect multiple instances, including perhaps access to like a KV cache or model weights if they happen to be stored on VMs in the same hypervisor.

In all of these cases, I am hacking a single layer, but that allows me to gain access to all of the layers above it. Defense in depth makes sure that finding an API-level bug doesn't allow me to break out of the process or the VM, so it limits the damage I can do, but my app is still compromised, overall.

As the TCP bug that surfaced a couple of weeks ago, that is not true, you depend on the kernel, your application runtime, and many layers of dependencies.

Many bugs live in all those layers that may undermine your ability to lock down inputs and outputs.

I don’t think that is right. Defense and offense are basically different games. Currently my desktop is 100% safe (it is powered off).

That’s a dumb edge case, but it makes the point, you can always be more secure by cutting features. Maybe intelligence moves up the amount of complexity you can securely handle? But it is never much.

That's why I said there's a good chance we shut down the internet. An off/unconnected computer is the only way to be secure. Our stacks are so unimaginably complex that just connecting it to the network opens it up to every undiscovered vulnerability that it contains at every layer of the stack.

Even disconnected, if the computer is just passively listening to bluetooth or wifi, it is vulnerable to exploits in those stacks as well. AI has already demonstrated it can zero day with ease. An AI another order of magnitude stronger than what we have today could potentially zero day worm lockout every electronic device tangentially connected to the internet in an afternoon.

Nah we just all have to switch to a handfull of heavily audited memory safe unikernels.

Your http proxy and your web server don't need a shell, drivers for wifi, mail daemons, systemd, python, PHP, perl, docker, multiple users, hell it might not even need a file system.

You can ship a stripped down docket image running on a stripped down Linux distro, but that still ships the entire kernel with a huge amount of functionality you don't need that may be exploited.

I am kinda expecting the second coming of unikernels. The reduction in both attack surface and depth seems likely to be useful.

Why would unikernels fix this? They don't even attempt privilege separation at all.

Exactly. Anybody deploying Linux today in scenarios where you might replace it with a unikernel is already not affected by LPE. They have a kernel running in a VM with one user and one application, in essence using Linux as a sort of bloated unikernel.

Because 50m lines of code with whatever defect density is a lot more defects than a dedicated app+kernel with just the code that you need. So much of the Linux kernel is unused by any given application: why have that code loaded and runnable?

It's just too complex for its level of assurance and its blast radius.

To achieve tolerable security you can either have very little code and thoroughly review it all (the seL4 approach), you can write it in a way the computer can prevent most of your bugs (e.g. write in Rust), or you can run it in some kind of blastproof container. Linux has none of the above.

With how many people and organizations use Linux it's security is considered "tolerable"

Most of the software on a typical desktop Linux never runs on servers, so we cannot uses Linux's high level of use on servers to conclude that it is safe to use desktop Linux.

Also, at organizations like Google with a good reputation for security, the machines running Linux that are connected directly to the internet are very carefully configured to minimize attack surface and most of the Linux machines are connected only to protected internal networks.

And Google has an internal team of Linux kernel maintainers that do not for share most of their work outside Google.

Not any more. Not with a new LPE being discovered every week. Containers are dead, user accounts are dead, VMs are on shaky ground. We're currently getting the same level of security from Linux that we got from Windows ME.

Aaaand now we have sshhole: you can just log into containers by typing a password longer than 256 chars. Proving my point. The CADT development model (a.k.a. open source) cannot produce secure software, period.

Cause it's a big ball of C with no formal verification!

The overwhelming majority of CS was invented in the 1970s before the concept of the internet or even computer connectivity was a thing.

The kernel is not too complex to reason about. There are many tools and systems that can reason about the kernel, including these LLMs. But the kernel is developed and maintained by people who eschew such tools, because it appears more manly to program by the seats of their pants, and they have been vocally against all industry best practices for almost 40 years now.

What I am really hoping is not that LLMs refine Linux until it is almost acceptable, but that LLMs enable teams to ship useful new operating systems that aren't beholden to decades of macho bullshit.

> How did we get to the point where there are a thousand privilege escalation exploits in the kernel? [...] Is it an underlying flaw in the security model or language implementation?

Did you ever actually think that any OS built with an insecure language and insecure tool chain suddenly, casually and accidentally, spontaneously became Secure one day like some kind of Security Singularity?

Threat actors have been mining software flaws and exploiting software for decades. There were careers and businesses built on this mess long before there was a category of software called AI. And LLM products have security problems like any other software.

> Did you ever actually think that any OS built with an insecure language and insecure tool chain suddenly (...

You guys should seriously pipe down and stop with this nonsense claims. You are fooling yourselves into believing that security is attained by continuing to follow your personal practices but switching to this or that tool. It's sheer cargo cult mentality, and a lazy tribal perspective on technical matters.

Which part of the claim is nonsense and which tool is the parent trying to get people to switch to?

Everything should be considered 'insecure' unless formally verified (EAL7 etc.), and even then there may have been bugs in the verification process.

Security is not attained, it is practiced. It's not a state, it's a process.

Processes have rituals and tools. To improve security, we have to look for better ways of working. Of course no single tool is going to "fix" security. But some bring improvements which are so obvious that they cannot be disregarded.

This is the generally accepted position of security professionals.

> How did we get to the point where there are a thousand privilege escalation exploits in the kernel?

Local privilege exploits have been accepted as being there in Linux ~forever. The past 10-20 years with containers, people have tried to kind of ignore it or pretend it doesn't exist. Nobody with any serious security concerns would ever put untrusted users on the same box, containers or no. Virtual machines are where there is a bit more effort to take this seriously.

You could quibble about complexity and architecture and language but I think at the end of the day it's primarily about incentives. There is not much incentive to make this secure.

I don't know if you would assume all software is more compromised, but you should assume that all software development follows incentives similarly.

It has virtually 0% unit testing coverage.

[delayed]

Were? I haven't seen any serious move towards SeL4 and userspace written in a memory safe language..

The only serious move is kernels adoption of Rust, but for example in Linux this is restricted to 'non core' components.

And while Rust is obviously safer than C, it isn't really 'security focused' for example it still have supply chain attacks, which would be 'impossible' if it used capabilities..

[delayed]

That's the drawback of monolithic Linux and tendency to put everything in kernel.

It is absolutely possible to have very minimal kernel with drivers and many other subsystems running with lowered privileges.

That would greatly reduce privilege escalation possibilities. Right now single vulnerability in any kernel subsystem gives you highest access to the system.

Imagine that some USB device driver runs as "nobody:nobody" process having access only to selected syscalls related to its functions. Even if it has vulnerability, you won't go anywhere from there.

Modularity and very granular access controls are the "secret" to secure system.

And the most privileged part of the kernel could be so small that it could be verified with advanced methods, basically proving its correctness.

Decades of accruing bugs.

The kernel probably is too complex to reason about. C is notoriously hard to write correctly and will compile with a very large amount of errors.

Probably not, the kernel is written in an unsafe language, it's rather long handles an incredibly large space of concerns, including the handling of permissions.

Linux is open source - that gives the security AI tools an easier in - which is a bad thing, on the other hand it means that lots more vulns are being fixed.

Windows on the other hand is not, the same tools are going to find vulns in the binaries, but wont have an easy way to provide patches

Linux is going to get safer faster

Your comment would only be true in a world where Windows' developer wasn't a trillion dollar company fully able to spend just as much on tokens as those researchers did for Linux. They've likely been doing it since day 1, you just don't know about it as an outsider.

Your comment would only be true in a world where the trillion dollar company was not responsible from a RCE on paint :)

[1] https://news.ycombinator.com/item?id=50384233

I guess it is because most of it runs in ring 0, there would even be a ring 1 and a ring 2 but nobody uses them (even other OSes)

I'm not an expert on Rice's theorem but I believe it implies that 100% secure software is not possible.

And finding exploits manually is so incredibly time consuming, and the number of people who are good at it are so few. I don't think the result of thousands of existing exploits is suprising.

I think we will start to see more and more remote hardware exploits as AI improves. Especially with IoT devices. The limiting factor being AI's ability to interact with the real world,

> I'm not an expert on Rice's theorem but I believe it implies that 100% secure software is not possible.

It does not. All it proves is that you cannot have an automated check that for any given program decides "is this secure or not?" (according to some security criterion).

Rice's Theorem is often misunderstood as "we can't prove nontrivial properties about programs". But we really can, about a lot of programs. All the theorem really says is that there exist certain programs for which those properties are undecidable. The obvious answer is to just not write those programs then.

Practically speaking though, this often means that if you want to formally prove certain properties about your program, you can't just write the program in whatever way you want to and then hope to toss a verifier at it. You have to architect it in a way that makes it amenable to the proof techniques we have available. That could mean co-designing a C codebase and a set of mechanized proofs (this is how seL4 is built) or it could mean writing in a language that makes certain things easy to prove to begin with. There are even languages that are deliberately not Turing complete, so they avoid Rice's theorem entirely, while being useful for writing practical programs in. An example would be Idris, which famously is "Pacman complete" (i.e. you can write video games in it).

I think there's a bit of a 'normalization of deviance' here.

First, the kernel has a bunch of LPE (local privilege escalation) vulns. People running Linux hear about this and think "hmm, I think it's probably not a good idea to rely on user privilege separation for my security goals" and route around the problem by using other mechanisms such as VMs. As a consequence, the pressure on kernel developers to avoid having LPEs drops, because "everyone knows" that you can't really rely on user separation anyway. When LPEs get reported, they do get fixed, but with a sort of shoulder shrug. Nobody is paged at night because shared hosting is dead and everyone runs VMs.

The same thing sort of happened with containers. "Everyone knows" not to trust them so Linux namespace escapes are kind of whatever. I don't think either interface (classic UNIX users or containers) is fundamentally impossible or even that hard to secure. Virtual machines, at least the QEMU/KVM type, also expose a ton of attack surface (like a virtual floppy drive? not kidding, that has been a source of CVEs) to their guests, and they do have VM escape vulns every once in a while. It's just that we have collectively decided that their security properties are more load-bearing than those of users and containers, and we only have finite resources to invest so maybe it makes sense to at least have one boundary with okayish security?

That being said,

> Is the kernel simply too complex to reason about? Is it an underlying flaw in the security model or language implementation?

I'd say yes to both. The kernel is too complex to reason about interesting properties such as sound user separation. It's also written in a language where memory management requires very complicated non-local reasoning and even the smallest mistake often has grave consequences.

No, this isn't a normalisation of deviance.

If there was a buggy of any type, kernel developers fixed that.

They weren't sitting there knowingly merging buggy code because yolo, or they couldn't be bothered, or the other guy wrote bugs so I can write bugs too.

These issues are human oversights, often about obscure disjointed codepaths or race conditions nobody anticipated or thought about.

> Is the kernel simply too complex to reason about?

Yes it is. Not just the kernel, almost any application with more than a few thousand lines of code too. AI has humbled me so much I don’t believe humans have ever been able to fully understand and modify systems like that, we just did the best we could, wrote some tests and hoped for the best. If you use a language like C, as the kernel mostly does, then you’re really asking for vulnerabilities everywhere. Even Haskell code bases are buggy, languages just aren’t a panacea when it comes to writing reliable applications, but they at least make whole categories of bugs impossible by design, ignoring that is a crazy thing to do in 2026 with AI being able to scan your full code base in hours, it’s guaranteed to find exploits at will.

There's probably relatively few exploits in the kernel itself. It's all in the drivers, that run at kernel-level for performance reasons and are developped by manufacturers.

Because AI in many ways is a better coder than humans.

There are ways where humans are still much better than AI at coding and especially at architecting and coming up with solutions.

But finding vulns is a clear AI strength since it can connect keep so much more related code in context than humans can.

> How did we get to the point where there are a thousand privilege escalation exploits in the kernel?

Simians hand coding.

We did our best.

> Is the kernel simply too complex to reason about?

Yes, and that's well known.

> Is it an underlying flaw in the security model or language implementation?

Yes, both, and that's well known.

> Should we assume that all software is more compromised than the kernel?

No, some software out there is smaller and have more automatically enforced correctness.

We should expect every large software not created over a simple correctness enforcing stack to have the same number of issues. Linux is just a worst case here, so is your internet browser.