boring 5.3.0

use crate::hpke::HpkeKey;
use crate::ssl::ech::SslEchKeys;
use crate::ssl::test::server::{ClientSslBuilder, Server};
use crate::ssl::{
    BoxSelectCertActionFinish, ClientHello, HandshakeError, NameType, SelectCertAction,
    SelectCertError,
};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::task::Waker;

// For future reference, these configs are generated by building the bssl tool (the binary is built
// alongside boringssl) and running the following command:
//
// ./bssl generate-ech -out-ech-config-list ./list -out-ech-config ./config -out-private-key ./key
// -public-name ech.com -config-id 1
static ECH_CONFIG_LIST: &[u8] = include_bytes!("../../../test/echconfiglist");
static ECH_CONFIG: &[u8] = include_bytes!("../../../test/echconfig");
static ECH_KEY: &[u8] = include_bytes!("../../../test/echkey");

static ECH_CONFIG_2: &[u8] = include_bytes!("../../../test/echconfig-2");
static ECH_KEY_2: &[u8] = include_bytes!("../../../test/echkey-2");

fn bootstrap_ech(config: &[u8], key: &[u8], list: &[u8]) -> (Server, ClientSslBuilder) {
    let server = {
        let key = HpkeKey::dhkem_p256_sha256(key).unwrap();
        let mut ech_keys_builder = SslEchKeys::builder().unwrap();
        ech_keys_builder.add_key(true, config, key).unwrap();
        let ech_keys = ech_keys_builder.build();

        let mut builder = Server::builder();
        builder.ctx().set_ech_keys(&ech_keys).unwrap();

        builder.build()
    };

    let mut client = server.client_with_root_ca().build().builder();
    client.ssl().set_ech_config_list(list).unwrap();
    client.ssl().set_hostname("foobar.com").unwrap();

    (server, client)
}

#[test]
fn ech() {
    let (_server, client) = bootstrap_ech(ECH_CONFIG, ECH_KEY, ECH_CONFIG_LIST);

    let ssl_stream = client.connect();
    assert!(ssl_stream.ssl().ech_accepted());
}

#[test]
fn ech_disable_from_select_certificate_callback() {
    let calls = Arc::new(AtomicUsize::new(0));
    let observations = Arc::new(Mutex::new(Vec::new()));
    let server = {
        let key = HpkeKey::dhkem_p256_sha256(ECH_KEY).unwrap();
        let mut ech_keys_builder = SslEchKeys::builder().unwrap();
        ech_keys_builder.add_key(true, ECH_CONFIG, key).unwrap();
        let ech_keys = ech_keys_builder.build();

        let mut builder = Server::builder();
        builder.ctx().set_ech_keys(&ech_keys).unwrap();
        let calls = calls.clone();
        let observations = observations.clone();
        builder
            .ctx()
            .set_select_certificate_callback_with_action(move |client_hello| {
                calls.fetch_add(1, Ordering::Relaxed);
                observations.lock().unwrap().push((
                    client_hello.ssl().ech_accepted(),
                    client_hello
                        .ssl()
                        .servername(NameType::HOST_NAME)
                        .map(str::to_owned),
                ));
                if client_hello.ssl().ech_accepted() {
                    Ok(SelectCertAction::DisableEch)
                } else {
                    Ok(SelectCertAction::Success)
                }
            });

        builder.build()
    };

    let mut client = server.client_with_root_ca().build().builder();
    client.ssl().set_ech_config_list(ECH_CONFIG_LIST).unwrap();
    client.ssl().set_hostname("foobar.com").unwrap();
    let HandshakeError::Failure(failed_ssl_stream) = client.connect_err() else {
        panic!("wrong HandshakeError failure variant!");
    };

    assert!(!failed_ssl_stream.ssl().ech_accepted());
    assert!(failed_ssl_stream.ssl().get_ech_retry_configs().is_none());
    assert_eq!(calls.load(Ordering::Relaxed), 2);
    assert_eq!(
        *observations.lock().unwrap(),
        vec![
            (true, Some("foobar.com".to_owned())),
            (false, Some("ech.com".to_owned())),
        ]
    );
}

#[test]
fn ech_disable_repeatedly_fails_after_outer_client_hello() {
    let calls = Arc::new(AtomicUsize::new(0));
    let server = {
        let key = HpkeKey::dhkem_p256_sha256(ECH_KEY).unwrap();
        let mut ech_keys_builder = SslEchKeys::builder().unwrap();
        ech_keys_builder.add_key(true, ECH_CONFIG, key).unwrap();
        let ech_keys = ech_keys_builder.build();

        let mut builder = Server::builder();
        builder.should_error();
        builder.ctx().set_ech_keys(&ech_keys).unwrap();
        let calls = calls.clone();
        builder
            .ctx()
            .set_select_certificate_callback_with_action(move |_client_hello| {
                if calls.fetch_add(1, Ordering::Relaxed) < 2 {
                    Ok(SelectCertAction::DisableEch)
                } else {
                    Err(SelectCertError::ERROR)
                }
            });

        builder.build()
    };

    let mut client = server.client_with_root_ca().build().builder();
    client.ssl().set_ech_config_list(ECH_CONFIG_LIST).unwrap();
    client.ssl().set_hostname("foobar.com").unwrap();
    client.connect_err();

    assert_eq!(calls.load(Ordering::Relaxed), 2);
}

#[test]
fn ech_disable_from_async_select_certificate_callback() {
    let calls = Arc::new(AtomicUsize::new(0));
    let server = {
        let key = HpkeKey::dhkem_p256_sha256(ECH_KEY).unwrap();
        let mut ech_keys_builder = SslEchKeys::builder().unwrap();
        ech_keys_builder.add_key(true, ECH_CONFIG, key).unwrap();
        let ech_keys = ech_keys_builder.build();

        let mut builder = Server::builder();
        builder.ctx().set_ech_keys(&ech_keys).unwrap();
        let calls = calls.clone();
        builder
            .ctx()
            .set_async_select_certificate_callback_with_action(move |_| {
                let calls = calls.clone();
                Ok(Box::pin(async move {
                    Ok(Box::new(move |_client_hello: ClientHello<'_>| {
                        if calls.fetch_add(1, Ordering::Relaxed) == 0 {
                            Ok(SelectCertAction::DisableEch)
                        } else {
                            Ok(SelectCertAction::Success)
                        }
                    }) as BoxSelectCertActionFinish)
                }))
            });
        builder.ssl_cb(|ssl| ssl.set_task_waker(Some(Waker::noop().clone())));

        builder.build()
    };

    let mut client = server.client_with_root_ca().build().builder();
    client.ssl().set_ech_config_list(ECH_CONFIG_LIST).unwrap();
    client.ssl().set_hostname("foobar.com").unwrap();
    let HandshakeError::Failure(failed_ssl_stream) = client.connect_err() else {
        panic!("wrong HandshakeError failure variant!");
    };

    assert!(!failed_ssl_stream.ssl().ech_accepted());
    assert!(failed_ssl_stream.ssl().get_ech_retry_configs().is_none());
    assert_eq!(calls.load(Ordering::Relaxed), 2);
}

#[test]
fn ech_rejection() {
    // Server is initialized using `ECH_CONFIG_2`, so using `ECH_CONFIG_LIST` instead of
    // `ECH_CONFIG_LIST_2` should trigger rejection.
    let (_server, client) = bootstrap_ech(ECH_CONFIG_2, ECH_KEY_2, ECH_CONFIG_LIST);

    let HandshakeError::Failure(failed_ssl_stream) = client.connect_err() else {
        panic!("wrong HandshakeError failure variant!");
    };
    assert_eq!(
        failed_ssl_stream.ssl().get_ech_name_override(),
        Some(b"ech.com".to_vec().as_ref())
    );
    assert!(failed_ssl_stream.ssl().get_ech_retry_configs().is_some());
    assert!(!failed_ssl_stream.ssl().ech_accepted());
}

#[test]
fn ech_grease() {
    let server = Server::builder().build();

    let mut client = server.client_with_root_ca().build().builder();
    // Verified with a pcap locally that the ECH extension gets sent due to GREASE
    client.ssl().set_enable_ech_grease(true);

    let ssl_stream = client.connect();
    assert!(!ssl_stream.ssl().ech_accepted());
}