traits VS rustls

For ECIES that'd probably be something like HPKE. HPKE isn't specific to ECC though, and is defined in terms of a KEM, so the first step there would probably be defining KEM traits which would allow you to plug in ECDH or potentially a post-quantum algorithm or RSA.

No need for eternal stability. It would be indeed nice to get the API right the first time, but in practice it's borderline impossible to do. It's fine for trait crates to introduce breaking changes from time to time, especially for pre-1.0 ones. For prior art you can take a look at rand_core or RustCrypto trait crates.

I finally dusted off my barely-working git hosting solution and added a basic user account system. It took me some time to understand how exactly I was supposed to use password-hash in combination with my hashing function of choice, as well as with the DB. Using sqlx together with Rocket turned out to be somewhat easy once I figured out that I should disregard the built-in database support, since it's seemingly incompatible with sqlx.

The main difference between those two languages, I think you should look at, is power of type system. A good type system allows to encode various invariants checked at compile time, help with interoperability, and even improve performance a bit (e.g. by eliminating runtime-checks). In this regard Rust is far, far ahead of Go in my opinion and continues to improve in this regard (e.g. soon we will have const generics). For example, in RustCrypto we have trait crates which contain "interfaces" of several algorithm types. Almost all algorithm implementations in this org (and some third-party implementations) are implemented in terms of those traits, which means you can easily swap algorithms with each other and combine them like Lego blocks, without diving deep into source code. This property is especially important if you want to support less common algorithms (e.g. regional standards or newly developed algorithms).

The RustTLS project is currently setting up their own CI benchmarking workflow, so I think that you could find some inspiration there: https://github.com/rustls/rustls/issues/1385 and https://github.com/rustls/rustls/issues/1205.

I also studied this question on FFI several weeks ago in terms of "rewrite part of the system in Rust". Unexpected results could be semantic issues (e.g., different error handling methods) or security issues (FFI could be a soundness hole). I suggest going through the issues of libraries that have started rewriting work such as rust-openssl or rustls (This is the one trying to rewrite in whole rust rather than using FFI; however, you will not be able to find the mapping function in the C version and compare them). I hope this helps!

Now for rust implementation of tls. Certificates can be loaded in two ways. * Finds and loads certificates using OS specific tools3 * Uses a rust implementation of webpki4 for loading with certificates5

> Ring is mostly C/Assembly

Crypto needs to be written in Assembly to ensure that operations take a constant time, regardless of input. Writing it in a high level language like C or Rust opens you up to the compiler "optimising" routines and making them no longer constant time.

But you already knew this. And you also knew that the security audit (https://github.com/rustls/rustls/blob/master/audit/TLS-01-re...) of ring was favourable

> No issues were found with regards to the cryptographic engineering of rustls or its underlying ring library. A recommendation is provided in TLS-01-001 to optionally supplement the already solid cryptographic library with another cryptographic provider (EverCrypt) with an added benefit of formally verified cryptographic primitives. Overall, it is very clear that the developers of rustls have an extensive knowledge on how to correctly implement the TLS stack whilst avoiding the common pitfalls that surround the TLS ecosystem. This knowledge has translated reliably into an implementation of exceptional quality.

You said

> a standard library with feature flags and editions would make rust ridiculously much more productive

What's the difference between opting into a library with a feature flag and opting in with a line in Cargo.toml? Let's say you want to use the de-facto regex library. Would it really be ridiculously productive if you said you wanted the "regex" feature flag instead of the "regex" crate?

I do agree that the standard library does need a versioning story so they can remove long deprecated functions. Where it gets complicated is if a new method is reintroduced using the same name in a later edition.

I used the commands listed in the .sh file here: https://github.com/rustls/rustls/tree/main/test-ca to generate keys/certs for a server and a client (with IP.1 records for SANs). I have added the local root CA to the trust store of each VM.

This is great news, this was our single biggest annoyance with rustls. One of our cloud providers choses to issue their hosted postgres instances with TLS certificates with IP addresses. Unusual, but valid per the spec, so why not. Apparently a practise that's also popular in kubernetes settings, so I'm somewhat surprised it took 5 years to close the issue, but now I can finally recommend people to use rustls without mentioning any gotchas.

I believe it is more relevant than you think: servers running in containers, web assembler tasks running in browsers, embedded devices and kernels with total control of the system, all have the ability to do something more sensible than plain out SIGABRT or similar, and in many the case is not that the complete system is falling down. For example RustTLS is looking into allowing fallible allocators and as a pretty general-purpose library that seems like a nice feature. I do wish ulimit -v worked in a sensible manner with applications.