ockam_identity 0.134.0

Ockam is a library for building devices that communicate securely, privately and trustfully with cloud services and other devices.
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
97
98
99
100
101
102

use core::time::Duration;

use ockam_core::{route, Result};
use ockam_identity::SecureChannelOptions;
use ockam_node::Context;
use ockam_transport_tcp::{TcpConnectionOptions, TcpListenerOptions, TcpTransport};

use crate::common::message_flow_auth::{
    create_secure_channel, create_secure_channel_listener, message_should_not_pass,
};

mod common;

// Alice: TCP connection + Secure Channel
// Bob: TCP listener + Secure Channel listener
#[ockam_macros::test]
async fn test1(ctx: &mut Context) -> Result<()> {
    let tcp_bob = TcpTransport::get_or_create(ctx)?;
    let listener = tcp_bob
        .listen("127.0.0.1:0", TcpListenerOptions::new())
        .await?;

    let tcp_alice = TcpTransport::get_or_create(ctx)?;
    let connection_to_bob = tcp_alice
        .connect(listener.socket_string(), TcpConnectionOptions::new())
        .await?;

    ctx.sleep(Duration::from_millis(50)).await; // Wait for workers to add themselves to the registry
    let connection_to_alice = tcp_bob
        .registry()
        .get_all_sender_workers()
        .last()
        .unwrap()
        .clone();

    message_should_not_pass(ctx, &connection_to_bob.clone().into()).await?;
    message_should_not_pass(ctx, connection_to_alice.address()).await?;

    let bob_listener_info = create_secure_channel_listener(ctx, listener.flow_control_id()).await?;

    let channel_to_bob = create_secure_channel(ctx, &connection_to_bob.clone().into()).await?;
    ctx.sleep(Duration::from_millis(50)).await; // Wait for workers to add themselves to the registry
    let channel_to_alice = bob_listener_info.get_channel();

    message_should_not_pass(ctx, &channel_to_bob.address).await?;
    message_should_not_pass(ctx, &channel_to_alice).await?;

    let res = channel_to_bob
        .secure_channels
        .create_secure_channel(
            ctx,
            &channel_to_bob.identifier,
            route![connection_to_bob.clone(), "listener"],
            SecureChannelOptions::new().with_timeout(Duration::from_secs(1)),
        )
        .await;
    assert!(
        res.is_ok(),
        "We can create multiple secure channels with that connection"
    );

    Ok(())
}

// Alice: TCP connection + Secure Channel listener
// Bob: TCP listener + Secure Channel
#[ockam_macros::test]
async fn test2(ctx: &mut Context) -> Result<()> {
    let tcp_bob = TcpTransport::create_new(ctx)?;
    let listener = {
        let options = TcpListenerOptions::new();
        tcp_bob.listen("127.0.0.1:0", options).await?
    };

    let tcp_alice = TcpTransport::create_new(ctx)?;
    let alice_tcp_options = TcpConnectionOptions::new();
    let alice_flow_control_id = alice_tcp_options.flow_control_id();
    let connection_to_bob = tcp_alice
        .connect(listener.socket_string(), alice_tcp_options)
        .await?;
    ctx.sleep(Duration::from_millis(50)).await; // Wait for workers to add themselves to the registry
    let connection_to_alice = tcp_bob
        .registry()
        .get_all_sender_workers()
        .last()
        .unwrap()
        .clone();

    message_should_not_pass(ctx, &connection_to_bob.into()).await?;
    message_should_not_pass(ctx, connection_to_alice.address()).await?;

    let alice_listener_info = create_secure_channel_listener(ctx, &alice_flow_control_id).await?;

    let channel_to_alice = create_secure_channel(ctx, connection_to_alice.address()).await?;
    ctx.sleep(Duration::from_millis(50)).await; // Wait for workers to add themselves to the registry
    let channel_to_bob = alice_listener_info.get_channel();

    message_should_not_pass(ctx, &channel_to_alice.address).await?;
    message_should_not_pass(ctx, &channel_to_bob).await?;

    Ok(())
}