Compatibility with C is Key for Memory Safe Software

When we're evaluating potential Prossimo initiatives we take a number of things into consideration. Perhaps one of the most important is compatibility with existing C (and C++) software.

Most of the Internet's critical low-level software infrastructure is written in C or C++. This includes the Linux, Windows, and Apple kernels, most DNS, TLS, NTP, and BGP implementations, most popular server and proxy software, and the core utilities in Linux and most Unix-like operating systems. It's also the case for critical higher-level software infrastructure, like web browsers and media codecs.

This is not going to change any time soon. We're in the beginning phases of a journey towards memory safety for the Internet's critical software infrastructure, and as we get going it makes the most sense to break down big problems into smaller ones by focusing on replacing components within existing C and C++ software. This is why it's a high priority for Prossimo projects to interoperate with C and C++.

Rustls (TLS)

We've invested quite a bit in the Rustls TLS library, which is now one of the fastest and safest TLS implementations out there. In particular, we've invested heavily in C compatibility.

Rustls has a native Rust API, but it also has a C interface to the Rust API as well as an OpenSSL v3 compatibility layer. The former is probably most useful for C developers doing initial integration with Rustls, or for those transitioning from OpenSSL and hoping to make use of a better API. The latter is a way for existing OpenSSL 3 API users to migrate to Rustls with as little effort as possible, perhaps without even recompiling their code!

Check out these blog posts for more information about Rustls:

• Rustls Server-Side Performance

• Rustls Outperforms OpenSSL and BoringSSL

• Encrypted Client Hello (ECH) Support for Rustls

• Rustls Gains OpenSSL and Nginx Compatibility

• The Rustls TLS Library Adds Post-Quantum Key Exchange Support

• Rustls Now Using AWS Libcrypto for Rust, Gains FIPS Support

zlib-rs

Similarly, the zlib-rs project provides a high performance Rust implementation of the zlib compression format that is drop-in compatible with the zlib C API.

Hopefully we (and others) can take what we've learned here and use it to build other memory safe compression libraries. The Trifecta Tech Foundation is the new home for zlib-rs, and they've published some great blog posts about their work:

• zlib-rs is faster than C

• SIMD in zlib-rs (part 1): Autovectorization and target features

• SIMD in zlib-rs (part 2): compare256

• The fastest WASM zlib

rav1d (AV1 Decoder)

The rav1d AV1 decoder is a fork of the dav1d decoder with the C code replaced by memory safe Rust code. It comes with a C API promising drop-in compatibility with dav1d's C API so it's easy to integrate into existing C programs.

As with compression libraries, hopefully we (and others) can take what we've learned here and use it to build other memory safe media decoders. Here are some blog posts about what we've learned:

• Porting C to Rust for a Fast and Safe AV1 Media Decoder

• Optimizing rav1d, an AV1 Decoder in Rust

• $20,000 rav1d AV1 Decoder Performance Bounty

Rust for Linux

Rust for Linux aims to allow integrating components written in Rust with the rest of the Linux kernel, which is written in C. To that end, developing Rust interfaces to C APIs is central to the work. Kernel developers working in C do not need to know Rust, and Rust code can be introduced component by component.

You can read more about the Rust for Linux project here.

bindgen

From 2022-2023, we made major contributions to bindgen, which automatically generates Rust FFI bindings to C (and some C++) libraries. This has made life easier for many people who integrate Rust with C and C++.

Ferrous Systems was the contractor for this work, they wrote some great blog posts about it:

• Binding with bindgen

• Our latest adventures with bindgen

• Automating Releases for Bindgen