ockam_entity 0.35.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

use crate::{
    CredentialAttribute, CredentialProtocolMessage, CredentialSchema, EntityError,
    EntitySecureChannelLocalInfo, Issuer, OfferId, Profile, ProfileIdentifier,
};
use ockam_core::async_trait;
use ockam_core::compat::{boxed::Box, string::String, vec::Vec};
use ockam_core::{Result, Route, Routed, Worker};
use ockam_node::Context;

enum State {
    CreateOffer(Route),
    SignRequest(OfferId),
    Done,
}

pub struct IssuerWorker {
    state: State,
    profile: Profile,
    holder_id: ProfileIdentifier,
    schema: CredentialSchema,
}

impl IssuerWorker {
    pub fn new(
        profile: Profile,
        holder_id: ProfileIdentifier,
        schema: CredentialSchema,
        return_route: Route,
    ) -> Result<Self> {
        let s = Self {
            profile,
            state: State::CreateOffer(return_route),
            holder_id,
            schema,
        };

        Ok(s)
    }
}

#[async_trait]
impl Worker for IssuerWorker {
    type Context = Context;
    type Message = CredentialProtocolMessage;

    async fn initialize(&mut self, ctx: &mut Self::Context) -> Result<()> {
        if let State::CreateOffer(return_route) = &self.state {
            let offer = self.profile.create_offer(&self.schema).await?;
            let offer_id = offer.id.clone();
            ctx.send(
                return_route.clone(),
                CredentialProtocolMessage::IssueOffer(offer),
            )
            .await?;

            self.state = State::SignRequest(offer_id);
        }

        Ok(())
    }

    async fn handle_message(
        &mut self,
        ctx: &mut Self::Context,
        msg: Routed<Self::Message>,
    ) -> Result<()> {
        let local_info = EntitySecureChannelLocalInfo::find_info(msg.local_message())?;
        if self.holder_id.ne(local_info.their_profile_id()) {
            return Err(EntityError::IssuerInvalidMessage.into());
        }

        let route = msg.return_route();
        let msg = msg.body();

        match &self.state {
            State::CreateOffer(_) => return Err(EntityError::InvalidIssueState.into()),
            State::SignRequest(offer_id) => {
                if let CredentialProtocolMessage::IssueRequest(request, values) = msg {
                    let signing_attributes: Vec<(String, CredentialAttribute)> = self
                        .schema
                        .attributes
                        .iter()
                        .skip(1) // FIXME: SECRET_ID
                        .zip(values.iter())
                        .map(|x|
                        // FIXME: Check types?
                        (x.0.label.clone(), x.1.clone()))
                        .collect();

                    // Office signs the credentials.
                    let frag2 = self
                        .profile
                        .sign_credential_request(
                            &request,
                            &self.schema,
                            &(signing_attributes.clone()),
                            offer_id.clone(),
                        )
                        .await?;

                    ctx.send(route, CredentialProtocolMessage::IssueResponse(frag2))
                        .await?;

                    self.state = State::Done;

                    ctx.stop_worker(ctx.address()).await?;
                } else {
                    return Err(EntityError::IssuerInvalidMessage.into());
                }
            }
            State::Done => {}
        }

        Ok(())
    }
}