Was just going on a grey-beard rant about how Rust give developers a false sense of security.

I didn't even notice the TARMageddon vulnerability until now and well this grey beard really only can say "told you so".

This is -precisely- the class of bugs I was describing, and -exactly- due to the reasons I outlined.

The blast radius of this thing is also freaking epic, almost anything that used tar in Rust is vulnerable to possible RCEs lmao.

https://edera.dev/stories/tarmageddon

#Rust #Cybersecurity #tar

CVE-2025-62518 Shows the Cost of Open Source Abandonware

Edera uncovers TARmageddon (CVE-2025-62518), a Rust async-tar RCE flaw exposing the real dangers of open-source abandonware and supply chain security.

Edera

So what were my cautions about Rust?

1. Be careful re-writing old stuff. You will repeat all the 30yr old logic bugs bc Rust is memory safe NOT provable correct.

2. Ppl-power. Lots of rewrites IS dividing our ppl-power. Be mindful of unmaintained core components

3. Vibe coded Rust is just as dangerous as any other language

4. Rust still can be used in memory unsafe ways. You actually have to audit the code to know if they did Rust right.

#Rust

I've coded in C / C++ / Java / Python / JS and anything else needed to get the job done.

I have never heard any group of devs so quickly dismiss security concerns about their ecosystem as rapidly as Rust devs.

YES the language IS type safe and that's a big value add.

But that value add can quickly be cancelled out without significant attention to detail.

The EXACT same attention to detail I code with in C / C++ / Java / Python / JS etc.

This time, is not different.

#Rust

@nullagent My personal opinion is #Rust developers aren't serious about security because those same people would've used #Ada before Rust became mainstream, but they haven't. So its pure hype. I'm a big fan of formally verified code and this hype trend is on one hand good – more people are conscious about type safety, but on other hand bad because those very same people tend to completely ignore decades of research on formal program verification.

How many of them know about ATS/Postiats for example or even more mainstream Ada SPARK?

@alg0w @nullagent I think more than you assume. Same about formal verification of Rust programs.
@michalfita @nullagent I beleive you, but I really can't tell the same for most Rust programmers, I have literally never met a single rustacean that by any chance happen to know that #Ada even exists! And there are affine types (similar to Rust's borrow checker) in SPARK 2014! And it has much-much more if you actually care about bug-free code. One of it is readable syntax.

@alg0w @nullagent I know plenty. I think in matters from what industry they're coming from.

#AdaCore, the company behind significant #Ada and #SPARK work invested in #Rust as well. And I think they're experts in the domain.

@michalfita @nullagent And for #Rust they come from webdev... (it is a joke). But my point still holds – people use Rust because it is fashionable, there are plenty of strongly typed languages. Yes Rust was first language that popularized affine type system – and that's good. But handling allocated resources isn't the only thing that is relevant for correctness. In #Ada for example you can write substantial programs without *ever* using dynamically allocated memory. Also in Ada you can have bounded types like an integer from 1 to 10 etc. Also Ada has a specification and is ISO standard. Compiler (gnat) is GPL licensed compared to MIT which is prone to corporate hostile project takeover. I hope you understood my point – Rust fans should compare Rust with some langue within its own league and not beat a grandpa C.

@alg0w @nullagent Fans would do whatever they wish for and asking them to do otherwise is at least wishful thinking.

The fact #Rust doesn't have #ISO standard is IMVHO a blessing - getting anything standardised is a painful process, then #Rust somehow avoided adding nonsense contrary to C++.

Not worries about the license at all - it let #Ferrocene and #AdaCore work on their safety certified products w/o rewriting the whole code.

#Rust could be better w/bounded types, still a lot can be done.