tokio-boring 5.0.0

An implementation of SSL streams for Tokio backed by BoringSSL
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use boring::ssl::{BoxCustomVerifyFinish, BoxCustomVerifyFuture, SslAlert, SslRef, SslVerifyMode};
use futures::future;
use tokio::task::yield_now;

mod common;

use self::common::{connect, create_server, with_trivial_client_server_exchange};

#[tokio::test]
async fn test_async_custom_verify_callback_trivial() {
    with_trivial_client_server_exchange(|builder| {
        builder.set_async_custom_verify_callback(SslVerifyMode::PEER, |_| {
            Ok(Box::pin(async {
                Ok(Box::new(|_: &mut _| Ok(())) as BoxCustomVerifyFinish)
            }))
        });
    })
    .await;
}

#[tokio::test]
async fn test_async_custom_verify_callback_yield() {
    with_trivial_client_server_exchange(|builder| {
        builder.set_async_custom_verify_callback(SslVerifyMode::PEER, |_| {
            Ok(Box::pin(async {
                yield_now().await;

                Ok(Box::new(|_: &mut _| Ok(())) as BoxCustomVerifyFinish)
            }))
        });
    })
    .await;
}

#[tokio::test]
async fn test_async_custom_verify_callback_return_error() {
    with_async_custom_verify_callback_error(|_| Err(SslAlert::CERTIFICATE_REVOKED)).await;
}

#[tokio::test]
async fn test_async_custom_verify_callback_future_error() {
    with_async_custom_verify_callback_error(|_| {
        Ok(Box::pin(async move { Err(SslAlert::CERTIFICATE_REVOKED) }))
    })
    .await;
}

#[tokio::test]
async fn test_async_custom_verify_callback_future_yield_error() {
    with_async_custom_verify_callback_error(|_| {
        Ok(Box::pin(async move {
            yield_now().await;

            Err(SslAlert::CERTIFICATE_REVOKED)
        }))
    })
    .await;
}

#[tokio::test]
async fn test_async_custom_verify_callback_finish_error() {
    with_async_custom_verify_callback_error(|_| {
        Ok(Box::pin(async move {
            yield_now().await;

            Ok(Box::new(|_: &mut _| Err(SslAlert::CERTIFICATE_REVOKED)) as BoxCustomVerifyFinish)
        }))
    })
    .await;
}

async fn with_async_custom_verify_callback_error(
    callback: impl Fn(&mut SslRef) -> Result<BoxCustomVerifyFuture, SslAlert> + Send + Sync + 'static,
) {
    let (stream, addr) = create_server(|_| {});

    let server = async {
        let err = stream.await.unwrap_err();

        assert_eq!(
            err.to_string(),
            "TLS handshake failed [SSLV3_ALERT_CERTIFICATE_REVOKED]"
        );
    };

    let client = async {
        let _err = connect(addr, |builder| {
            builder.set_async_custom_verify_callback(SslVerifyMode::PEER, callback);
            builder.set_ca_file("tests/cert.pem")
        })
        .await
        .unwrap_err();
    };

    future::join(server, client).await;
}