Struct ClientConnection 

pub struct ClientConnection(/* private fields */);

A TLS 1.3 client connection. The ClientHello is queued at construction.

Implementations

impl ClientConnection

pub fn new( cfg: Arc<ClientConfig>, server_name: &str, ) -> Result<ClientConnection>

server_name is verified against the certificate and sent as SNI (unless it is an IP address).

Examples found in repository

examples/../tests/fuzzing/mod.rs (line 131)

pub fn corpus() -> Corpus {
    let ss = certgen::issue(&CertParams::server(&["localhost"]), PrivateKey::generate_ec(EcCurve::P256), None);
    let mut roots = RootStore::empty();
    roots.add_der(&ss.cert_der).unwrap();
    let scfg = Arc::new(ServerConfig::new(CertifiedKey::new(vec![ss.cert_der.clone()], ss.key.clone()).unwrap()).with_alpn(&[b"h3", b"http/1.1"]));
    let mut cc = ClientConfig::new(roots).with_alpn(&[b"h3", b"http/1.1"]);
    cc.sessions = None;
    let ccfg = Arc::new(cc);
    // a TLS handshake transcript
    let mut c = ClientConnection::new(ccfg.clone(), "localhost").unwrap();
    let mut s = ServerConnection::new(scfg.clone());
    let ch = c.tls_output().to_vec();
    c.consume_tls_output(ch.len());
    s.read_tls(&ch);
    s.process_new_packets().unwrap();
    let flight = s.tls_output().to_vec();
    let mut ch_plus = ch.clone();
    ch_plus.extend_from_slice(&[20, 3, 3, 0, 1, 1, 23, 3, 3, 0, 20]);
    ch_plus.extend(std::iter::repeat_n(0xaa, 20));
    // a QUIC handshake: the ClientHello message and the server's Handshake-level flight
    let mut qc = QuicConnection::new_client(ccfg.clone(), "localhost", vec![1, 2, 3]).unwrap();
    let mut qs = QuicConnection::new_server(scfg.clone(), vec![4, 5, 6]);
    let mut ch_msg = Vec::new();
    qc.write_handshake(&mut ch_msg);
    qs.read_handshake(Level::Initial, &ch_msg).unwrap();
    let mut sh = Vec::new();
    qs.write_handshake(&mut sh);
    let mut hs = Vec::new();
    qs.write_handshake(&mut hs);
    Corpus {
        scfg,
        ccfg,
        to_server: vec![ch, ch_plus],
        to_client: vec![flight],
        ch_msg,
        server_hs_flight: hs,
        key_der: ss.key_der.clone(),
        cert_der: ss.cert_der,
    }
}

/// Feeds `data` in random-sized pieces and processes after each; checks that errors stick.
fn feed(rng: &mut Rng, conn: &mut simoom_tls::Connection, data: &[u8]) {
    let mut off = 0;
    while off < data.len() {
        let k = 1 + rng.below(data.len() - off);
        let taken = conn.read_tls(&data[off..off + k]);
        off += taken;
        let r = conn.process_new_packets();
        if let Err(e) = r {
            assert_eq!(conn.process_new_packets().unwrap_err(), e, "errors must stick");
            assert!(conn.tls_output().len() < 64 * 1024, "output stays bounded");
            assert!(conn.write_plaintext(b"x").is_err(), "a failed connection refuses writes");
            return;
        }
        if taken == 0 {
            // buffer full: the application reads plaintext
            let n = conn.plaintext().len();
            if n == 0 {
                return;
            }
            conn.consume_plaintext(n);
        }
    }
}

pub fn server_records(rng: &mut Rng, c: &Corpus, iters: usize) {
    for _ in 0..iters {
        let seed = &c.to_server[rng.below(c.to_server.len())];
        let data = mutate(rng, seed, &c.to_client);
        let mut s = ServerConnection::new(c.scfg.clone());
        feed(rng, &mut s, &data);
    }
}

pub fn client_records(rng: &mut Rng, c: &Corpus, iters: usize) {
    for _ in 0..iters {
        let data = mutate(rng, &c.to_client[0], &c.to_server);
        let mut cl = ClientConnection::new(c.ccfg.clone(), "localhost").unwrap();
        let n = cl.tls_output().len();
        cl.consume_tls_output(n);
        feed(rng, &mut cl, &data);
    }
}

examples/bench_tls.rs (line 174)

fn main() {
    let openssl = std::env::args().any(|a| a == "--openssl");
    let d = Duration::from_millis(if std::env::args().any(|a| a == "--quick") { 300 } else { 1500 });
    println!("simoom-tls benchmarks (single thread), hardware AES: {}, CLMUL: {}, SHA-NI: {}", simoom_sys::arch::has_aes(), simoom_sys::arch::has_clmul(), simoom_sys::arch::has_sha256());
    println!();
    println!("{:<34} {:>12} {:>12}", "AEAD seal (encrypt + tag)", "16384 B", "1400 B");
    let aad = [0u8; 13];
    let mut buf = vec![0x5au8; 16384];
    let gcm128 = AesGcm::new(&[1u8; 16]);
    let gcm256 = AesGcm::new(&[1u8; 32]);
    let gcm128s = AesGcm::new_soft(&[1u8; 16]);
    let chacha = ChaCha20Poly1305::new(&[2u8; 32]);
    let mut seq = 0u64;
    let mut nonce = || {
        seq += 1;
        let mut n = [0u8; 12];
        n[4..].copy_from_slice(&seq.to_be_bytes());
        n
    };
    let f1 = |n: &[u8; 12], b: &mut [u8]| gcm128.seal(n, &aad, b);
    let f2 = |n: &[u8; 12], b: &mut [u8]| gcm256.seal(n, &aad, b);
    let f3 = |n: &[u8; 12], b: &mut [u8]| gcm128s.seal(n, &aad, b);
    let f4 = |n: &[u8; 12], b: &mut [u8]| chacha.seal(n, &aad, b);
    let algs: [(&str, &dyn Fn(&[u8; 12], &mut [u8]) -> [u8; 16]); 4] =
        [("AES-128-GCM", &f1), ("AES-256-GCM", &f2), ("AES-128-GCM (portable, bitsliced)", &f3), ("ChaCha20-Poly1305", &f4)];
    for (name, f) in algs {
        let size_d = if name.contains("portable") { d / 3 } else { d };
        let a = rate(size_d, || {
            black_box(f(&nonce(), &mut buf));
        });
        let b = rate(size_d, || {
            black_box(f(&nonce(), &mut buf[..1400]));
        });
        println!("{:<34} {:>9.2} GB/s {:>7.2} GB/s", name, gbps(a, 16384), gbps(b, 1400));
    }
    let mut tag = [0u8; 16];
    let n12 = [0u8; 12];
    tag.copy_from_slice(&gcm128.seal(&n12, &aad, &mut buf));
    let o = rate(d, || {
        // open fails (buffer changed) but does the full work: GHASH, CTR, tag compare
        black_box(gcm128.open(&n12, &aad, &mut buf, &tag));
    });
    println!("{:<34} {:>9.2} GB/s", "AES-128-GCM open", gbps(o, 16384));

    println!();
    println!("{:<34} {:>12}", "Primitive", "ops/s");
    let sk = [7u8; 32];
    let pk = x25519::x25519_base(&[9u8; 32]);
    println!("{:<34} {:>12.0}", "X25519 key generation (table)", rate(d, || {
        black_box(x25519::x25519_base(black_box(&sk)));
    }));
    println!("{:<34} {:>12.0}", "X25519 shared secret (ladder)", rate(d, || {
        black_box(x25519::x25519(black_box(&sk), &pk));
    }));
    let d256 = p256::generate_private();
    let q256 = p256::public_key(&p256::generate_private()).unwrap();
    let h = [3u8; 32];
    println!("{:<34} {:>12.0}", "P-256 key generation", rate(d, || {
        black_box(p256::public_key(black_box(&d256)));
    }));
    println!("{:<34} {:>12.0}", "P-256 ECDH", rate(d, || {
        black_box(p256::ecdh(black_box(&d256), &q256));
    }));
    let (r, s) = p256::sign(&d256, &h, simoom_tls::crypto::sha2::HashAlg::Sha256).unwrap();
    let pub256 = p256::public_key(&d256).unwrap();
    println!("{:<34} {:>12.0}", "ECDSA P-256 sign", rate(d, || {
        black_box(p256::sign(black_box(&d256), &h, simoom_tls::crypto::sha2::HashAlg::Sha256));
    }));
    println!("{:<34} {:>12.0}", "ECDSA P-256 verify", rate(d, || {
        black_box(p256::verify(&pub256, &h, &r, &s));
    }));
    let seed = [5u8; 32];
    let edpub = simoom_tls::crypto::ed25519::public_key(&seed);
    // as the server signs: the key's public half is known (OpenSSL keeps it in the key too)
    println!("{:<34} {:>12.0}", "Ed25519 sign", rate(d, || {
        black_box(simoom_tls::crypto::ed25519::sign_with_public(&seed, &edpub, b"message"));
    }));
    let edsig = simoom_tls::crypto::ed25519::sign(&seed, b"message");
    println!("{:<34} {:>12.0}", "Ed25519 verify", rate(d, || {
        black_box(simoom_tls::crypto::ed25519::verify(&edpub, b"message", &edsig));
    }));
    let rsa = PrivateKey::from_pem(include_bytes!("../testdata/rsa2048.pkcs1.pem")).unwrap();
    if let PrivateKey::Rsa(k) = &rsa {
        let dg = [1u8; 32];
        println!("{:<34} {:>12.0}", "RSA-2048 PSS sign", rate(d, || {
            black_box(k.sign_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg));
        }));
        let sig = k.sign_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg).unwrap();
        println!("{:<34} {:>12.0}", "RSA-2048 PSS verify", rate(d, || {
            black_box(k.public.verify_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg, &sig, Some(32)));
        }));
    }

    // handshakes
    let ss = certgen::issue(&CertParams::server(&["localhost"]), PrivateKey::generate_ec(EcCurve::P256), None);
    let mut roots = RootStore::empty();
    roots.add_der(&ss.cert_der).unwrap();
    let mut scfg = ServerConfig::new(CertifiedKey::new(vec![ss.cert_der.clone()], ss.key.clone()).unwrap());
    scfg.groups = vec![NamedGroup::X25519];
    let scfg = Arc::new(scfg);
    let mut cfull = ClientConfig::new(roots.clone());
    cfull.sessions = None;
    cfull.groups = vec![NamedGroup::X25519];
    let cfull = Arc::new(cfull);
    let mut cres = ClientConfig::new(roots);
    cres.groups = vec![NamedGroup::X25519];
    let cres = Arc::new(cres);

    println!();
    println!("{:<44} {:>12}", "TLS 1.3 handshake (X25519, ECDSA P-256 cert)", "per second");
    let full = rate(d, || {
        let mut c = ClientConnection::new(cfull.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        pump(&mut c, &mut s);
        assert!(!s.is_handshaking());
    });
    println!("{:<44} {:>12.0}", "full, client + server", full);
    // server side only: replay a fresh ClientHello per iteration and time the server's work
    let mut server_time = Duration::ZERO;
    let mut n = 0u32;
    let t0 = Instant::now();
    while t0.elapsed() < d {
        let mut c = ClientConnection::new(cfull.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        let ch = c.tls_output().to_vec();
        c.consume_tls_output(ch.len());
        let t = Instant::now();
        s.read_tls(&ch);
        s.process_new_packets().unwrap();
        server_time += t.elapsed();
        let flight = s.tls_output().to_vec();
        s.consume_tls_output(flight.len());
        c.read_tls(&flight);
        c.process_new_packets().unwrap();
        let fin = c.tls_output().to_vec();
        let t = Instant::now();
        s.read_tls(&fin);
        s.process_new_packets().unwrap();
        server_time += t.elapsed();
        n += 1;
    }
    println!("{:<44} {:>12.0}", "full, server side only", n as f64 / server_time.as_secs_f64());
    // resumption: prime the cache, then each connection uses one ticket and stores a new one
    let mut c = ClientConnection::new(cres.clone(), "localhost").unwrap();
    let mut s = ServerConnection::new(scfg.clone());
    pump(&mut c, &mut s);
    let resumed = rate(d, || {
        let mut c = ClientConnection::new(cres.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        pump(&mut c, &mut s);
        assert!(c.is_resumed());
    });
    println!("{:<44} {:>12.0}", "PSK-DHE resumption, client + server", resumed);

    if openssl {
        println!();
        println!("openssl speed (same machine, single thread):");
        for args in [
            &["speed", "-seconds", "2", "-bytes", "16384", "-evp", "aes-128-gcm"][..],
            &["speed", "-seconds", "2", "-bytes", "1400", "-evp", "aes-128-gcm"][..],
            &["speed", "-seconds", "2", "-bytes", "16384", "-evp", "chacha20-poly1305"][..],
            &["speed", "-seconds", "2", "-bytes", "1400", "-evp", "chacha20-poly1305"][..],
            &["speed", "-seconds", "2", "ecdhx25519", "ecdhp256", "ecdsap256", "ed25519", "rsa2048"][..],
        ] {
            match std::process::Command::new("openssl").args(args).output() {
                Ok(o) => {
                    let out = String::from_utf8_lossy(&o.stdout);
                    for line in out.lines().filter(|l| {
                        l.starts_with("AES-128-GCM") || l.starts_with("ChaCha20-Poly1305") || l.contains(" sign ") || l.contains("op/s") || l.starts_with("rsa") || l.contains("ecdh") || l.contains("ecdsa") || l.contains("Ed25519") || l.contains("type")
                    }) {
                        println!("  {line}");
                    }
                }
                Err(e) => println!("  openssl not available: {e}"),
            }
        }
    }
}

pub fn into_inner(self) -> Connection

The underlying connection (for example to call Connection::export_traffic_secrets).

Methods from Deref<Target = Connection>

pub fn read_tls(&mut self, data: &[u8]) -> usize

Buffers received TLS bytes and returns how many were taken (fewer than offered, possibly zero, while earlier input waits to be processed or read).

Examples found in repository

examples/bench_tls.rs (line 46)

fn pump(c: &mut Connection, s: &mut Connection) {
    loop {
        let mut moved = false;
        if c.wants_write() {
            let n = s.read_tls(c.tls_output());
            c.consume_tls_output(n);
            s.process_new_packets().unwrap();
            moved = true;
        }
        if s.wants_write() {
            let n = c.read_tls(s.tls_output());
            s.consume_tls_output(n);
            c.process_new_packets().unwrap();
            moved = true;
        }
        if !moved {
            return;
        }
    }
}

fn main() {
    let openssl = std::env::args().any(|a| a == "--openssl");
    let d = Duration::from_millis(if std::env::args().any(|a| a == "--quick") { 300 } else { 1500 });
    println!("simoom-tls benchmarks (single thread), hardware AES: {}, CLMUL: {}, SHA-NI: {}", simoom_sys::arch::has_aes(), simoom_sys::arch::has_clmul(), simoom_sys::arch::has_sha256());
    println!();
    println!("{:<34} {:>12} {:>12}", "AEAD seal (encrypt + tag)", "16384 B", "1400 B");
    let aad = [0u8; 13];
    let mut buf = vec![0x5au8; 16384];
    let gcm128 = AesGcm::new(&[1u8; 16]);
    let gcm256 = AesGcm::new(&[1u8; 32]);
    let gcm128s = AesGcm::new_soft(&[1u8; 16]);
    let chacha = ChaCha20Poly1305::new(&[2u8; 32]);
    let mut seq = 0u64;
    let mut nonce = || {
        seq += 1;
        let mut n = [0u8; 12];
        n[4..].copy_from_slice(&seq.to_be_bytes());
        n
    };
    let f1 = |n: &[u8; 12], b: &mut [u8]| gcm128.seal(n, &aad, b);
    let f2 = |n: &[u8; 12], b: &mut [u8]| gcm256.seal(n, &aad, b);
    let f3 = |n: &[u8; 12], b: &mut [u8]| gcm128s.seal(n, &aad, b);
    let f4 = |n: &[u8; 12], b: &mut [u8]| chacha.seal(n, &aad, b);
    let algs: [(&str, &dyn Fn(&[u8; 12], &mut [u8]) -> [u8; 16]); 4] =
        [("AES-128-GCM", &f1), ("AES-256-GCM", &f2), ("AES-128-GCM (portable, bitsliced)", &f3), ("ChaCha20-Poly1305", &f4)];
    for (name, f) in algs {
        let size_d = if name.contains("portable") { d / 3 } else { d };
        let a = rate(size_d, || {
            black_box(f(&nonce(), &mut buf));
        });
        let b = rate(size_d, || {
            black_box(f(&nonce(), &mut buf[..1400]));
        });
        println!("{:<34} {:>9.2} GB/s {:>7.2} GB/s", name, gbps(a, 16384), gbps(b, 1400));
    }
    let mut tag = [0u8; 16];
    let n12 = [0u8; 12];
    tag.copy_from_slice(&gcm128.seal(&n12, &aad, &mut buf));
    let o = rate(d, || {
        // open fails (buffer changed) but does the full work: GHASH, CTR, tag compare
        black_box(gcm128.open(&n12, &aad, &mut buf, &tag));
    });
    println!("{:<34} {:>9.2} GB/s", "AES-128-GCM open", gbps(o, 16384));

    println!();
    println!("{:<34} {:>12}", "Primitive", "ops/s");
    let sk = [7u8; 32];
    let pk = x25519::x25519_base(&[9u8; 32]);
    println!("{:<34} {:>12.0}", "X25519 key generation (table)", rate(d, || {
        black_box(x25519::x25519_base(black_box(&sk)));
    }));
    println!("{:<34} {:>12.0}", "X25519 shared secret (ladder)", rate(d, || {
        black_box(x25519::x25519(black_box(&sk), &pk));
    }));
    let d256 = p256::generate_private();
    let q256 = p256::public_key(&p256::generate_private()).unwrap();
    let h = [3u8; 32];
    println!("{:<34} {:>12.0}", "P-256 key generation", rate(d, || {
        black_box(p256::public_key(black_box(&d256)));
    }));
    println!("{:<34} {:>12.0}", "P-256 ECDH", rate(d, || {
        black_box(p256::ecdh(black_box(&d256), &q256));
    }));
    let (r, s) = p256::sign(&d256, &h, simoom_tls::crypto::sha2::HashAlg::Sha256).unwrap();
    let pub256 = p256::public_key(&d256).unwrap();
    println!("{:<34} {:>12.0}", "ECDSA P-256 sign", rate(d, || {
        black_box(p256::sign(black_box(&d256), &h, simoom_tls::crypto::sha2::HashAlg::Sha256));
    }));
    println!("{:<34} {:>12.0}", "ECDSA P-256 verify", rate(d, || {
        black_box(p256::verify(&pub256, &h, &r, &s));
    }));
    let seed = [5u8; 32];
    let edpub = simoom_tls::crypto::ed25519::public_key(&seed);
    // as the server signs: the key's public half is known (OpenSSL keeps it in the key too)
    println!("{:<34} {:>12.0}", "Ed25519 sign", rate(d, || {
        black_box(simoom_tls::crypto::ed25519::sign_with_public(&seed, &edpub, b"message"));
    }));
    let edsig = simoom_tls::crypto::ed25519::sign(&seed, b"message");
    println!("{:<34} {:>12.0}", "Ed25519 verify", rate(d, || {
        black_box(simoom_tls::crypto::ed25519::verify(&edpub, b"message", &edsig));
    }));
    let rsa = PrivateKey::from_pem(include_bytes!("../testdata/rsa2048.pkcs1.pem")).unwrap();
    if let PrivateKey::Rsa(k) = &rsa {
        let dg = [1u8; 32];
        println!("{:<34} {:>12.0}", "RSA-2048 PSS sign", rate(d, || {
            black_box(k.sign_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg));
        }));
        let sig = k.sign_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg).unwrap();
        println!("{:<34} {:>12.0}", "RSA-2048 PSS verify", rate(d, || {
            black_box(k.public.verify_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg, &sig, Some(32)));
        }));
    }

    // handshakes
    let ss = certgen::issue(&CertParams::server(&["localhost"]), PrivateKey::generate_ec(EcCurve::P256), None);
    let mut roots = RootStore::empty();
    roots.add_der(&ss.cert_der).unwrap();
    let mut scfg = ServerConfig::new(CertifiedKey::new(vec![ss.cert_der.clone()], ss.key.clone()).unwrap());
    scfg.groups = vec![NamedGroup::X25519];
    let scfg = Arc::new(scfg);
    let mut cfull = ClientConfig::new(roots.clone());
    cfull.sessions = None;
    cfull.groups = vec![NamedGroup::X25519];
    let cfull = Arc::new(cfull);
    let mut cres = ClientConfig::new(roots);
    cres.groups = vec![NamedGroup::X25519];
    let cres = Arc::new(cres);

    println!();
    println!("{:<44} {:>12}", "TLS 1.3 handshake (X25519, ECDSA P-256 cert)", "per second");
    let full = rate(d, || {
        let mut c = ClientConnection::new(cfull.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        pump(&mut c, &mut s);
        assert!(!s.is_handshaking());
    });
    println!("{:<44} {:>12.0}", "full, client + server", full);
    // server side only: replay a fresh ClientHello per iteration and time the server's work
    let mut server_time = Duration::ZERO;
    let mut n = 0u32;
    let t0 = Instant::now();
    while t0.elapsed() < d {
        let mut c = ClientConnection::new(cfull.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        let ch = c.tls_output().to_vec();
        c.consume_tls_output(ch.len());
        let t = Instant::now();
        s.read_tls(&ch);
        s.process_new_packets().unwrap();
        server_time += t.elapsed();
        let flight = s.tls_output().to_vec();
        s.consume_tls_output(flight.len());
        c.read_tls(&flight);
        c.process_new_packets().unwrap();
        let fin = c.tls_output().to_vec();
        let t = Instant::now();
        s.read_tls(&fin);
        s.process_new_packets().unwrap();
        server_time += t.elapsed();
        n += 1;
    }
    println!("{:<44} {:>12.0}", "full, server side only", n as f64 / server_time.as_secs_f64());
    // resumption: prime the cache, then each connection uses one ticket and stores a new one
    let mut c = ClientConnection::new(cres.clone(), "localhost").unwrap();
    let mut s = ServerConnection::new(scfg.clone());
    pump(&mut c, &mut s);
    let resumed = rate(d, || {
        let mut c = ClientConnection::new(cres.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        pump(&mut c, &mut s);
        assert!(c.is_resumed());
    });
    println!("{:<44} {:>12.0}", "PSK-DHE resumption, client + server", resumed);

    if openssl {
        println!();
        println!("openssl speed (same machine, single thread):");
        for args in [
            &["speed", "-seconds", "2", "-bytes", "16384", "-evp", "aes-128-gcm"][..],
            &["speed", "-seconds", "2", "-bytes", "1400", "-evp", "aes-128-gcm"][..],
            &["speed", "-seconds", "2", "-bytes", "16384", "-evp", "chacha20-poly1305"][..],
            &["speed", "-seconds", "2", "-bytes", "1400", "-evp", "chacha20-poly1305"][..],
            &["speed", "-seconds", "2", "ecdhx25519", "ecdhp256", "ecdsap256", "ed25519", "rsa2048"][..],
        ] {
            match std::process::Command::new("openssl").args(args).output() {
                Ok(o) => {
                    let out = String::from_utf8_lossy(&o.stdout);
                    for line in out.lines().filter(|l| {
                        l.starts_with("AES-128-GCM") || l.starts_with("ChaCha20-Poly1305") || l.contains(" sign ") || l.contains("op/s") || l.starts_with("rsa") || l.contains("ecdh") || l.contains("ecdsa") || l.contains("Ed25519") || l.contains("type")
                    }) {
                        println!("  {line}");
                    }
                }
                Err(e) => println!("  openssl not available: {e}"),
            }
        }
    }
}

examples/size_server.rs (line 24)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 3 {
        eprintln!("usage: size_server CERT.pem KEY.pem < client_flight");
        std::process::exit(2);
    }
    let cert = std::fs::read(&args[1]).expect("certificate");
    let key = std::fs::read(&args[2]).expect("key");
    let cfg = Arc::new(ServerConfig::from_pem(&cert, &key).expect("server config").with_alpn(&[b"h2", b"http/1.1"]));
    let mut conn = ServerConnection::new(cfg);
    let mut input = Vec::new();
    std::io::stdin().read_to_end(&mut input).expect("stdin");
    conn.read_tls(&input);
    if let Err(e) = conn.process_new_packets() {
        eprintln!("{e:?}");
    }
    let out = conn.tls_output().to_vec();
    conn.consume_tls_output(out.len());
    std::io::stdout().write_all(&out).expect("stdout");
    let mut buf = [0u8; 1024];
    let n = conn.read_plaintext(&mut buf);
    std::io::stdout().write_all(&buf[..n]).expect("stdout");
}

examples/size_features.rs (line 68)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 3 {
        eprintln!("usage: size_features CERT.pem KEY.pem [PASSWORD [KEYSTORE [OCSP.der [CRL]]]] < client_flight");
        std::process::exit(2);
    }
    let cfg = Arc::new(config(&args));
    #[cfg(feature = "blocking")]
    if std::env::var("SIZE_FEATURES_LISTEN").is_ok() {
        let l = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
        let (tcp, _) = l.accept().expect("accept");
        let mut s = simoom_tls::blocking::accept(tcp, cfg).expect("handshake");
        let mut buf = [0u8; 1024];
        let n = s.read(&mut buf).expect("read");
        s.write_all(&buf[..n]).expect("write");
        return;
    }
    let mut conn = ServerConnection::new(cfg);
    let mut input = Vec::new();
    std::io::stdin().read_to_end(&mut input).expect("stdin");
    conn.read_tls(&input);
    if let Err(e) = conn.process_new_packets() {
        eprintln!("{e:?}");
    }
    let out = conn.tls_output().to_vec();
    conn.consume_tls_output(out.len());
    std::io::stdout().write_all(&out).expect("stdout");
    let mut buf = [0u8; 1024];
    let n = conn.read_plaintext(&mut buf);
    std::io::stdout().write_all(&buf[..n]).expect("stdout");
}

examples/../tests/fuzzing/mod.rs (line 135)

pub fn corpus() -> Corpus {
    let ss = certgen::issue(&CertParams::server(&["localhost"]), PrivateKey::generate_ec(EcCurve::P256), None);
    let mut roots = RootStore::empty();
    roots.add_der(&ss.cert_der).unwrap();
    let scfg = Arc::new(ServerConfig::new(CertifiedKey::new(vec![ss.cert_der.clone()], ss.key.clone()).unwrap()).with_alpn(&[b"h3", b"http/1.1"]));
    let mut cc = ClientConfig::new(roots).with_alpn(&[b"h3", b"http/1.1"]);
    cc.sessions = None;
    let ccfg = Arc::new(cc);
    // a TLS handshake transcript
    let mut c = ClientConnection::new(ccfg.clone(), "localhost").unwrap();
    let mut s = ServerConnection::new(scfg.clone());
    let ch = c.tls_output().to_vec();
    c.consume_tls_output(ch.len());
    s.read_tls(&ch);
    s.process_new_packets().unwrap();
    let flight = s.tls_output().to_vec();
    let mut ch_plus = ch.clone();
    ch_plus.extend_from_slice(&[20, 3, 3, 0, 1, 1, 23, 3, 3, 0, 20]);
    ch_plus.extend(std::iter::repeat_n(0xaa, 20));
    // a QUIC handshake: the ClientHello message and the server's Handshake-level flight
    let mut qc = QuicConnection::new_client(ccfg.clone(), "localhost", vec![1, 2, 3]).unwrap();
    let mut qs = QuicConnection::new_server(scfg.clone(), vec![4, 5, 6]);
    let mut ch_msg = Vec::new();
    qc.write_handshake(&mut ch_msg);
    qs.read_handshake(Level::Initial, &ch_msg).unwrap();
    let mut sh = Vec::new();
    qs.write_handshake(&mut sh);
    let mut hs = Vec::new();
    qs.write_handshake(&mut hs);
    Corpus {
        scfg,
        ccfg,
        to_server: vec![ch, ch_plus],
        to_client: vec![flight],
        ch_msg,
        server_hs_flight: hs,
        key_der: ss.key_der.clone(),
        cert_der: ss.cert_der,
    }
}

/// Feeds `data` in random-sized pieces and processes after each; checks that errors stick.
fn feed(rng: &mut Rng, conn: &mut simoom_tls::Connection, data: &[u8]) {
    let mut off = 0;
    while off < data.len() {
        let k = 1 + rng.below(data.len() - off);
        let taken = conn.read_tls(&data[off..off + k]);
        off += taken;
        let r = conn.process_new_packets();
        if let Err(e) = r {
            assert_eq!(conn.process_new_packets().unwrap_err(), e, "errors must stick");
            assert!(conn.tls_output().len() < 64 * 1024, "output stays bounded");
            assert!(conn.write_plaintext(b"x").is_err(), "a failed connection refuses writes");
            return;
        }
        if taken == 0 {
            // buffer full: the application reads plaintext
            let n = conn.plaintext().len();
            if n == 0 {
                return;
            }
            conn.consume_plaintext(n);
        }
    }
}

pub fn process_new_packets(&mut self) -> Result<IoState>

Processes buffered records. After an error every call returns the same error; the alert for it (if any) is already queued in the TLS output.

Examples found in repository

examples/bench_tls.rs (line 48)

fn pump(c: &mut Connection, s: &mut Connection) {
    loop {
        let mut moved = false;
        if c.wants_write() {
            let n = s.read_tls(c.tls_output());
            c.consume_tls_output(n);
            s.process_new_packets().unwrap();
            moved = true;
        }
        if s.wants_write() {
            let n = c.read_tls(s.tls_output());
            s.consume_tls_output(n);
            c.process_new_packets().unwrap();
            moved = true;
        }
        if !moved {
            return;
        }
    }
}

fn main() {
    let openssl = std::env::args().any(|a| a == "--openssl");
    let d = Duration::from_millis(if std::env::args().any(|a| a == "--quick") { 300 } else { 1500 });
    println!("simoom-tls benchmarks (single thread), hardware AES: {}, CLMUL: {}, SHA-NI: {}", simoom_sys::arch::has_aes(), simoom_sys::arch::has_clmul(), simoom_sys::arch::has_sha256());
    println!();
    println!("{:<34} {:>12} {:>12}", "AEAD seal (encrypt + tag)", "16384 B", "1400 B");
    let aad = [0u8; 13];
    let mut buf = vec![0x5au8; 16384];
    let gcm128 = AesGcm::new(&[1u8; 16]);
    let gcm256 = AesGcm::new(&[1u8; 32]);
    let gcm128s = AesGcm::new_soft(&[1u8; 16]);
    let chacha = ChaCha20Poly1305::new(&[2u8; 32]);
    let mut seq = 0u64;
    let mut nonce = || {
        seq += 1;
        let mut n = [0u8; 12];
        n[4..].copy_from_slice(&seq.to_be_bytes());
        n
    };
    let f1 = |n: &[u8; 12], b: &mut [u8]| gcm128.seal(n, &aad, b);
    let f2 = |n: &[u8; 12], b: &mut [u8]| gcm256.seal(n, &aad, b);
    let f3 = |n: &[u8; 12], b: &mut [u8]| gcm128s.seal(n, &aad, b);
    let f4 = |n: &[u8; 12], b: &mut [u8]| chacha.seal(n, &aad, b);
    let algs: [(&str, &dyn Fn(&[u8; 12], &mut [u8]) -> [u8; 16]); 4] =
        [("AES-128-GCM", &f1), ("AES-256-GCM", &f2), ("AES-128-GCM (portable, bitsliced)", &f3), ("ChaCha20-Poly1305", &f4)];
    for (name, f) in algs {
        let size_d = if name.contains("portable") { d / 3 } else { d };
        let a = rate(size_d, || {
            black_box(f(&nonce(), &mut buf));
        });
        let b = rate(size_d, || {
            black_box(f(&nonce(), &mut buf[..1400]));
        });
        println!("{:<34} {:>9.2} GB/s {:>7.2} GB/s", name, gbps(a, 16384), gbps(b, 1400));
    }
    let mut tag = [0u8; 16];
    let n12 = [0u8; 12];
    tag.copy_from_slice(&gcm128.seal(&n12, &aad, &mut buf));
    let o = rate(d, || {
        // open fails (buffer changed) but does the full work: GHASH, CTR, tag compare
        black_box(gcm128.open(&n12, &aad, &mut buf, &tag));
    });
    println!("{:<34} {:>9.2} GB/s", "AES-128-GCM open", gbps(o, 16384));

    println!();
    println!("{:<34} {:>12}", "Primitive", "ops/s");
    let sk = [7u8; 32];
    let pk = x25519::x25519_base(&[9u8; 32]);
    println!("{:<34} {:>12.0}", "X25519 key generation (table)", rate(d, || {
        black_box(x25519::x25519_base(black_box(&sk)));
    }));
    println!("{:<34} {:>12.0}", "X25519 shared secret (ladder)", rate(d, || {
        black_box(x25519::x25519(black_box(&sk), &pk));
    }));
    let d256 = p256::generate_private();
    let q256 = p256::public_key(&p256::generate_private()).unwrap();
    let h = [3u8; 32];
    println!("{:<34} {:>12.0}", "P-256 key generation", rate(d, || {
        black_box(p256::public_key(black_box(&d256)));
    }));
    println!("{:<34} {:>12.0}", "P-256 ECDH", rate(d, || {
        black_box(p256::ecdh(black_box(&d256), &q256));
    }));
    let (r, s) = p256::sign(&d256, &h, simoom_tls::crypto::sha2::HashAlg::Sha256).unwrap();
    let pub256 = p256::public_key(&d256).unwrap();
    println!("{:<34} {:>12.0}", "ECDSA P-256 sign", rate(d, || {
        black_box(p256::sign(black_box(&d256), &h, simoom_tls::crypto::sha2::HashAlg::Sha256));
    }));
    println!("{:<34} {:>12.0}", "ECDSA P-256 verify", rate(d, || {
        black_box(p256::verify(&pub256, &h, &r, &s));
    }));
    let seed = [5u8; 32];
    let edpub = simoom_tls::crypto::ed25519::public_key(&seed);
    // as the server signs: the key's public half is known (OpenSSL keeps it in the key too)
    println!("{:<34} {:>12.0}", "Ed25519 sign", rate(d, || {
        black_box(simoom_tls::crypto::ed25519::sign_with_public(&seed, &edpub, b"message"));
    }));
    let edsig = simoom_tls::crypto::ed25519::sign(&seed, b"message");
    println!("{:<34} {:>12.0}", "Ed25519 verify", rate(d, || {
        black_box(simoom_tls::crypto::ed25519::verify(&edpub, b"message", &edsig));
    }));
    let rsa = PrivateKey::from_pem(include_bytes!("../testdata/rsa2048.pkcs1.pem")).unwrap();
    if let PrivateKey::Rsa(k) = &rsa {
        let dg = [1u8; 32];
        println!("{:<34} {:>12.0}", "RSA-2048 PSS sign", rate(d, || {
            black_box(k.sign_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg));
        }));
        let sig = k.sign_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg).unwrap();
        println!("{:<34} {:>12.0}", "RSA-2048 PSS verify", rate(d, || {
            black_box(k.public.verify_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg, &sig, Some(32)));
        }));
    }

    // handshakes
    let ss = certgen::issue(&CertParams::server(&["localhost"]), PrivateKey::generate_ec(EcCurve::P256), None);
    let mut roots = RootStore::empty();
    roots.add_der(&ss.cert_der).unwrap();
    let mut scfg = ServerConfig::new(CertifiedKey::new(vec![ss.cert_der.clone()], ss.key.clone()).unwrap());
    scfg.groups = vec![NamedGroup::X25519];
    let scfg = Arc::new(scfg);
    let mut cfull = ClientConfig::new(roots.clone());
    cfull.sessions = None;
    cfull.groups = vec![NamedGroup::X25519];
    let cfull = Arc::new(cfull);
    let mut cres = ClientConfig::new(roots);
    cres.groups = vec![NamedGroup::X25519];
    let cres = Arc::new(cres);

    println!();
    println!("{:<44} {:>12}", "TLS 1.3 handshake (X25519, ECDSA P-256 cert)", "per second");
    let full = rate(d, || {
        let mut c = ClientConnection::new(cfull.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        pump(&mut c, &mut s);
        assert!(!s.is_handshaking());
    });
    println!("{:<44} {:>12.0}", "full, client + server", full);
    // server side only: replay a fresh ClientHello per iteration and time the server's work
    let mut server_time = Duration::ZERO;
    let mut n = 0u32;
    let t0 = Instant::now();
    while t0.elapsed() < d {
        let mut c = ClientConnection::new(cfull.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        let ch = c.tls_output().to_vec();
        c.consume_tls_output(ch.len());
        let t = Instant::now();
        s.read_tls(&ch);
        s.process_new_packets().unwrap();
        server_time += t.elapsed();
        let flight = s.tls_output().to_vec();
        s.consume_tls_output(flight.len());
        c.read_tls(&flight);
        c.process_new_packets().unwrap();
        let fin = c.tls_output().to_vec();
        let t = Instant::now();
        s.read_tls(&fin);
        s.process_new_packets().unwrap();
        server_time += t.elapsed();
        n += 1;
    }
    println!("{:<44} {:>12.0}", "full, server side only", n as f64 / server_time.as_secs_f64());
    // resumption: prime the cache, then each connection uses one ticket and stores a new one
    let mut c = ClientConnection::new(cres.clone(), "localhost").unwrap();
    let mut s = ServerConnection::new(scfg.clone());
    pump(&mut c, &mut s);
    let resumed = rate(d, || {
        let mut c = ClientConnection::new(cres.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        pump(&mut c, &mut s);
        assert!(c.is_resumed());
    });
    println!("{:<44} {:>12.0}", "PSK-DHE resumption, client + server", resumed);

    if openssl {
        println!();
        println!("openssl speed (same machine, single thread):");
        for args in [
            &["speed", "-seconds", "2", "-bytes", "16384", "-evp", "aes-128-gcm"][..],
            &["speed", "-seconds", "2", "-bytes", "1400", "-evp", "aes-128-gcm"][..],
            &["speed", "-seconds", "2", "-bytes", "16384", "-evp", "chacha20-poly1305"][..],
            &["speed", "-seconds", "2", "-bytes", "1400", "-evp", "chacha20-poly1305"][..],
            &["speed", "-seconds", "2", "ecdhx25519", "ecdhp256", "ecdsap256", "ed25519", "rsa2048"][..],
        ] {
            match std::process::Command::new("openssl").args(args).output() {
                Ok(o) => {
                    let out = String::from_utf8_lossy(&o.stdout);
                    for line in out.lines().filter(|l| {
                        l.starts_with("AES-128-GCM") || l.starts_with("ChaCha20-Poly1305") || l.contains(" sign ") || l.contains("op/s") || l.starts_with("rsa") || l.contains("ecdh") || l.contains("ecdsa") || l.contains("Ed25519") || l.contains("type")
                    }) {
                        println!("  {line}");
                    }
                }
                Err(e) => println!("  openssl not available: {e}"),
            }
        }
    }
}

examples/size_server.rs (line 25)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 3 {
        eprintln!("usage: size_server CERT.pem KEY.pem < client_flight");
        std::process::exit(2);
    }
    let cert = std::fs::read(&args[1]).expect("certificate");
    let key = std::fs::read(&args[2]).expect("key");
    let cfg = Arc::new(ServerConfig::from_pem(&cert, &key).expect("server config").with_alpn(&[b"h2", b"http/1.1"]));
    let mut conn = ServerConnection::new(cfg);
    let mut input = Vec::new();
    std::io::stdin().read_to_end(&mut input).expect("stdin");
    conn.read_tls(&input);
    if let Err(e) = conn.process_new_packets() {
        eprintln!("{e:?}");
    }
    let out = conn.tls_output().to_vec();
    conn.consume_tls_output(out.len());
    std::io::stdout().write_all(&out).expect("stdout");
    let mut buf = [0u8; 1024];
    let n = conn.read_plaintext(&mut buf);
    std::io::stdout().write_all(&buf[..n]).expect("stdout");
}

examples/size_features.rs (line 69)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 3 {
        eprintln!("usage: size_features CERT.pem KEY.pem [PASSWORD [KEYSTORE [OCSP.der [CRL]]]] < client_flight");
        std::process::exit(2);
    }
    let cfg = Arc::new(config(&args));
    #[cfg(feature = "blocking")]
    if std::env::var("SIZE_FEATURES_LISTEN").is_ok() {
        let l = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
        let (tcp, _) = l.accept().expect("accept");
        let mut s = simoom_tls::blocking::accept(tcp, cfg).expect("handshake");
        let mut buf = [0u8; 1024];
        let n = s.read(&mut buf).expect("read");
        s.write_all(&buf[..n]).expect("write");
        return;
    }
    let mut conn = ServerConnection::new(cfg);
    let mut input = Vec::new();
    std::io::stdin().read_to_end(&mut input).expect("stdin");
    conn.read_tls(&input);
    if let Err(e) = conn.process_new_packets() {
        eprintln!("{e:?}");
    }
    let out = conn.tls_output().to_vec();
    conn.consume_tls_output(out.len());
    std::io::stdout().write_all(&out).expect("stdout");
    let mut buf = [0u8; 1024];
    let n = conn.read_plaintext(&mut buf);
    std::io::stdout().write_all(&buf[..n]).expect("stdout");
}

examples/../tests/fuzzing/mod.rs (line 136)

pub fn corpus() -> Corpus {
    let ss = certgen::issue(&CertParams::server(&["localhost"]), PrivateKey::generate_ec(EcCurve::P256), None);
    let mut roots = RootStore::empty();
    roots.add_der(&ss.cert_der).unwrap();
    let scfg = Arc::new(ServerConfig::new(CertifiedKey::new(vec![ss.cert_der.clone()], ss.key.clone()).unwrap()).with_alpn(&[b"h3", b"http/1.1"]));
    let mut cc = ClientConfig::new(roots).with_alpn(&[b"h3", b"http/1.1"]);
    cc.sessions = None;
    let ccfg = Arc::new(cc);
    // a TLS handshake transcript
    let mut c = ClientConnection::new(ccfg.clone(), "localhost").unwrap();
    let mut s = ServerConnection::new(scfg.clone());
    let ch = c.tls_output().to_vec();
    c.consume_tls_output(ch.len());
    s.read_tls(&ch);
    s.process_new_packets().unwrap();
    let flight = s.tls_output().to_vec();
    let mut ch_plus = ch.clone();
    ch_plus.extend_from_slice(&[20, 3, 3, 0, 1, 1, 23, 3, 3, 0, 20]);
    ch_plus.extend(std::iter::repeat_n(0xaa, 20));
    // a QUIC handshake: the ClientHello message and the server's Handshake-level flight
    let mut qc = QuicConnection::new_client(ccfg.clone(), "localhost", vec![1, 2, 3]).unwrap();
    let mut qs = QuicConnection::new_server(scfg.clone(), vec![4, 5, 6]);
    let mut ch_msg = Vec::new();
    qc.write_handshake(&mut ch_msg);
    qs.read_handshake(Level::Initial, &ch_msg).unwrap();
    let mut sh = Vec::new();
    qs.write_handshake(&mut sh);
    let mut hs = Vec::new();
    qs.write_handshake(&mut hs);
    Corpus {
        scfg,
        ccfg,
        to_server: vec![ch, ch_plus],
        to_client: vec![flight],
        ch_msg,
        server_hs_flight: hs,
        key_der: ss.key_der.clone(),
        cert_der: ss.cert_der,
    }
}

/// Feeds `data` in random-sized pieces and processes after each; checks that errors stick.
fn feed(rng: &mut Rng, conn: &mut simoom_tls::Connection, data: &[u8]) {
    let mut off = 0;
    while off < data.len() {
        let k = 1 + rng.below(data.len() - off);
        let taken = conn.read_tls(&data[off..off + k]);
        off += taken;
        let r = conn.process_new_packets();
        if let Err(e) = r {
            assert_eq!(conn.process_new_packets().unwrap_err(), e, "errors must stick");
            assert!(conn.tls_output().len() < 64 * 1024, "output stays bounded");
            assert!(conn.write_plaintext(b"x").is_err(), "a failed connection refuses writes");
            return;
        }
        if taken == 0 {
            // buffer full: the application reads plaintext
            let n = conn.plaintext().len();
            if n == 0 {
                return;
            }
            conn.consume_plaintext(n);
        }
    }
}

pub fn wants_write(&self) -> bool

True if TLS bytes are waiting to be sent.

Examples found in repository

examples/bench_tls.rs (line 45)

fn pump(c: &mut Connection, s: &mut Connection) {
    loop {
        let mut moved = false;
        if c.wants_write() {
            let n = s.read_tls(c.tls_output());
            c.consume_tls_output(n);
            s.process_new_packets().unwrap();
            moved = true;
        }
        if s.wants_write() {
            let n = c.read_tls(s.tls_output());
            s.consume_tls_output(n);
            c.process_new_packets().unwrap();
            moved = true;
        }
        if !moved {
            return;
        }
    }
}

pub fn tls_output(&self) -> &[u8]

The TLS bytes waiting to be sent.

Examples found in repository

examples/bench_tls.rs (line 46)

fn pump(c: &mut Connection, s: &mut Connection) {
    loop {
        let mut moved = false;
        if c.wants_write() {
            let n = s.read_tls(c.tls_output());
            c.consume_tls_output(n);
            s.process_new_packets().unwrap();
            moved = true;
        }
        if s.wants_write() {
            let n = c.read_tls(s.tls_output());
            s.consume_tls_output(n);
            c.process_new_packets().unwrap();
            moved = true;
        }
        if !moved {
            return;
        }
    }
}

fn main() {
    let openssl = std::env::args().any(|a| a == "--openssl");
    let d = Duration::from_millis(if std::env::args().any(|a| a == "--quick") { 300 } else { 1500 });
    println!("simoom-tls benchmarks (single thread), hardware AES: {}, CLMUL: {}, SHA-NI: {}", simoom_sys::arch::has_aes(), simoom_sys::arch::has_clmul(), simoom_sys::arch::has_sha256());
    println!();
    println!("{:<34} {:>12} {:>12}", "AEAD seal (encrypt + tag)", "16384 B", "1400 B");
    let aad = [0u8; 13];
    let mut buf = vec![0x5au8; 16384];
    let gcm128 = AesGcm::new(&[1u8; 16]);
    let gcm256 = AesGcm::new(&[1u8; 32]);
    let gcm128s = AesGcm::new_soft(&[1u8; 16]);
    let chacha = ChaCha20Poly1305::new(&[2u8; 32]);
    let mut seq = 0u64;
    let mut nonce = || {
        seq += 1;
        let mut n = [0u8; 12];
        n[4..].copy_from_slice(&seq.to_be_bytes());
        n
    };
    let f1 = |n: &[u8; 12], b: &mut [u8]| gcm128.seal(n, &aad, b);
    let f2 = |n: &[u8; 12], b: &mut [u8]| gcm256.seal(n, &aad, b);
    let f3 = |n: &[u8; 12], b: &mut [u8]| gcm128s.seal(n, &aad, b);
    let f4 = |n: &[u8; 12], b: &mut [u8]| chacha.seal(n, &aad, b);
    let algs: [(&str, &dyn Fn(&[u8; 12], &mut [u8]) -> [u8; 16]); 4] =
        [("AES-128-GCM", &f1), ("AES-256-GCM", &f2), ("AES-128-GCM (portable, bitsliced)", &f3), ("ChaCha20-Poly1305", &f4)];
    for (name, f) in algs {
        let size_d = if name.contains("portable") { d / 3 } else { d };
        let a = rate(size_d, || {
            black_box(f(&nonce(), &mut buf));
        });
        let b = rate(size_d, || {
            black_box(f(&nonce(), &mut buf[..1400]));
        });
        println!("{:<34} {:>9.2} GB/s {:>7.2} GB/s", name, gbps(a, 16384), gbps(b, 1400));
    }
    let mut tag = [0u8; 16];
    let n12 = [0u8; 12];
    tag.copy_from_slice(&gcm128.seal(&n12, &aad, &mut buf));
    let o = rate(d, || {
        // open fails (buffer changed) but does the full work: GHASH, CTR, tag compare
        black_box(gcm128.open(&n12, &aad, &mut buf, &tag));
    });
    println!("{:<34} {:>9.2} GB/s", "AES-128-GCM open", gbps(o, 16384));

    println!();
    println!("{:<34} {:>12}", "Primitive", "ops/s");
    let sk = [7u8; 32];
    let pk = x25519::x25519_base(&[9u8; 32]);
    println!("{:<34} {:>12.0}", "X25519 key generation (table)", rate(d, || {
        black_box(x25519::x25519_base(black_box(&sk)));
    }));
    println!("{:<34} {:>12.0}", "X25519 shared secret (ladder)", rate(d, || {
        black_box(x25519::x25519(black_box(&sk), &pk));
    }));
    let d256 = p256::generate_private();
    let q256 = p256::public_key(&p256::generate_private()).unwrap();
    let h = [3u8; 32];
    println!("{:<34} {:>12.0}", "P-256 key generation", rate(d, || {
        black_box(p256::public_key(black_box(&d256)));
    }));
    println!("{:<34} {:>12.0}", "P-256 ECDH", rate(d, || {
        black_box(p256::ecdh(black_box(&d256), &q256));
    }));
    let (r, s) = p256::sign(&d256, &h, simoom_tls::crypto::sha2::HashAlg::Sha256).unwrap();
    let pub256 = p256::public_key(&d256).unwrap();
    println!("{:<34} {:>12.0}", "ECDSA P-256 sign", rate(d, || {
        black_box(p256::sign(black_box(&d256), &h, simoom_tls::crypto::sha2::HashAlg::Sha256));
    }));
    println!("{:<34} {:>12.0}", "ECDSA P-256 verify", rate(d, || {
        black_box(p256::verify(&pub256, &h, &r, &s));
    }));
    let seed = [5u8; 32];
    let edpub = simoom_tls::crypto::ed25519::public_key(&seed);
    // as the server signs: the key's public half is known (OpenSSL keeps it in the key too)
    println!("{:<34} {:>12.0}", "Ed25519 sign", rate(d, || {
        black_box(simoom_tls::crypto::ed25519::sign_with_public(&seed, &edpub, b"message"));
    }));
    let edsig = simoom_tls::crypto::ed25519::sign(&seed, b"message");
    println!("{:<34} {:>12.0}", "Ed25519 verify", rate(d, || {
        black_box(simoom_tls::crypto::ed25519::verify(&edpub, b"message", &edsig));
    }));
    let rsa = PrivateKey::from_pem(include_bytes!("../testdata/rsa2048.pkcs1.pem")).unwrap();
    if let PrivateKey::Rsa(k) = &rsa {
        let dg = [1u8; 32];
        println!("{:<34} {:>12.0}", "RSA-2048 PSS sign", rate(d, || {
            black_box(k.sign_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg));
        }));
        let sig = k.sign_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg).unwrap();
        println!("{:<34} {:>12.0}", "RSA-2048 PSS verify", rate(d, || {
            black_box(k.public.verify_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg, &sig, Some(32)));
        }));
    }

    // handshakes
    let ss = certgen::issue(&CertParams::server(&["localhost"]), PrivateKey::generate_ec(EcCurve::P256), None);
    let mut roots = RootStore::empty();
    roots.add_der(&ss.cert_der).unwrap();
    let mut scfg = ServerConfig::new(CertifiedKey::new(vec![ss.cert_der.clone()], ss.key.clone()).unwrap());
    scfg.groups = vec![NamedGroup::X25519];
    let scfg = Arc::new(scfg);
    let mut cfull = ClientConfig::new(roots.clone());
    cfull.sessions = None;
    cfull.groups = vec![NamedGroup::X25519];
    let cfull = Arc::new(cfull);
    let mut cres = ClientConfig::new(roots);
    cres.groups = vec![NamedGroup::X25519];
    let cres = Arc::new(cres);

    println!();
    println!("{:<44} {:>12}", "TLS 1.3 handshake (X25519, ECDSA P-256 cert)", "per second");
    let full = rate(d, || {
        let mut c = ClientConnection::new(cfull.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        pump(&mut c, &mut s);
        assert!(!s.is_handshaking());
    });
    println!("{:<44} {:>12.0}", "full, client + server", full);
    // server side only: replay a fresh ClientHello per iteration and time the server's work
    let mut server_time = Duration::ZERO;
    let mut n = 0u32;
    let t0 = Instant::now();
    while t0.elapsed() < d {
        let mut c = ClientConnection::new(cfull.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        let ch = c.tls_output().to_vec();
        c.consume_tls_output(ch.len());
        let t = Instant::now();
        s.read_tls(&ch);
        s.process_new_packets().unwrap();
        server_time += t.elapsed();
        let flight = s.tls_output().to_vec();
        s.consume_tls_output(flight.len());
        c.read_tls(&flight);
        c.process_new_packets().unwrap();
        let fin = c.tls_output().to_vec();
        let t = Instant::now();
        s.read_tls(&fin);
        s.process_new_packets().unwrap();
        server_time += t.elapsed();
        n += 1;
    }
    println!("{:<44} {:>12.0}", "full, server side only", n as f64 / server_time.as_secs_f64());
    // resumption: prime the cache, then each connection uses one ticket and stores a new one
    let mut c = ClientConnection::new(cres.clone(), "localhost").unwrap();
    let mut s = ServerConnection::new(scfg.clone());
    pump(&mut c, &mut s);
    let resumed = rate(d, || {
        let mut c = ClientConnection::new(cres.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        pump(&mut c, &mut s);
        assert!(c.is_resumed());
    });
    println!("{:<44} {:>12.0}", "PSK-DHE resumption, client + server", resumed);

    if openssl {
        println!();
        println!("openssl speed (same machine, single thread):");
        for args in [
            &["speed", "-seconds", "2", "-bytes", "16384", "-evp", "aes-128-gcm"][..],
            &["speed", "-seconds", "2", "-bytes", "1400", "-evp", "aes-128-gcm"][..],
            &["speed", "-seconds", "2", "-bytes", "16384", "-evp", "chacha20-poly1305"][..],
            &["speed", "-seconds", "2", "-bytes", "1400", "-evp", "chacha20-poly1305"][..],
            &["speed", "-seconds", "2", "ecdhx25519", "ecdhp256", "ecdsap256", "ed25519", "rsa2048"][..],
        ] {
            match std::process::Command::new("openssl").args(args).output() {
                Ok(o) => {
                    let out = String::from_utf8_lossy(&o.stdout);
                    for line in out.lines().filter(|l| {
                        l.starts_with("AES-128-GCM") || l.starts_with("ChaCha20-Poly1305") || l.contains(" sign ") || l.contains("op/s") || l.starts_with("rsa") || l.contains("ecdh") || l.contains("ecdsa") || l.contains("Ed25519") || l.contains("type")
                    }) {
                        println!("  {line}");
                    }
                }
                Err(e) => println!("  openssl not available: {e}"),
            }
        }
    }
}

examples/size_server.rs (line 28)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 3 {
        eprintln!("usage: size_server CERT.pem KEY.pem < client_flight");
        std::process::exit(2);
    }
    let cert = std::fs::read(&args[1]).expect("certificate");
    let key = std::fs::read(&args[2]).expect("key");
    let cfg = Arc::new(ServerConfig::from_pem(&cert, &key).expect("server config").with_alpn(&[b"h2", b"http/1.1"]));
    let mut conn = ServerConnection::new(cfg);
    let mut input = Vec::new();
    std::io::stdin().read_to_end(&mut input).expect("stdin");
    conn.read_tls(&input);
    if let Err(e) = conn.process_new_packets() {
        eprintln!("{e:?}");
    }
    let out = conn.tls_output().to_vec();
    conn.consume_tls_output(out.len());
    std::io::stdout().write_all(&out).expect("stdout");
    let mut buf = [0u8; 1024];
    let n = conn.read_plaintext(&mut buf);
    std::io::stdout().write_all(&buf[..n]).expect("stdout");
}

examples/size_features.rs (line 72)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 3 {
        eprintln!("usage: size_features CERT.pem KEY.pem [PASSWORD [KEYSTORE [OCSP.der [CRL]]]] < client_flight");
        std::process::exit(2);
    }
    let cfg = Arc::new(config(&args));
    #[cfg(feature = "blocking")]
    if std::env::var("SIZE_FEATURES_LISTEN").is_ok() {
        let l = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
        let (tcp, _) = l.accept().expect("accept");
        let mut s = simoom_tls::blocking::accept(tcp, cfg).expect("handshake");
        let mut buf = [0u8; 1024];
        let n = s.read(&mut buf).expect("read");
        s.write_all(&buf[..n]).expect("write");
        return;
    }
    let mut conn = ServerConnection::new(cfg);
    let mut input = Vec::new();
    std::io::stdin().read_to_end(&mut input).expect("stdin");
    conn.read_tls(&input);
    if let Err(e) = conn.process_new_packets() {
        eprintln!("{e:?}");
    }
    let out = conn.tls_output().to_vec();
    conn.consume_tls_output(out.len());
    std::io::stdout().write_all(&out).expect("stdout");
    let mut buf = [0u8; 1024];
    let n = conn.read_plaintext(&mut buf);
    std::io::stdout().write_all(&buf[..n]).expect("stdout");
}

examples/../tests/fuzzing/mod.rs (line 133)

pub fn corpus() -> Corpus {
    let ss = certgen::issue(&CertParams::server(&["localhost"]), PrivateKey::generate_ec(EcCurve::P256), None);
    let mut roots = RootStore::empty();
    roots.add_der(&ss.cert_der).unwrap();
    let scfg = Arc::new(ServerConfig::new(CertifiedKey::new(vec![ss.cert_der.clone()], ss.key.clone()).unwrap()).with_alpn(&[b"h3", b"http/1.1"]));
    let mut cc = ClientConfig::new(roots).with_alpn(&[b"h3", b"http/1.1"]);
    cc.sessions = None;
    let ccfg = Arc::new(cc);
    // a TLS handshake transcript
    let mut c = ClientConnection::new(ccfg.clone(), "localhost").unwrap();
    let mut s = ServerConnection::new(scfg.clone());
    let ch = c.tls_output().to_vec();
    c.consume_tls_output(ch.len());
    s.read_tls(&ch);
    s.process_new_packets().unwrap();
    let flight = s.tls_output().to_vec();
    let mut ch_plus = ch.clone();
    ch_plus.extend_from_slice(&[20, 3, 3, 0, 1, 1, 23, 3, 3, 0, 20]);
    ch_plus.extend(std::iter::repeat_n(0xaa, 20));
    // a QUIC handshake: the ClientHello message and the server's Handshake-level flight
    let mut qc = QuicConnection::new_client(ccfg.clone(), "localhost", vec![1, 2, 3]).unwrap();
    let mut qs = QuicConnection::new_server(scfg.clone(), vec![4, 5, 6]);
    let mut ch_msg = Vec::new();
    qc.write_handshake(&mut ch_msg);
    qs.read_handshake(Level::Initial, &ch_msg).unwrap();
    let mut sh = Vec::new();
    qs.write_handshake(&mut sh);
    let mut hs = Vec::new();
    qs.write_handshake(&mut hs);
    Corpus {
        scfg,
        ccfg,
        to_server: vec![ch, ch_plus],
        to_client: vec![flight],
        ch_msg,
        server_hs_flight: hs,
        key_der: ss.key_der.clone(),
        cert_der: ss.cert_der,
    }
}

/// Feeds `data` in random-sized pieces and processes after each; checks that errors stick.
fn feed(rng: &mut Rng, conn: &mut simoom_tls::Connection, data: &[u8]) {
    let mut off = 0;
    while off < data.len() {
        let k = 1 + rng.below(data.len() - off);
        let taken = conn.read_tls(&data[off..off + k]);
        off += taken;
        let r = conn.process_new_packets();
        if let Err(e) = r {
            assert_eq!(conn.process_new_packets().unwrap_err(), e, "errors must stick");
            assert!(conn.tls_output().len() < 64 * 1024, "output stays bounded");
            assert!(conn.write_plaintext(b"x").is_err(), "a failed connection refuses writes");
            return;
        }
        if taken == 0 {
            // buffer full: the application reads plaintext
            let n = conn.plaintext().len();
            if n == 0 {
                return;
            }
            conn.consume_plaintext(n);
        }
    }
}

pub fn server_records(rng: &mut Rng, c: &Corpus, iters: usize) {
    for _ in 0..iters {
        let seed = &c.to_server[rng.below(c.to_server.len())];
        let data = mutate(rng, seed, &c.to_client);
        let mut s = ServerConnection::new(c.scfg.clone());
        feed(rng, &mut s, &data);
    }
}

pub fn client_records(rng: &mut Rng, c: &Corpus, iters: usize) {
    for _ in 0..iters {
        let data = mutate(rng, &c.to_client[0], &c.to_server);
        let mut cl = ClientConnection::new(c.ccfg.clone(), "localhost").unwrap();
        let n = cl.tls_output().len();
        cl.consume_tls_output(n);
        feed(rng, &mut cl, &data);
    }
}

pub fn consume_tls_output(&mut self, n: usize)

Marks n bytes of tls_output as sent.

Examples found in repository

examples/bench_tls.rs (line 47)

fn pump(c: &mut Connection, s: &mut Connection) {
    loop {
        let mut moved = false;
        if c.wants_write() {
            let n = s.read_tls(c.tls_output());
            c.consume_tls_output(n);
            s.process_new_packets().unwrap();
            moved = true;
        }
        if s.wants_write() {
            let n = c.read_tls(s.tls_output());
            s.consume_tls_output(n);
            c.process_new_packets().unwrap();
            moved = true;
        }
        if !moved {
            return;
        }
    }
}

fn main() {
    let openssl = std::env::args().any(|a| a == "--openssl");
    let d = Duration::from_millis(if std::env::args().any(|a| a == "--quick") { 300 } else { 1500 });
    println!("simoom-tls benchmarks (single thread), hardware AES: {}, CLMUL: {}, SHA-NI: {}", simoom_sys::arch::has_aes(), simoom_sys::arch::has_clmul(), simoom_sys::arch::has_sha256());
    println!();
    println!("{:<34} {:>12} {:>12}", "AEAD seal (encrypt + tag)", "16384 B", "1400 B");
    let aad = [0u8; 13];
    let mut buf = vec![0x5au8; 16384];
    let gcm128 = AesGcm::new(&[1u8; 16]);
    let gcm256 = AesGcm::new(&[1u8; 32]);
    let gcm128s = AesGcm::new_soft(&[1u8; 16]);
    let chacha = ChaCha20Poly1305::new(&[2u8; 32]);
    let mut seq = 0u64;
    let mut nonce = || {
        seq += 1;
        let mut n = [0u8; 12];
        n[4..].copy_from_slice(&seq.to_be_bytes());
        n
    };
    let f1 = |n: &[u8; 12], b: &mut [u8]| gcm128.seal(n, &aad, b);
    let f2 = |n: &[u8; 12], b: &mut [u8]| gcm256.seal(n, &aad, b);
    let f3 = |n: &[u8; 12], b: &mut [u8]| gcm128s.seal(n, &aad, b);
    let f4 = |n: &[u8; 12], b: &mut [u8]| chacha.seal(n, &aad, b);
    let algs: [(&str, &dyn Fn(&[u8; 12], &mut [u8]) -> [u8; 16]); 4] =
        [("AES-128-GCM", &f1), ("AES-256-GCM", &f2), ("AES-128-GCM (portable, bitsliced)", &f3), ("ChaCha20-Poly1305", &f4)];
    for (name, f) in algs {
        let size_d = if name.contains("portable") { d / 3 } else { d };
        let a = rate(size_d, || {
            black_box(f(&nonce(), &mut buf));
        });
        let b = rate(size_d, || {
            black_box(f(&nonce(), &mut buf[..1400]));
        });
        println!("{:<34} {:>9.2} GB/s {:>7.2} GB/s", name, gbps(a, 16384), gbps(b, 1400));
    }
    let mut tag = [0u8; 16];
    let n12 = [0u8; 12];
    tag.copy_from_slice(&gcm128.seal(&n12, &aad, &mut buf));
    let o = rate(d, || {
        // open fails (buffer changed) but does the full work: GHASH, CTR, tag compare
        black_box(gcm128.open(&n12, &aad, &mut buf, &tag));
    });
    println!("{:<34} {:>9.2} GB/s", "AES-128-GCM open", gbps(o, 16384));

    println!();
    println!("{:<34} {:>12}", "Primitive", "ops/s");
    let sk = [7u8; 32];
    let pk = x25519::x25519_base(&[9u8; 32]);
    println!("{:<34} {:>12.0}", "X25519 key generation (table)", rate(d, || {
        black_box(x25519::x25519_base(black_box(&sk)));
    }));
    println!("{:<34} {:>12.0}", "X25519 shared secret (ladder)", rate(d, || {
        black_box(x25519::x25519(black_box(&sk), &pk));
    }));
    let d256 = p256::generate_private();
    let q256 = p256::public_key(&p256::generate_private()).unwrap();
    let h = [3u8; 32];
    println!("{:<34} {:>12.0}", "P-256 key generation", rate(d, || {
        black_box(p256::public_key(black_box(&d256)));
    }));
    println!("{:<34} {:>12.0}", "P-256 ECDH", rate(d, || {
        black_box(p256::ecdh(black_box(&d256), &q256));
    }));
    let (r, s) = p256::sign(&d256, &h, simoom_tls::crypto::sha2::HashAlg::Sha256).unwrap();
    let pub256 = p256::public_key(&d256).unwrap();
    println!("{:<34} {:>12.0}", "ECDSA P-256 sign", rate(d, || {
        black_box(p256::sign(black_box(&d256), &h, simoom_tls::crypto::sha2::HashAlg::Sha256));
    }));
    println!("{:<34} {:>12.0}", "ECDSA P-256 verify", rate(d, || {
        black_box(p256::verify(&pub256, &h, &r, &s));
    }));
    let seed = [5u8; 32];
    let edpub = simoom_tls::crypto::ed25519::public_key(&seed);
    // as the server signs: the key's public half is known (OpenSSL keeps it in the key too)
    println!("{:<34} {:>12.0}", "Ed25519 sign", rate(d, || {
        black_box(simoom_tls::crypto::ed25519::sign_with_public(&seed, &edpub, b"message"));
    }));
    let edsig = simoom_tls::crypto::ed25519::sign(&seed, b"message");
    println!("{:<34} {:>12.0}", "Ed25519 verify", rate(d, || {
        black_box(simoom_tls::crypto::ed25519::verify(&edpub, b"message", &edsig));
    }));
    let rsa = PrivateKey::from_pem(include_bytes!("../testdata/rsa2048.pkcs1.pem")).unwrap();
    if let PrivateKey::Rsa(k) = &rsa {
        let dg = [1u8; 32];
        println!("{:<34} {:>12.0}", "RSA-2048 PSS sign", rate(d, || {
            black_box(k.sign_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg));
        }));
        let sig = k.sign_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg).unwrap();
        println!("{:<34} {:>12.0}", "RSA-2048 PSS verify", rate(d, || {
            black_box(k.public.verify_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg, &sig, Some(32)));
        }));
    }

    // handshakes
    let ss = certgen::issue(&CertParams::server(&["localhost"]), PrivateKey::generate_ec(EcCurve::P256), None);
    let mut roots = RootStore::empty();
    roots.add_der(&ss.cert_der).unwrap();
    let mut scfg = ServerConfig::new(CertifiedKey::new(vec![ss.cert_der.clone()], ss.key.clone()).unwrap());
    scfg.groups = vec![NamedGroup::X25519];
    let scfg = Arc::new(scfg);
    let mut cfull = ClientConfig::new(roots.clone());
    cfull.sessions = None;
    cfull.groups = vec![NamedGroup::X25519];
    let cfull = Arc::new(cfull);
    let mut cres = ClientConfig::new(roots);
    cres.groups = vec![NamedGroup::X25519];
    let cres = Arc::new(cres);

    println!();
    println!("{:<44} {:>12}", "TLS 1.3 handshake (X25519, ECDSA P-256 cert)", "per second");
    let full = rate(d, || {
        let mut c = ClientConnection::new(cfull.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        pump(&mut c, &mut s);
        assert!(!s.is_handshaking());
    });
    println!("{:<44} {:>12.0}", "full, client + server", full);
    // server side only: replay a fresh ClientHello per iteration and time the server's work
    let mut server_time = Duration::ZERO;
    let mut n = 0u32;
    let t0 = Instant::now();
    while t0.elapsed() < d {
        let mut c = ClientConnection::new(cfull.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        let ch = c.tls_output().to_vec();
        c.consume_tls_output(ch.len());
        let t = Instant::now();
        s.read_tls(&ch);
        s.process_new_packets().unwrap();
        server_time += t.elapsed();
        let flight = s.tls_output().to_vec();
        s.consume_tls_output(flight.len());
        c.read_tls(&flight);
        c.process_new_packets().unwrap();
        let fin = c.tls_output().to_vec();
        let t = Instant::now();
        s.read_tls(&fin);
        s.process_new_packets().unwrap();
        server_time += t.elapsed();
        n += 1;
    }
    println!("{:<44} {:>12.0}", "full, server side only", n as f64 / server_time.as_secs_f64());
    // resumption: prime the cache, then each connection uses one ticket and stores a new one
    let mut c = ClientConnection::new(cres.clone(), "localhost").unwrap();
    let mut s = ServerConnection::new(scfg.clone());
    pump(&mut c, &mut s);
    let resumed = rate(d, || {
        let mut c = ClientConnection::new(cres.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        pump(&mut c, &mut s);
        assert!(c.is_resumed());
    });
    println!("{:<44} {:>12.0}", "PSK-DHE resumption, client + server", resumed);

    if openssl {
        println!();
        println!("openssl speed (same machine, single thread):");
        for args in [
            &["speed", "-seconds", "2", "-bytes", "16384", "-evp", "aes-128-gcm"][..],
            &["speed", "-seconds", "2", "-bytes", "1400", "-evp", "aes-128-gcm"][..],
            &["speed", "-seconds", "2", "-bytes", "16384", "-evp", "chacha20-poly1305"][..],
            &["speed", "-seconds", "2", "-bytes", "1400", "-evp", "chacha20-poly1305"][..],
            &["speed", "-seconds", "2", "ecdhx25519", "ecdhp256", "ecdsap256", "ed25519", "rsa2048"][..],
        ] {
            match std::process::Command::new("openssl").args(args).output() {
                Ok(o) => {
                    let out = String::from_utf8_lossy(&o.stdout);
                    for line in out.lines().filter(|l| {
                        l.starts_with("AES-128-GCM") || l.starts_with("ChaCha20-Poly1305") || l.contains(" sign ") || l.contains("op/s") || l.starts_with("rsa") || l.contains("ecdh") || l.contains("ecdsa") || l.contains("Ed25519") || l.contains("type")
                    }) {
                        println!("  {line}");
                    }
                }
                Err(e) => println!("  openssl not available: {e}"),
            }
        }
    }
}

examples/size_server.rs (line 29)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 3 {
        eprintln!("usage: size_server CERT.pem KEY.pem < client_flight");
        std::process::exit(2);
    }
    let cert = std::fs::read(&args[1]).expect("certificate");
    let key = std::fs::read(&args[2]).expect("key");
    let cfg = Arc::new(ServerConfig::from_pem(&cert, &key).expect("server config").with_alpn(&[b"h2", b"http/1.1"]));
    let mut conn = ServerConnection::new(cfg);
    let mut input = Vec::new();
    std::io::stdin().read_to_end(&mut input).expect("stdin");
    conn.read_tls(&input);
    if let Err(e) = conn.process_new_packets() {
        eprintln!("{e:?}");
    }
    let out = conn.tls_output().to_vec();
    conn.consume_tls_output(out.len());
    std::io::stdout().write_all(&out).expect("stdout");
    let mut buf = [0u8; 1024];
    let n = conn.read_plaintext(&mut buf);
    std::io::stdout().write_all(&buf[..n]).expect("stdout");
}

examples/size_features.rs (line 73)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 3 {
        eprintln!("usage: size_features CERT.pem KEY.pem [PASSWORD [KEYSTORE [OCSP.der [CRL]]]] < client_flight");
        std::process::exit(2);
    }
    let cfg = Arc::new(config(&args));
    #[cfg(feature = "blocking")]
    if std::env::var("SIZE_FEATURES_LISTEN").is_ok() {
        let l = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
        let (tcp, _) = l.accept().expect("accept");
        let mut s = simoom_tls::blocking::accept(tcp, cfg).expect("handshake");
        let mut buf = [0u8; 1024];
        let n = s.read(&mut buf).expect("read");
        s.write_all(&buf[..n]).expect("write");
        return;
    }
    let mut conn = ServerConnection::new(cfg);
    let mut input = Vec::new();
    std::io::stdin().read_to_end(&mut input).expect("stdin");
    conn.read_tls(&input);
    if let Err(e) = conn.process_new_packets() {
        eprintln!("{e:?}");
    }
    let out = conn.tls_output().to_vec();
    conn.consume_tls_output(out.len());
    std::io::stdout().write_all(&out).expect("stdout");
    let mut buf = [0u8; 1024];
    let n = conn.read_plaintext(&mut buf);
    std::io::stdout().write_all(&buf[..n]).expect("stdout");
}

examples/../tests/fuzzing/mod.rs (line 134)

pub fn corpus() -> Corpus {
    let ss = certgen::issue(&CertParams::server(&["localhost"]), PrivateKey::generate_ec(EcCurve::P256), None);
    let mut roots = RootStore::empty();
    roots.add_der(&ss.cert_der).unwrap();
    let scfg = Arc::new(ServerConfig::new(CertifiedKey::new(vec![ss.cert_der.clone()], ss.key.clone()).unwrap()).with_alpn(&[b"h3", b"http/1.1"]));
    let mut cc = ClientConfig::new(roots).with_alpn(&[b"h3", b"http/1.1"]);
    cc.sessions = None;
    let ccfg = Arc::new(cc);
    // a TLS handshake transcript
    let mut c = ClientConnection::new(ccfg.clone(), "localhost").unwrap();
    let mut s = ServerConnection::new(scfg.clone());
    let ch = c.tls_output().to_vec();
    c.consume_tls_output(ch.len());
    s.read_tls(&ch);
    s.process_new_packets().unwrap();
    let flight = s.tls_output().to_vec();
    let mut ch_plus = ch.clone();
    ch_plus.extend_from_slice(&[20, 3, 3, 0, 1, 1, 23, 3, 3, 0, 20]);
    ch_plus.extend(std::iter::repeat_n(0xaa, 20));
    // a QUIC handshake: the ClientHello message and the server's Handshake-level flight
    let mut qc = QuicConnection::new_client(ccfg.clone(), "localhost", vec![1, 2, 3]).unwrap();
    let mut qs = QuicConnection::new_server(scfg.clone(), vec![4, 5, 6]);
    let mut ch_msg = Vec::new();
    qc.write_handshake(&mut ch_msg);
    qs.read_handshake(Level::Initial, &ch_msg).unwrap();
    let mut sh = Vec::new();
    qs.write_handshake(&mut sh);
    let mut hs = Vec::new();
    qs.write_handshake(&mut hs);
    Corpus {
        scfg,
        ccfg,
        to_server: vec![ch, ch_plus],
        to_client: vec![flight],
        ch_msg,
        server_hs_flight: hs,
        key_der: ss.key_der.clone(),
        cert_der: ss.cert_der,
    }
}

/// Feeds `data` in random-sized pieces and processes after each; checks that errors stick.
fn feed(rng: &mut Rng, conn: &mut simoom_tls::Connection, data: &[u8]) {
    let mut off = 0;
    while off < data.len() {
        let k = 1 + rng.below(data.len() - off);
        let taken = conn.read_tls(&data[off..off + k]);
        off += taken;
        let r = conn.process_new_packets();
        if let Err(e) = r {
            assert_eq!(conn.process_new_packets().unwrap_err(), e, "errors must stick");
            assert!(conn.tls_output().len() < 64 * 1024, "output stays bounded");
            assert!(conn.write_plaintext(b"x").is_err(), "a failed connection refuses writes");
            return;
        }
        if taken == 0 {
            // buffer full: the application reads plaintext
            let n = conn.plaintext().len();
            if n == 0 {
                return;
            }
            conn.consume_plaintext(n);
        }
    }
}

pub fn server_records(rng: &mut Rng, c: &Corpus, iters: usize) {
    for _ in 0..iters {
        let seed = &c.to_server[rng.below(c.to_server.len())];
        let data = mutate(rng, seed, &c.to_client);
        let mut s = ServerConnection::new(c.scfg.clone());
        feed(rng, &mut s, &data);
    }
}

pub fn client_records(rng: &mut Rng, c: &Corpus, iters: usize) {
    for _ in 0..iters {
        let data = mutate(rng, &c.to_client[0], &c.to_server);
        let mut cl = ClientConnection::new(c.ccfg.clone(), "localhost").unwrap();
        let n = cl.tls_output().len();
        cl.consume_tls_output(n);
        feed(rng, &mut cl, &data);
    }
}

pub fn write_tls_into(&mut self, out: &mut Vec<u8>) -> usize

Moves all pending TLS output to out.

pub fn write_plaintext(&mut self, data: &[u8]) -> Result<usize>

Encrypts application data. Before the handshake completes the data is buffered (up to 1 MiB) and sent right after it.

Examples found in repository

examples/../tests/fuzzing/mod.rs (line 174)

fn feed(rng: &mut Rng, conn: &mut simoom_tls::Connection, data: &[u8]) {
    let mut off = 0;
    while off < data.len() {
        let k = 1 + rng.below(data.len() - off);
        let taken = conn.read_tls(&data[off..off + k]);
        off += taken;
        let r = conn.process_new_packets();
        if let Err(e) = r {
            assert_eq!(conn.process_new_packets().unwrap_err(), e, "errors must stick");
            assert!(conn.tls_output().len() < 64 * 1024, "output stays bounded");
            assert!(conn.write_plaintext(b"x").is_err(), "a failed connection refuses writes");
            return;
        }
        if taken == 0 {
            // buffer full: the application reads plaintext
            let n = conn.plaintext().len();
            if n == 0 {
                return;
            }
            conn.consume_plaintext(n);
        }
    }
}

pub fn read_plaintext(&mut self, buf: &mut [u8]) -> usize

Copies decrypted application data into buf.

Examples found in repository

examples/size_server.rs (line 32)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 3 {
        eprintln!("usage: size_server CERT.pem KEY.pem < client_flight");
        std::process::exit(2);
    }
    let cert = std::fs::read(&args[1]).expect("certificate");
    let key = std::fs::read(&args[2]).expect("key");
    let cfg = Arc::new(ServerConfig::from_pem(&cert, &key).expect("server config").with_alpn(&[b"h2", b"http/1.1"]));
    let mut conn = ServerConnection::new(cfg);
    let mut input = Vec::new();
    std::io::stdin().read_to_end(&mut input).expect("stdin");
    conn.read_tls(&input);
    if let Err(e) = conn.process_new_packets() {
        eprintln!("{e:?}");
    }
    let out = conn.tls_output().to_vec();
    conn.consume_tls_output(out.len());
    std::io::stdout().write_all(&out).expect("stdout");
    let mut buf = [0u8; 1024];
    let n = conn.read_plaintext(&mut buf);
    std::io::stdout().write_all(&buf[..n]).expect("stdout");
}

examples/size_features.rs (line 76)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 3 {
        eprintln!("usage: size_features CERT.pem KEY.pem [PASSWORD [KEYSTORE [OCSP.der [CRL]]]] < client_flight");
        std::process::exit(2);
    }
    let cfg = Arc::new(config(&args));
    #[cfg(feature = "blocking")]
    if std::env::var("SIZE_FEATURES_LISTEN").is_ok() {
        let l = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
        let (tcp, _) = l.accept().expect("accept");
        let mut s = simoom_tls::blocking::accept(tcp, cfg).expect("handshake");
        let mut buf = [0u8; 1024];
        let n = s.read(&mut buf).expect("read");
        s.write_all(&buf[..n]).expect("write");
        return;
    }
    let mut conn = ServerConnection::new(cfg);
    let mut input = Vec::new();
    std::io::stdin().read_to_end(&mut input).expect("stdin");
    conn.read_tls(&input);
    if let Err(e) = conn.process_new_packets() {
        eprintln!("{e:?}");
    }
    let out = conn.tls_output().to_vec();
    conn.consume_tls_output(out.len());
    std::io::stdout().write_all(&out).expect("stdout");
    let mut buf = [0u8; 1024];
    let n = conn.read_plaintext(&mut buf);
    std::io::stdout().write_all(&buf[..n]).expect("stdout");
}

pub fn plaintext(&self) -> &[u8]

The decrypted application data not yet consumed.

Examples found in repository

examples/../tests/fuzzing/mod.rs (line 179)

fn feed(rng: &mut Rng, conn: &mut simoom_tls::Connection, data: &[u8]) {
    let mut off = 0;
    while off < data.len() {
        let k = 1 + rng.below(data.len() - off);
        let taken = conn.read_tls(&data[off..off + k]);
        off += taken;
        let r = conn.process_new_packets();
        if let Err(e) = r {
            assert_eq!(conn.process_new_packets().unwrap_err(), e, "errors must stick");
            assert!(conn.tls_output().len() < 64 * 1024, "output stays bounded");
            assert!(conn.write_plaintext(b"x").is_err(), "a failed connection refuses writes");
            return;
        }
        if taken == 0 {
            // buffer full: the application reads plaintext
            let n = conn.plaintext().len();
            if n == 0 {
                return;
            }
            conn.consume_plaintext(n);
        }
    }
}

pub fn consume_plaintext(&mut self, n: usize)

Examples found in repository

examples/../tests/fuzzing/mod.rs (line 183)

fn feed(rng: &mut Rng, conn: &mut simoom_tls::Connection, data: &[u8]) {
    let mut off = 0;
    while off < data.len() {
        let k = 1 + rng.below(data.len() - off);
        let taken = conn.read_tls(&data[off..off + k]);
        off += taken;
        let r = conn.process_new_packets();
        if let Err(e) = r {
            assert_eq!(conn.process_new_packets().unwrap_err(), e, "errors must stick");
            assert!(conn.tls_output().len() < 64 * 1024, "output stays bounded");
            assert!(conn.write_plaintext(b"x").is_err(), "a failed connection refuses writes");
            return;
        }
        if taken == 0 {
            // buffer full: the application reads plaintext
            let n = conn.plaintext().len();
            if n == 0 {
                return;
            }
            conn.consume_plaintext(n);
        }
    }
}

pub fn release_buffers(&mut self) -> usize

Frees the capacity of empty buffers (call on idle keep-alive connections). Returns the bytes still held by buffers with pending data.

pub fn send_close_notify(&mut self)

Queues close_notify. Further writes fail with Error::Closed.

pub fn send_key_update(&mut self, request_peer: bool) -> Result<()>

Sends a KeyUpdate and switches to the next write key; request_peer asks the peer to update its keys too.

pub fn is_handshaking(&self) -> bool

Examples found in repository

examples/bench_tls.rs (line 177)

fn main() {
    let openssl = std::env::args().any(|a| a == "--openssl");
    let d = Duration::from_millis(if std::env::args().any(|a| a == "--quick") { 300 } else { 1500 });
    println!("simoom-tls benchmarks (single thread), hardware AES: {}, CLMUL: {}, SHA-NI: {}", simoom_sys::arch::has_aes(), simoom_sys::arch::has_clmul(), simoom_sys::arch::has_sha256());
    println!();
    println!("{:<34} {:>12} {:>12}", "AEAD seal (encrypt + tag)", "16384 B", "1400 B");
    let aad = [0u8; 13];
    let mut buf = vec![0x5au8; 16384];
    let gcm128 = AesGcm::new(&[1u8; 16]);
    let gcm256 = AesGcm::new(&[1u8; 32]);
    let gcm128s = AesGcm::new_soft(&[1u8; 16]);
    let chacha = ChaCha20Poly1305::new(&[2u8; 32]);
    let mut seq = 0u64;
    let mut nonce = || {
        seq += 1;
        let mut n = [0u8; 12];
        n[4..].copy_from_slice(&seq.to_be_bytes());
        n
    };
    let f1 = |n: &[u8; 12], b: &mut [u8]| gcm128.seal(n, &aad, b);
    let f2 = |n: &[u8; 12], b: &mut [u8]| gcm256.seal(n, &aad, b);
    let f3 = |n: &[u8; 12], b: &mut [u8]| gcm128s.seal(n, &aad, b);
    let f4 = |n: &[u8; 12], b: &mut [u8]| chacha.seal(n, &aad, b);
    let algs: [(&str, &dyn Fn(&[u8; 12], &mut [u8]) -> [u8; 16]); 4] =
        [("AES-128-GCM", &f1), ("AES-256-GCM", &f2), ("AES-128-GCM (portable, bitsliced)", &f3), ("ChaCha20-Poly1305", &f4)];
    for (name, f) in algs {
        let size_d = if name.contains("portable") { d / 3 } else { d };
        let a = rate(size_d, || {
            black_box(f(&nonce(), &mut buf));
        });
        let b = rate(size_d, || {
            black_box(f(&nonce(), &mut buf[..1400]));
        });
        println!("{:<34} {:>9.2} GB/s {:>7.2} GB/s", name, gbps(a, 16384), gbps(b, 1400));
    }
    let mut tag = [0u8; 16];
    let n12 = [0u8; 12];
    tag.copy_from_slice(&gcm128.seal(&n12, &aad, &mut buf));
    let o = rate(d, || {
        // open fails (buffer changed) but does the full work: GHASH, CTR, tag compare
        black_box(gcm128.open(&n12, &aad, &mut buf, &tag));
    });
    println!("{:<34} {:>9.2} GB/s", "AES-128-GCM open", gbps(o, 16384));

    println!();
    println!("{:<34} {:>12}", "Primitive", "ops/s");
    let sk = [7u8; 32];
    let pk = x25519::x25519_base(&[9u8; 32]);
    println!("{:<34} {:>12.0}", "X25519 key generation (table)", rate(d, || {
        black_box(x25519::x25519_base(black_box(&sk)));
    }));
    println!("{:<34} {:>12.0}", "X25519 shared secret (ladder)", rate(d, || {
        black_box(x25519::x25519(black_box(&sk), &pk));
    }));
    let d256 = p256::generate_private();
    let q256 = p256::public_key(&p256::generate_private()).unwrap();
    let h = [3u8; 32];
    println!("{:<34} {:>12.0}", "P-256 key generation", rate(d, || {
        black_box(p256::public_key(black_box(&d256)));
    }));
    println!("{:<34} {:>12.0}", "P-256 ECDH", rate(d, || {
        black_box(p256::ecdh(black_box(&d256), &q256));
    }));
    let (r, s) = p256::sign(&d256, &h, simoom_tls::crypto::sha2::HashAlg::Sha256).unwrap();
    let pub256 = p256::public_key(&d256).unwrap();
    println!("{:<34} {:>12.0}", "ECDSA P-256 sign", rate(d, || {
        black_box(p256::sign(black_box(&d256), &h, simoom_tls::crypto::sha2::HashAlg::Sha256));
    }));
    println!("{:<34} {:>12.0}", "ECDSA P-256 verify", rate(d, || {
        black_box(p256::verify(&pub256, &h, &r, &s));
    }));
    let seed = [5u8; 32];
    let edpub = simoom_tls::crypto::ed25519::public_key(&seed);
    // as the server signs: the key's public half is known (OpenSSL keeps it in the key too)
    println!("{:<34} {:>12.0}", "Ed25519 sign", rate(d, || {
        black_box(simoom_tls::crypto::ed25519::sign_with_public(&seed, &edpub, b"message"));
    }));
    let edsig = simoom_tls::crypto::ed25519::sign(&seed, b"message");
    println!("{:<34} {:>12.0}", "Ed25519 verify", rate(d, || {
        black_box(simoom_tls::crypto::ed25519::verify(&edpub, b"message", &edsig));
    }));
    let rsa = PrivateKey::from_pem(include_bytes!("../testdata/rsa2048.pkcs1.pem")).unwrap();
    if let PrivateKey::Rsa(k) = &rsa {
        let dg = [1u8; 32];
        println!("{:<34} {:>12.0}", "RSA-2048 PSS sign", rate(d, || {
            black_box(k.sign_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg));
        }));
        let sig = k.sign_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg).unwrap();
        println!("{:<34} {:>12.0}", "RSA-2048 PSS verify", rate(d, || {
            black_box(k.public.verify_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg, &sig, Some(32)));
        }));
    }

    // handshakes
    let ss = certgen::issue(&CertParams::server(&["localhost"]), PrivateKey::generate_ec(EcCurve::P256), None);
    let mut roots = RootStore::empty();
    roots.add_der(&ss.cert_der).unwrap();
    let mut scfg = ServerConfig::new(CertifiedKey::new(vec![ss.cert_der.clone()], ss.key.clone()).unwrap());
    scfg.groups = vec![NamedGroup::X25519];
    let scfg = Arc::new(scfg);
    let mut cfull = ClientConfig::new(roots.clone());
    cfull.sessions = None;
    cfull.groups = vec![NamedGroup::X25519];
    let cfull = Arc::new(cfull);
    let mut cres = ClientConfig::new(roots);
    cres.groups = vec![NamedGroup::X25519];
    let cres = Arc::new(cres);

    println!();
    println!("{:<44} {:>12}", "TLS 1.3 handshake (X25519, ECDSA P-256 cert)", "per second");
    let full = rate(d, || {
        let mut c = ClientConnection::new(cfull.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        pump(&mut c, &mut s);
        assert!(!s.is_handshaking());
    });
    println!("{:<44} {:>12.0}", "full, client + server", full);
    // server side only: replay a fresh ClientHello per iteration and time the server's work
    let mut server_time = Duration::ZERO;
    let mut n = 0u32;
    let t0 = Instant::now();
    while t0.elapsed() < d {
        let mut c = ClientConnection::new(cfull.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        let ch = c.tls_output().to_vec();
        c.consume_tls_output(ch.len());
        let t = Instant::now();
        s.read_tls(&ch);
        s.process_new_packets().unwrap();
        server_time += t.elapsed();
        let flight = s.tls_output().to_vec();
        s.consume_tls_output(flight.len());
        c.read_tls(&flight);
        c.process_new_packets().unwrap();
        let fin = c.tls_output().to_vec();
        let t = Instant::now();
        s.read_tls(&fin);
        s.process_new_packets().unwrap();
        server_time += t.elapsed();
        n += 1;
    }
    println!("{:<44} {:>12.0}", "full, server side only", n as f64 / server_time.as_secs_f64());
    // resumption: prime the cache, then each connection uses one ticket and stores a new one
    let mut c = ClientConnection::new(cres.clone(), "localhost").unwrap();
    let mut s = ServerConnection::new(scfg.clone());
    pump(&mut c, &mut s);
    let resumed = rate(d, || {
        let mut c = ClientConnection::new(cres.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        pump(&mut c, &mut s);
        assert!(c.is_resumed());
    });
    println!("{:<44} {:>12.0}", "PSK-DHE resumption, client + server", resumed);

    if openssl {
        println!();
        println!("openssl speed (same machine, single thread):");
        for args in [
            &["speed", "-seconds", "2", "-bytes", "16384", "-evp", "aes-128-gcm"][..],
            &["speed", "-seconds", "2", "-bytes", "1400", "-evp", "aes-128-gcm"][..],
            &["speed", "-seconds", "2", "-bytes", "16384", "-evp", "chacha20-poly1305"][..],
            &["speed", "-seconds", "2", "-bytes", "1400", "-evp", "chacha20-poly1305"][..],
            &["speed", "-seconds", "2", "ecdhx25519", "ecdhp256", "ecdsap256", "ed25519", "rsa2048"][..],
        ] {
            match std::process::Command::new("openssl").args(args).output() {
                Ok(o) => {
                    let out = String::from_utf8_lossy(&o.stdout);
                    for line in out.lines().filter(|l| {
                        l.starts_with("AES-128-GCM") || l.starts_with("ChaCha20-Poly1305") || l.contains(" sign ") || l.contains("op/s") || l.starts_with("rsa") || l.contains("ecdh") || l.contains("ecdsa") || l.contains("Ed25519") || l.contains("type")
                    }) {
                        println!("  {line}");
                    }
                }
                Err(e) => println!("  openssl not available: {e}"),
            }
        }
    }
}

pub fn alpn_protocol(&self) -> Option<&[u8]>

pub fn negotiated_cipher_suite(&self) -> Option<CipherSuite>

The TLS 1.3 cipher suite (None for TLS 1.2: see negotiated_tls12_suite and Connection::cipher_suite_name).

pub fn cipher_suite_name(&self) -> Option<&'static str>

The IANA name of the negotiated cipher suite, for either version.

pub fn protocol_version(&self) -> Option<ProtocolVersion>

The negotiated protocol version (None during the handshake).

pub fn negotiated_group(&self) -> Option<NamedGroup>

pub fn server_name(&self) -> Option<&str>

Server: the SNI name sent by the client. Client: the name, if the server acknowledged it.

pub fn peer_certificates(&self) -> &[Vec<u8>]

The peer’s certificate chain, leaf first (restored from the ticket on resumption).

pub fn is_resumed(&self) -> bool

Examples found in repository

examples/bench_tls.rs (line 213)

fn main() {
    let openssl = std::env::args().any(|a| a == "--openssl");
    let d = Duration::from_millis(if std::env::args().any(|a| a == "--quick") { 300 } else { 1500 });
    println!("simoom-tls benchmarks (single thread), hardware AES: {}, CLMUL: {}, SHA-NI: {}", simoom_sys::arch::has_aes(), simoom_sys::arch::has_clmul(), simoom_sys::arch::has_sha256());
    println!();
    println!("{:<34} {:>12} {:>12}", "AEAD seal (encrypt + tag)", "16384 B", "1400 B");
    let aad = [0u8; 13];
    let mut buf = vec![0x5au8; 16384];
    let gcm128 = AesGcm::new(&[1u8; 16]);
    let gcm256 = AesGcm::new(&[1u8; 32]);
    let gcm128s = AesGcm::new_soft(&[1u8; 16]);
    let chacha = ChaCha20Poly1305::new(&[2u8; 32]);
    let mut seq = 0u64;
    let mut nonce = || {
        seq += 1;
        let mut n = [0u8; 12];
        n[4..].copy_from_slice(&seq.to_be_bytes());
        n
    };
    let f1 = |n: &[u8; 12], b: &mut [u8]| gcm128.seal(n, &aad, b);
    let f2 = |n: &[u8; 12], b: &mut [u8]| gcm256.seal(n, &aad, b);
    let f3 = |n: &[u8; 12], b: &mut [u8]| gcm128s.seal(n, &aad, b);
    let f4 = |n: &[u8; 12], b: &mut [u8]| chacha.seal(n, &aad, b);
    let algs: [(&str, &dyn Fn(&[u8; 12], &mut [u8]) -> [u8; 16]); 4] =
        [("AES-128-GCM", &f1), ("AES-256-GCM", &f2), ("AES-128-GCM (portable, bitsliced)", &f3), ("ChaCha20-Poly1305", &f4)];
    for (name, f) in algs {
        let size_d = if name.contains("portable") { d / 3 } else { d };
        let a = rate(size_d, || {
            black_box(f(&nonce(), &mut buf));
        });
        let b = rate(size_d, || {
            black_box(f(&nonce(), &mut buf[..1400]));
        });
        println!("{:<34} {:>9.2} GB/s {:>7.2} GB/s", name, gbps(a, 16384), gbps(b, 1400));
    }
    let mut tag = [0u8; 16];
    let n12 = [0u8; 12];
    tag.copy_from_slice(&gcm128.seal(&n12, &aad, &mut buf));
    let o = rate(d, || {
        // open fails (buffer changed) but does the full work: GHASH, CTR, tag compare
        black_box(gcm128.open(&n12, &aad, &mut buf, &tag));
    });
    println!("{:<34} {:>9.2} GB/s", "AES-128-GCM open", gbps(o, 16384));

    println!();
    println!("{:<34} {:>12}", "Primitive", "ops/s");
    let sk = [7u8; 32];
    let pk = x25519::x25519_base(&[9u8; 32]);
    println!("{:<34} {:>12.0}", "X25519 key generation (table)", rate(d, || {
        black_box(x25519::x25519_base(black_box(&sk)));
    }));
    println!("{:<34} {:>12.0}", "X25519 shared secret (ladder)", rate(d, || {
        black_box(x25519::x25519(black_box(&sk), &pk));
    }));
    let d256 = p256::generate_private();
    let q256 = p256::public_key(&p256::generate_private()).unwrap();
    let h = [3u8; 32];
    println!("{:<34} {:>12.0}", "P-256 key generation", rate(d, || {
        black_box(p256::public_key(black_box(&d256)));
    }));
    println!("{:<34} {:>12.0}", "P-256 ECDH", rate(d, || {
        black_box(p256::ecdh(black_box(&d256), &q256));
    }));
    let (r, s) = p256::sign(&d256, &h, simoom_tls::crypto::sha2::HashAlg::Sha256).unwrap();
    let pub256 = p256::public_key(&d256).unwrap();
    println!("{:<34} {:>12.0}", "ECDSA P-256 sign", rate(d, || {
        black_box(p256::sign(black_box(&d256), &h, simoom_tls::crypto::sha2::HashAlg::Sha256));
    }));
    println!("{:<34} {:>12.0}", "ECDSA P-256 verify", rate(d, || {
        black_box(p256::verify(&pub256, &h, &r, &s));
    }));
    let seed = [5u8; 32];
    let edpub = simoom_tls::crypto::ed25519::public_key(&seed);
    // as the server signs: the key's public half is known (OpenSSL keeps it in the key too)
    println!("{:<34} {:>12.0}", "Ed25519 sign", rate(d, || {
        black_box(simoom_tls::crypto::ed25519::sign_with_public(&seed, &edpub, b"message"));
    }));
    let edsig = simoom_tls::crypto::ed25519::sign(&seed, b"message");
    println!("{:<34} {:>12.0}", "Ed25519 verify", rate(d, || {
        black_box(simoom_tls::crypto::ed25519::verify(&edpub, b"message", &edsig));
    }));
    let rsa = PrivateKey::from_pem(include_bytes!("../testdata/rsa2048.pkcs1.pem")).unwrap();
    if let PrivateKey::Rsa(k) = &rsa {
        let dg = [1u8; 32];
        println!("{:<34} {:>12.0}", "RSA-2048 PSS sign", rate(d, || {
            black_box(k.sign_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg));
        }));
        let sig = k.sign_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg).unwrap();
        println!("{:<34} {:>12.0}", "RSA-2048 PSS verify", rate(d, || {
            black_box(k.public.verify_pss(simoom_tls::crypto::sha2::HashAlg::Sha256, &dg, &sig, Some(32)));
        }));
    }

    // handshakes
    let ss = certgen::issue(&CertParams::server(&["localhost"]), PrivateKey::generate_ec(EcCurve::P256), None);
    let mut roots = RootStore::empty();
    roots.add_der(&ss.cert_der).unwrap();
    let mut scfg = ServerConfig::new(CertifiedKey::new(vec![ss.cert_der.clone()], ss.key.clone()).unwrap());
    scfg.groups = vec![NamedGroup::X25519];
    let scfg = Arc::new(scfg);
    let mut cfull = ClientConfig::new(roots.clone());
    cfull.sessions = None;
    cfull.groups = vec![NamedGroup::X25519];
    let cfull = Arc::new(cfull);
    let mut cres = ClientConfig::new(roots);
    cres.groups = vec![NamedGroup::X25519];
    let cres = Arc::new(cres);

    println!();
    println!("{:<44} {:>12}", "TLS 1.3 handshake (X25519, ECDSA P-256 cert)", "per second");
    let full = rate(d, || {
        let mut c = ClientConnection::new(cfull.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        pump(&mut c, &mut s);
        assert!(!s.is_handshaking());
    });
    println!("{:<44} {:>12.0}", "full, client + server", full);
    // server side only: replay a fresh ClientHello per iteration and time the server's work
    let mut server_time = Duration::ZERO;
    let mut n = 0u32;
    let t0 = Instant::now();
    while t0.elapsed() < d {
        let mut c = ClientConnection::new(cfull.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        let ch = c.tls_output().to_vec();
        c.consume_tls_output(ch.len());
        let t = Instant::now();
        s.read_tls(&ch);
        s.process_new_packets().unwrap();
        server_time += t.elapsed();
        let flight = s.tls_output().to_vec();
        s.consume_tls_output(flight.len());
        c.read_tls(&flight);
        c.process_new_packets().unwrap();
        let fin = c.tls_output().to_vec();
        let t = Instant::now();
        s.read_tls(&fin);
        s.process_new_packets().unwrap();
        server_time += t.elapsed();
        n += 1;
    }
    println!("{:<44} {:>12.0}", "full, server side only", n as f64 / server_time.as_secs_f64());
    // resumption: prime the cache, then each connection uses one ticket and stores a new one
    let mut c = ClientConnection::new(cres.clone(), "localhost").unwrap();
    let mut s = ServerConnection::new(scfg.clone());
    pump(&mut c, &mut s);
    let resumed = rate(d, || {
        let mut c = ClientConnection::new(cres.clone(), "localhost").unwrap();
        let mut s = ServerConnection::new(scfg.clone());
        pump(&mut c, &mut s);
        assert!(c.is_resumed());
    });
    println!("{:<44} {:>12.0}", "PSK-DHE resumption, client + server", resumed);

    if openssl {
        println!();
        println!("openssl speed (same machine, single thread):");
        for args in [
            &["speed", "-seconds", "2", "-bytes", "16384", "-evp", "aes-128-gcm"][..],
            &["speed", "-seconds", "2", "-bytes", "1400", "-evp", "aes-128-gcm"][..],
            &["speed", "-seconds", "2", "-bytes", "16384", "-evp", "chacha20-poly1305"][..],
            &["speed", "-seconds", "2", "-bytes", "1400", "-evp", "chacha20-poly1305"][..],
            &["speed", "-seconds", "2", "ecdhx25519", "ecdhp256", "ecdsap256", "ed25519", "rsa2048"][..],
        ] {
            match std::process::Command::new("openssl").args(args).output() {
                Ok(o) => {
                    let out = String::from_utf8_lossy(&o.stdout);
                    for line in out.lines().filter(|l| {
                        l.starts_with("AES-128-GCM") || l.starts_with("ChaCha20-Poly1305") || l.contains(" sign ") || l.contains("op/s") || l.starts_with("rsa") || l.contains("ecdh") || l.contains("ecdsa") || l.contains("Ed25519") || l.contains("type")
                    }) {
                        println!("  {line}");
                    }
                }
                Err(e) => println!("  openssl not available: {e}"),
            }
        }
    }
}

pub fn peer_has_closed(&self) -> bool

pub fn error(&self) -> Option<&Error>

The error that ended the connection, if any.

pub fn export_keying_material( &self, label: &[u8], context: &[u8], len: usize, ) -> Result<Vec<u8>>

RFC 8446 section 7.5 keying material exporter. With TLS 1.2 this is RFC 5705, where an empty context means no context.

Trait Implementations

impl Debug for ClientConnection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for ClientConnection

Available on crate feature client only.

type Target = Connection

The resulting type after dereferencing.

fn deref(&self) -> &Connection

Dereferences the value.

impl DerefMut for ClientConnection

Available on crate feature client only.

fn deref_mut(&mut self) -> &mut Connection

Mutably dereferences the value.