cve-rs

Oh oh, who would have thought. A memory-safe rust at last. With no unsafe allowed, even type safe. Unless you forget about their type bugs: https://github.com/Speykious/cve-rs. So maybe eliminate type and concurrency unsafeties also then in the next decades or so.

I think referencing the well-known cases in cve-rs[1] is quite a bad faith effort. Of course if you try reeeally hard to write unsound code, you can write unsound code. An edge case in the type system downstream of lifetime variance rules is simply not something that matters in any practical attempt to write safe software. I find the tracker interesting since it probes the boundary of the compiler, but it says absolute nothing to the effect of "Rust is unsafe". [1] https://github.com/Speykious/cve-rs

> And even if there's some fundamental issue with how traits work that hasn't been resolved for six years, that can get brushed off as merely a compiler bug. Is it getting brushed off as merely a compiler bug? At least if I'm thinking of the same bug as you [0] the discussion there seems to be more along the lines of the devs treating it as a "proper" language issue, not a compiler bug. At least as far as I can tell there hasn't been a resolution to the design issue, let alone any work towards implementing a fix in the compiler. The soundness issue that I see more frequently get "brushed off as merely a compiler bug" is the lifetime variance one underpinning cve-rs [1], which IIRC the devs have long decided what the proper behavior should be but actually implementing said behavior is blocked behind some major compiler reworks. > has made

rustc and Rust have some rather serious type system holes and other kinds of issues. https://github.com/Speykious/cve-rs https://github.com/lcnr/solver-woes/issues

> Consider Rust. What about advertising actual memory safe languages instead. https://github.com/Speykious/cve-rs

> https://github.com/Speykious/cve-rs Caution: Lifetime may not live long enough https://github.com/Speykious/cve-rs/issues/48

> Safe rust doesn't segfault ever. https://github.com/Speykious/cve-rs > That is why cve-rs uses #![deny(unsafe_code)] in the entire codebase. There is not a single block of unsafe code (except for some tests) in this project. > cve-rs implements the following bugs in safe Rust: * Use after free * Buffer overflow * Segmentation fault

I like the license: https://github.com/Speykious/cve-rs/blob/main/LICENSE

Funny thing is that you can get undefined behavior and segfaults using only "safe rust", and the rust compiler has subtle bugs that allow you to disable important checks (like type checking), which can leave your code completely broken. But for some crazy propaganda, rust devs believes that any rust code is safe and sound no matter what. https://github.com/Speykious/cve-rs/issues/49

And how would you conclude that "fast"? You can have UB in "safe rust". https://github.com/Speykious/cve-rs You can even disable the Type check, trait check and borrow check in "safe rust" And all of this is unsound. https://users.rust-lang.org/t/i-finally-found-the-cheat-code...

Safe Rust is demonstrably not memory-safe: https://github.com/Speykious/cve-rs/tree/main

> Even validators have bugs Yep! For example, https://github.com/Speykious/cve-rs is an example of a bug in the Rust compiler, which allows something that it shouldn't. It's on its way to being fixed. > or miss things no? This is the trickier part! Yes, even proofs have axioms, that is, things that are accepted without proof, that the rest of the proof is built on top of. If an axiom is incorrect, so is the proof, even though we've proven it.