I don't have a use case for this yet, but as more and more of the rust community moves towards async libraries like tokio, I wonder if there's a way ResolvesServerCert could support callback functions which do not return immediately/play nicely with the tokio Core.

Specific use case that might require this are servers which process many different domains and store certs/keys in a database, or servers which attempt to lazily obtain certificates from CAs like let's encrypt.

In the latest master, ClientConfig and ServerConfig no longer have a new(). There are new Builder types to construct them, but someone attempting to port old code without many changes might be tempted to try and instantiated a ClientConfig or ServerConfig by setting all of their fields. That's currently impossible, because verifier on both types is private.

Is that an intentional choice, to prevent construction of ClientConfig and ServerConfig without going through the Builders? If so, we should document it on the respective structs. Also if that's the case: should all the other fields be made private, if the intent is only to support construction via Builder?

KTLS is tls support in linux kernel, but it only handles symmetric encryption and decryption, so using Rustls as a handshake is great.

We can simply public SessionSecrets, but this does not apply to TLS 1.3.

Rustls implements client- and server-side requirements for RFC8446 Appendix D.4, except it forgets to send a session ID in the ClientHello when also resuming TLS 1.3 sessions. This PR addresses that issue.

This is what I've been using with my QUIC implementation; seems to work.

As a next step, we could pull out the TransportParameters code again, and I could just pass in an UnknownExtension, but I wanted to run this by you first.

The clone is a bit ugly, but I'm not sure there is a better way right now. I suppose there could be a second ext_refs that copies a ref from the locally-created extensions, which we could then add the externally-added extensions to. There is also the risk of code size bulking from the extra impls, not sure how concerning that is to you.

Hi!

My Tokio-based PostgreSQL crate https://nest.pijul.com/pmeunier/pleingres was originally based on Rustls, but I couldn't connect to a Google Cloud PostgreSQL database.

I replaced tokio-rustls with tokio-openssl, and it started working.

The error originated from webpki, and was BadDER. The CA certificate was from Google, and there was no other DER-encoded file involved (besides what's in webpki-roots maybe?).

Now that I got a working version, I can reproduce that bug if needed. With OpenSSL, I needed a function that doesn't check the hostname (the host I want to connect to has no hostname and is supposed to be accessed by its IP address).

As discussed in #584, this patch makes SessionID an Option in most places. I had to touch parts of the codebase I'm not very familiar with, so I'm not that confident in this patch, but it does pass all of the tests.

I wasn't sure what to do when reading a zero-length SessionID off the wire. I left it as-is, but perhaps it should result in None.

Here I will leave some tips for upgrading to ring 0.15, which implements a new AEAD API, a new HKDF API, and an extended ring::rand API. I'll describe how Rustls can use the new features in this issue.

There is a discussion about TLS implementations in the newly spun up networking WG:

https://github.com/rust-lang-nursery/wg-net/issues/40

Given the comments there, I've been thinking that it would be great if the rustls stack (which probably means ring + webpki + rustls) went through a security audit somehow (maybe with a MOSS grant?).

Currently, to look at traffic in wireshark, you have to opt-in not just by setting the env variable, but also opting-in in the application itself. This makes it possible to debug the traffic with just the env variable, which is the same default behavior as curl and openssl.

libp2p needs to be able to verify certificates that would normally be considered invalid (they contain a critical extension that webpki does not, and should not, know about). It also needs to return data from this process to the application. The easiest way to do this is for rustls to not even try to parse the certificate itself. Instead, it should just treat it as bytes.

Hey there,

In the API documentation (https://docs.rs/rustls/0.20.7/rustls/server/struct.ClientHello.html), I don't see any option to query the IP address of the sender of the ClientHello message. This would be a welcome addition to see who is sending these messages (for ratelimiting, etcetera)!

This is for #466

Todo:

• [ ] review coverage
• [ ] reinstate unit tests in client/handy.rs
• [ ] add tests for overall TLS1.3 repeated resumption behaviour

Any recommendation how to tweak TLS for latency purposes? I have a lot of small constantly incoming packets and sometimes i see a lot of batches made by Rustls.

Hi!

I was looking at the code to verify SCTs in a certificate, and it looks like yall use this sct.rs library from rustls. Looking at the source code from the library, it doesn't remove embedded SCTs from a certificate if it has them before validating the signature. I believe this implies that the caller has to do this instead, but I wasn't able to find where/whether Rustls does this verification.

Would you be able to confirm whether Rustls has this functionality and if so, point me to it? I'm trying to get the sct verification library to work for my own certificate verification and not able to find a straightforward way of doing this.

I have implemented these method and enabled "dangerous_configuration". `struct SkipServerVerification;

impl SkipServerVerification { fn new() -> Arc { Arc::new(Self) } }

impl rustls::client::ServerCertVerifier for SkipServerVerification { fn verify_server_cert( &self, _end_entity: &rustls::Certificate, _intermediates: &[rustls::Certificate], _server_name: &rustls::ServerName, _scts: &mut dyn Iterator<Item = &[u8]>, _ocsp_response: &[u8], _now: std::time::SystemTime, ) -> Result<rustls::client::ServerCertVerified, rustls::Error> { Ok(rustls::client::ServerCertVerified::assertion()) } } ` Now, i want to use ClientConfig for creating a custom configuration :

fn configure_client() -> ClientConfig { let crypto = rustls::ClientConfig::builder().with_safe_defaults().with_custom_certificate_verifier(SkipServerVerification::new()).with_single_cert(client_cert.to_vec(), Key::RSA(client_key.to_vec())); rustls::ClientConfig::new(Arc::new(crypto)) } I want to pass these certificate to ClientConfig:

let root_certs = include_bytes!("../certs/ca.crt"); let client_cert = include_bytes!("../certs/client.crt"); let client_key = include_bytes!("../certs/client.key"); How can i achieve this? Thanks.