Follow Slashdot stories on Twitter

 



Forgot your password?
typodupeerror
Programming Security

Rust's Annual Tech Report: Trusted Publishing for Packages and a C++/Rust Interop Strategy (rustfoundation.org) 24

Thursday saw the release of Rust 1.89.0 But this week the Rust Foundation also released its second comprehensive annual technology report.

A Rust Foundation announcement shares some highlights: - Trusted Publishing [GitHub Actions authentication using cryptographically signed tokens] fully launched on crates.io, enhancing supply chain security and streamlining workflows for maintainers.

- Major progress on crate signing infrastructure using The Update Framework (TUF), including three full repository implementations and stakeholder consensus.

- Integration of the Ferrocene Language Specification (FLS) into the Rust Project, marking a critical step toward a formal Rust language specification [and "laying the groundwork for broader safety certification and formal tooling."]

- 75% reduction in CI infrastructure costs while maintaining contributor workflow stability. ["All Rust repositories are now managed through Infrastructure-as-Code, improving maintainability and security."]

- Expansion of the Safety-Critical Rust Consortium, with multiple international meetings and advances on coding guidelines aligned with safety standards like MISRA. ["The consortium is developing practical coding guidelines, aligned tooling, and reference materials to support regulated industries — including automotive, aerospace, and medical devices — adopting Rust."]

- Direct engagement with ISO C++ standards bodies and collaborative Rust-C++ exploration... The Foundation finalized its strategic roadmap, participated in ISO WG21 meetings, and initiated cross-language tooling and documentation planning. These efforts aim to unlock Rust adoption across legacy C++ environments without sacrificing safety.

The Rust Foundation also acknowledges continued funding from OpenSSF's Alpha-Omega Project and "generous infrastructure donations from organizations like AWS, GitHub, and Mullvad VPN" to the Foundation's Security Initiative, which enabled advances like including GitHub Secret Scanning and automated incident response to "Trusted Publishing" and the integration of vulnerability-surfacing capabilities into crates.io.

There was another announcement this week. In November AWS and the Rust Foundation crowdsourced "an effort to verify the Rust standard library" — and it's now resulted in a new formal verification tool called "Efficient SMT-based Context-Bounded Model Checker" (or ESBMCESBMC) This winning contribution adds ESBMC — a state-of-the-art bounded model checker — to the suite of tools used to analyze and verify Rust's standard library. By integrating through Goto-Transcoder, they enabled ESBMC to operate seamlessly in the Rust verification workflow, significantly expanding the scope and flexibility of verification efforts...

This achievement builds on years of ongoing collaboration across the Rust and formal verification communities... The collaboration has since expanded. In addition to verifying the Rust standard library, the team is exploring the use of formal methods to validate automated C-to-Rust translations, with support from AWS. This direction, highlighted by AWS Senior Principal Scientist Baris Coskun and celebrated by the ESBMC team in a recent LinkedIn post, represents an exciting new frontier for Rust safety and verification tooling.

Rust's Annual Tech Report: Trusted Publishing for Packages and a C++/Rust Interop Strategy

Comments Filter:
  • Mozilla has so many resources, they could have completely rewritten Firefox in Rust by now, just as an experiment to see if it was better.

    Instead they threw their money away on who knows what.
    • Instead they threw their money away on who knows what.

      We know exactly what they spent their money on. Not on software, but on various social programs that having to do with their core mission.
    • Not sure if rust could manage the interface for Firefox. Most interfaces require mutable trees.
      • Oh, that's only because you don't know anything about rust.

      • by DrXym ( 126579 )
        Funnily enough I modeled massive mutable trees in Rust. It might require some modicum of thought towards safety but it is not impossible.
        • It's really not even hard, I've actually done this a lot of times, usually when doing some kind of in-memory caching. I actually like doing it in rust over other languages because rust makes it easy to get it right and hard to fuck it up. This is exactly what any good tool should do.

          • And you can do this without an unsafe block?
            • Presumably you'd use a &mut variable or a RefCell ?

              • It really depends, there really is no one correct answer. A regular mutable reference won't work for multithreading or concurrency. Ideally you prefer atomic types, but those are mostly restricted to primitives. After that, prefer types with their own interior mutability. Failing that, generally mutexes wrapped in atomic reference counters. I've also done it where a single thread owns the entire structure, and everything else manipulates it via channels.

                You're supposed to be doing this in other languages as

            • by DrXym ( 126579 )
              Yes. In my case by modelling each node with a unique key and maintaining a map between the key and the node and another map & reverse map of target/source keys. I was modelling very large trees and acyclic graphs no trouble. I am sure there are other ways utilising weak references, or reference counts or similar, none of which require unsafe at any point.

              And "unsafe" just unlocks access to direct memory operations, mostly for interaction with C. Even in an unsafe block it still enforces borrow & l

      • Most interfaces require mutable trees.

        How is this hard?

"Even if you're on the right track, you'll get run over if you just sit there." -- Will Rogers

Working...