News for hackers. Stuff that matters.
Re:SeL4 security proofs now complete on AArch64 by StilesCrisis on Monday August 24, 2026 @08:24AM (#49418736)
Coming soon: a side-channel timing attack which completely invalidates this result
Re:SeL4 security proofs now complete on AArch64 by brohee on Monday August 24, 2026 @09:25AM (#49419444)
The assumptions the proof makes are pretty clearly listed: https://sel4.systems/Verification/assumptions.html

The one covering side channels is pretty honest:

Information side-channels: this assumption applies to the confidentiality proof only and is not present for functional correctness or integrity. The assumption is that the binary-level model of the hardware captures all relevant information channels. We know this not to be the case. This is not a problem for the validity of the confidentiality proof, but means that its conclusion (that secrets do not leak) holds only for the channels visible in the model. This is a standard situation in information flow proofs: they can never be absolute. As mentioned above, in practice the proof covers all in-kernel storage channels but does not cover timing channels.

So the proof won't be invalidated at it does not cover that particular threat.

Now the question is how useful the is a proof not covering side channels? I'd say pretty useful and it doesn't mean they don't have counter measures for to counter their exploitation, nor that they are not effective, just that a proof of efficiency is out of reach for now.

Re:SeL4 security proofs now complete on AArch64 by brohee on Monday August 24, 2026 @09:48AM (#49419750)
To add to that, the only way I see proof of absence of timing channels is by proving both the software and the hardware design side by side, and then the proof would hold only for a specific core. Something that would look both at the code manipulating secrets and at the Verilog for the specific core/memory chips. I've not been working in that space in a long while but AFAIK such a thing is nowhere near ready. I suspect it will be a lot easier if the hardware design is optimised for provability, which won't be good at all for performance. But there are plenty of contexts where security matters a lot more than performance (SMC, BMC, RoT and co at the very least).

And then you'd need assurance that the Verilog is faithfully transcribed in the silicon, which is a can of worms in itself.

Re:SeL4 security proofs now complete on AArch64 by mswphd on Monday August 24, 2026 @10:55AM (#49420672)
In general you don’t need things that fancy. Instead, you can take

1. Some known set of architectures, with

2. Some known set of (constant time/variable time) operations

And then prove things about programs written against those architectures. See for example

https://github.com/PLSysSec/FaCT

That being said, practically the operations that are variable time are known, and are mostly* the same on all modern architectures. In particular

1. Branching on a secret-dependent variable, or

2. Indexing an array with a secret-dependent index, or

3. Some architecture specific operations (typically things like division, occasionally things like multiplications/shifting).

Re:SeL4 security proofs now complete on AArch64 by brohee on Monday August 24, 2026 @11:37AM (#49421298)
I don't think you can ignore memory access. The whole "hyperthreading considered harmful" was because of shared cache between contexts. That's why I think a proof is in reach without cache, much harder with one...
Re:SeL4 security proofs now complete on AArch64 by Someone on Tuesday August 25, 2026 @11:37AM (#49435943)
Without cache, without virtual memory, without throttling when the more hardware is switched on or the CPU gets hot, without memory that’s unreliable under load (https://en.wikipedia.org/wiki/Row_hammer), etc.
Re:SeL4 security proofs now complete on AArch64 by rivetfasten on Tuesday August 25, 2026 @09:00AM (#49433281)
That works fine for some crypto algorithms, but as stated in the paper not for everything.

As I understand it, this proof needs to support conditionals for example.

Re:SeL4 security proofs now complete on AArch64 by simiones on Monday August 24, 2026 @10:27AM (#49420311)
I don't think it needs to be so dramatic. You could have a proof that the algorithms don't contain data-dependent logic, and perhaps ensure that no data-dependent instructions are generated; and that all branches have the same number of instrution-cycles (adding padding if not). You'd then simply rely on the architecture-specific instruction timing differences to be respected by the compiler.

Would something like this guarantee that no side-channels are possible on any architecture? Perhaps not, but it would still get you most of the way there.

Re:SeL4 security proofs now complete on AArch64 by logdahl on Monday August 24, 2026 @11:33AM (#49421245)
What about power draw? Maybe that doesn't count as a side channel (I'm not a security guy). Afaik, CMOS transistors mostly draw power on switching state, so a normal adder adding 0+0 or 1+1 is visible in the power draw.

I googled a bit and found Sense Amplifier-Based Logic (SABL). Super interesting :^)

Re:SeL4 security proofs now complete on AArch64 by less_less on Monday August 24, 2026 @12:03PM (#49421726)
Power draw is a side channel, yeah. It's not as easy to exploit in software as timing (including memory timing), but there are software exploits in some cases if it affects the CPU's frequency (HertzBleed) or if it can be read through channels like a sound card or radio receivers. For attackers who have physical access it's very much in scope.

For software like seL4 it would generally be out-of-scope, because it depends too much on the specific hardware and specific application, not just on the kernel, and protection usually requires extensive countermeasures in those places.

Re:SeL4 security proofs now complete on AArch64 by brohee on Monday August 24, 2026 @11:09AM (#49420882)
I'm not so sure. It's pretty hard to know how many cycles a register load instruction will take if there is a cache, or worse a cache hierarchy. That's why I think it will be a lot easier to have a proof on simple cache less designs...

Your version is likely good enough in practice though.

Re:SeL4 security proofs now complete on AArch64 by Dylan16807 on Tuesday August 25, 2026 @02:48AM (#49429950)
You don't need to know how long a load will take, you just need to know the duration doesn't depend on secret data.
Re:SeL4 security proofs now complete on AArch64 by gizmo686 on Monday August 24, 2026 @04:09PM (#49425207)
You don't need to prove the hardware correct to prove that the software is free from timing side-channels. You just need a model of the hardware that captures timing information.

Sure a hardware or model bug would render your proof non-applicable, but that is already the case for the existing proofs.

The bigger problem is simply that hardware designers do not care about timing side channels. Even if you did accurately model the timing behavior of a modern processor, you would just discover that trying to write software free from timing side channels is a practical impossibility.

> And then you'd need assurance that the Verilog is faithfully transcribed in the silicon, which is a can of worms in itself.

You would also need to prove that our model of physics accurately describes how that silicon would behave, and the the environment around the silicon is within the physical parameters you modeled...

Re:SeL4 security proofs now complete on AArch64 by brohee on Monday August 24, 2026 @08:41PM (#49427750)
A backdoor in physics would be interesting indeed, but not as likely as a rogue agent in a TSMC fab...
Re:SeL4 security proofs now complete on AArch64 by gizmo686 on Tuesday August 25, 2026 @01:18AM (#49429374)
Interesting, but not unheard of. Think of attacks like Row Hammer. No revolutionary physics needed. But chip designers cannot fully apply quantum field theory to an entire CPU, so they necessarily use simplified a simplified physics model. The resulting chips then need to be empirically verified to correct places where that simplified model diverges to much from the messy reality, which means that the chip design is only as good as the empirical testing done to it.

Add to that the potential for unknown and mis-moddeled manufacturing defects, and manipulated electrical voltages and signals, random particle interactions, and there is a lot of room for known physics to break a verilog level proof of correctness.

Re:SeL4 security proofs now complete on AArch64 by eigenform on Monday August 24, 2026 @06:12PM (#49426546)
What you want is a proof that microarchitectural timing differences (ie. the difference between a cache hit and cache miss) cannot possibly turn into architecturally-visible timing differences. If a program cannot reliably distinguish between two points in time, time is not a suitable channel for programs.

You could have an ISA where timing information is simply not presented to the programmer, but programmers like being able to profile their programs.

Re:SeL4 security proofs now complete on AArch64 by brookst on Tuesday August 25, 2026 @07:50AM (#49432330)
Not to mention interact with enternal clocks like audio.
Re:SeL4 security proofs now complete on AArch64 by brookst on Tuesday August 25, 2026 @07:48AM (#49432307)
It’s absolutely still very useful. Security is risk mitigation, and a reduced surface area makes it easier for everyone to focus on the remaining areas.

It’s basically a great front door lock: it does not guarantee nobody will break in through window, but it narrows the population of threat actors who have time and inclination.

Re:SeL4 security proofs now complete on AArch64 by torginus on Monday August 24, 2026 @09:21AM (#49419395)
I don't think a side channel attack against L4 would be particularly useful - the kernel's tiny, and doesn't really do much other than scheduling, IPC and capabilities. Anything you might want to learn lives in other processes.

That said, the big caveat of the whole thing, is that by pushing stuff traditionally considered to be sensitive to user space doesn't solve security or stability, it makes it other people's problem. There's no reason you couldn't do a side channel (or a different kind of) attack against a process that hosts the filesystem.

Re:SeL4 security proofs now complete on AArch64 by spectra2 on Tuesday August 25, 2026 @03:06AM (#49430087)
I think the danger of a side-channel attack against seL4 is more dangerous than you believe. The security proofs ensure that threads should not be able to read data they do not have permission to, or write to places they do not have permission to etc., through any part of the kernel's interface, which includes the mechanisms for inter-process communication. That means a side-channel, or some gap in this proof, would allow learning about what lives in processes!

While seL4 is definitely not a silver bullet for building a secure and stable system, I would argue that its security guarantees mitigate the risks. seL4's security proofs guarantee that the kernel obeys the information flow policy of your system, derived from the runtime distribution of permissions ("capabilities") in your system. If the interface to your filesystem, for example, is through the judicious granting of capabilities, then you can rest assured there is no side-channel.

Re:SeL4 security proofs now complete on AArch64 by torginus on Tuesday August 25, 2026 @04:25AM (#49430622)
> That means a side-channel, or some gap in this proof, would allow learning about what lives in processes!

This is true, but outside of the scope of the kernel (which is a theme with microkernel). Side channels are unfortunately a side effect of how hardware works. This is kind of a theme with microkernels, they are not a silver bullet, I agree.

The Linux kernel handles a lot of things L4 doesn't like memory management, drivers, file systems that L4 doesn't. So a filesystem bug would not be a kernel bug in L4 but would have just as serious implications as on Linux.

So while what they're claiming about security imo is true, they're claiming much less here than people here assume.

> If the interface to your filesystem, for example, is through the judicious granting of capabilities, then you can rest assured there is no side-channel.

How do you mean? Caps are a software contract, and side channels, like manipulating CPU cache with speculative execution is lower level than that. I don't see how that would mitigate issues like that.

Re:SeL4 security proofs now complete on AArch64 by spectra2 on Tuesday August 25, 2026 @05:11PM (#49440696)
Sorry! I didn't read "side-channel" as also referring to microarchitectural timing channels, but mostly to refer to (architectural) storage channels. You are right, it's not covered at all until the experimental Time Protection work is completed [0].

[0] https://trustworthy.systems/projects/timeprotection/

Re:SeL4 security proofs now complete on AArch64 by avadodin on Monday August 24, 2026 @08:48AM (#49419037)
That's a bit unfair. Any side–channel attack that invalidates seL4 security guarantees —assuming the proofs are valid— also invalidates any other imaginable OS'.

We're in the philosophical territory of tasking infallible beings with stopping their own flawless creations.

Re:SeL4 security proofs now complete on AArch64 by fosslinux on Monday August 24, 2026 @09:03AM (#49419220)
Although, there is ongoing research regarding time protection (https://trustworthy.systems/projects/timeprotection/) which prevents exactly timing channels. Including proofs of seL4 providing time protection.
Re:SeL4 security proofs now complete on AArch64 by brohee on Monday August 24, 2026 @03:57PM (#49425066)
Security-partition switches that carefully reset all shared micro-architectural state, while making switch times completely deterministic, and in particular, independent of previous execution history.

I'm afraid it means clearing all caches at each context switch. The performance penalty is really high.

Re:SeL4 security proofs now complete on AArch64 by spectra2 on Tuesday August 25, 2026 @02:42AM (#49429902)
Not all caches are cleared. There are some clever techniques to partition off-core caches (i.e. the L3) as part of the isolation boundaries enforced by the kernel. What I think is particularly exciting is that a new RISCV64 instruction to clear microarchitectural state is in the process of being standardised! So I'm hopeful that, while it should not be ignored, the performance penalty will not be too high.
Re:SeL4 security proofs now complete on AArch64 by msdz on Monday August 24, 2026 @08:42AM (#49418972)
Are timing (over network) attacks, physical access, etc. typically excluded from research like this for being “out of scope”, so to speak? I’m not familiar.
Re:SeL4 security proofs now complete on AArch64 by StilesCrisis on Monday August 24, 2026 @08:46AM (#49419022)
Mathematical proofs tend to assume that they are built on perfect foundations (you have to stop the proof somewhere!). Unfortunately, proving that the software is correct just means you need to find a flaw in a deeper layer.
Re:SeL4 security proofs now complete on AArch64 by monster_truck on Monday August 24, 2026 @09:04AM (#49419230)
They aren't out of scope as much as they are irrelevant. It has been a best practice to ensure that the things you would be attempting to attack the timing of do not let you do this for a very long time. We are so far down this road that we do things like generate thousands of values and throw most of them away to mitigate the laziest attempts at what would be considered in scope.
Re:SeL4 security proofs now complete on AArch64 by less_less on Monday August 24, 2026 @12:06PM (#49421774)
It's still relevant (and probably also rather difficult) to prove that seL4 itself conforms to those best practices.
Re:SeL4 security proofs now complete on AArch64 by dathinab on Monday August 24, 2026 @11:15AM (#49420972)
you are missing the point

just because something isn't perfect and handles everything you can come up with doesn't mean it isn't still very very useful

nothing in nature is truly perfect and down-talking grate but not perfect things will just make us stuck in a pretty shitty world which never improves because no improvement by itself "perfectly/fully" solves whatever problem set you are looking at

Re:SeL4 security proofs now complete on AArch64 by IsTom on Monday August 24, 2026 @09:26AM (#49419464)
There's another can of worms that are rowhammer-esque attacks.
Re:SeL4 security proofs now complete on AArch64 by CalChris on Monday August 24, 2026 @04:18PM (#49425344)
Side channel timing attacks are micro architectural. The SeL4 security proofs are architectural.
Re:SeL4 security proofs now complete on AArch64 by warkdarrior on Monday August 24, 2026 @08:13PM (#49427552)
Is cache hierarchy considered part of the microarchitecture?
Re:SeL4 security proofs now complete on AArch64 by saidnooneever on Tuesday August 25, 2026 @07:21AM (#49432029)
the proofs prove certain things they do not prove a system is infallable or actually secure they rule out certain things in certain parts of the code.