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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use std::sync::Arc;

use rand::random;

use ockam_core::flow_control::FlowControlId;
use ockam_core::{route, Address, AllowAll, Result, Route};
use ockam_identity::models::Identifier;
use ockam_identity::{
    secure_channels, SecureChannelListenerOptions, SecureChannelOptions, SecureChannels,
};
use ockam_node::{Context, MessageReceiveOptions};

pub async fn message_should_pass(ctx: &Context, address: &Address) -> Result<()> {
    check_message_flow(ctx, route![address.clone()], true).await
}

pub async fn message_should_not_pass(ctx: &Context, address: &Address) -> Result<()> {
    check_message_flow(ctx, route![address.clone()], false).await
}

async fn check_message_flow(ctx: &Context, route: Route, should_pass: bool) -> Result<()> {
    let address = Address::random_local();
    let mut receiving_ctx = ctx.new_detached(address.clone(), AllowAll, AllowAll)?;

    let msg: [u8; 4] = random();
    let msg = hex::encode(msg);
    ctx.send(route + address, msg.clone()).await?;

    if should_pass {
        let msg_received = receiving_ctx.receive::<String>().await?.into_body()?;
        assert_eq!(msg_received, msg);
    } else {
        let res = receiving_ctx
            .receive_extended::<String>(MessageReceiveOptions::new().with_timeout_secs(1))
            .await;
        assert!(res.is_err(), "Messages should not pass for given route");
    }

    Ok(())
}

pub async fn message_should_pass_with_ctx(
    ctx: &Context,
    address: &Address,
    receiving_ctx: &mut Context,
) -> Result<()> {
    check_message_flow_with_ctx(ctx, address, receiving_ctx, true).await
}

pub async fn message_should_not_pass_with_ctx(
    ctx: &Context,
    address: &Address,
    receiving_ctx: &mut Context,
) -> Result<()> {
    check_message_flow_with_ctx(ctx, address, receiving_ctx, false).await
}

async fn check_message_flow_with_ctx(
    ctx: &Context,
    address: &Address,
    receiving_ctx: &mut Context,
    should_pass: bool,
) -> Result<()> {
    let msg: [u8; 4] = random();
    let msg = hex::encode(msg);
    ctx.send(
        route![address.clone(), receiving_ctx.primary_address().clone()],
        msg.clone(),
    )
    .await?;

    if should_pass {
        let msg_received = receiving_ctx.receive::<String>().await?.into_body()?;
        assert_eq!(msg_received, msg);
    } else {
        let res = receiving_ctx
            .receive_extended::<String>(MessageReceiveOptions::new().with_timeout_secs(1))
            .await;
        assert!(res.is_err(), "Messages should not pass for given route");
    }

    Ok(())
}

pub struct SecureChannelListenerInfo {
    pub identifier: Identifier,
    pub secure_channels: Arc<SecureChannels>,
    pub flow_control_id: FlowControlId,
}

impl SecureChannelListenerInfo {
    pub fn get_channel(&self) -> Address {
        self.secure_channels
            .secure_channel_registry()
            .get_channel_list()
            .first()
            .unwrap()
            .encryptor_messaging_address()
            .clone()
    }
}

pub async fn create_secure_channel_listener(
    ctx: &Context,
    flow_control_id: &FlowControlId,
) -> Result<SecureChannelListenerInfo> {
    let secure_channels = secure_channels().await?;
    let identities_creation = secure_channels.identities().identities_creation();

    let identifier = identities_creation.create_identity().await?;
    let options = SecureChannelListenerOptions::new().as_consumer(flow_control_id);
    let listener =
        secure_channels.create_secure_channel_listener(ctx, &identifier, "listener", options)?;

    let info = SecureChannelListenerInfo {
        secure_channels,
        identifier,
        flow_control_id: listener.flow_control_id().clone(),
    };

    Ok(info)
}

pub struct SecureChannelInfo {
    pub secure_channels: Arc<SecureChannels>,
    pub identifier: Identifier,
    pub address: Address,
}

pub async fn create_secure_channel(
    ctx: &Context,
    connection: &Address,
) -> Result<SecureChannelInfo> {
    let secure_channels = secure_channels().await?;
    let identities_creation = secure_channels.identities().identities_creation();

    let identifier = identities_creation.create_identity().await?;
    let address = secure_channels
        .create_secure_channel(
            ctx,
            &identifier,
            route![connection.clone(), "listener"],
            SecureChannelOptions::new(),
        )
        .await?
        .encryptor_address()
        .clone();

    let info = SecureChannelInfo {
        secure_channels,
        identifier,
        address,
    };

    Ok(info)
}