scal3 0.4.1

Verify that systems operate under your sole control (prototype, patent pending)
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

use crate::api::{
    Acceptance, AuthenticateRequest, ChallengeRequest, PassRequest, ProveRequest, ProviderState,
    SubscriberState, Verification, VerifyRequest,
};
use crate::handle::get_authentication;
use crate::{Error, ErrorResponse, Response};
use serde::Deserialize;
use alloc::vec::Vec;

#[derive(Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum Request {
    Register(SubscriberState),
    Accept(ProviderState),
    Challenge(ChallengeRequest),
    Authenticate(AuthenticateRequest),
    Pass(PassRequest),
    Prove(ProveRequest),
    Verify(VerifyRequest),
}

/// Dispatches a CBOR-encoded request and returns a CBOR-encoded response.
pub fn dispatch(input: &[u8]) -> Vec<u8> {
    let response = match minicbor_serde::from_slice::<Request>(input) {
        Err(_) => Response::Error(ErrorResponse {
            error: Error::BadRequest,
        }),
        Ok(Request::Register(args)) => match args.handle() {
            None => Response::Error(ErrorResponse {
                error: Error::MissingValue,
            }),
            Some(Some(registration)) => Response::Register(Some(registration)),
            Some(None) => Response::Error(ErrorResponse {
                error: Error::InvalidInput,
            }),
        },
        Ok(Request::Accept(args)) => match args.handle() {
            None => Response::Error(ErrorResponse {
                error: Error::MissingValue,
            }),
            Some(Ok(())) => Response::Accept(Acceptance::Accepted),
            Some(Err(_)) => Response::Accept(Acceptance::Rejected),
        },
        Ok(Request::Authenticate(args)) => match args.handle2() {
            None => Response::Error(ErrorResponse {
                error: Error::MissingValue,
            }),
            Some(response) => Response::Authenticate(response),
        },
        Ok(Request::Challenge(args)) => match args.handle() {
            None => Response::Error(ErrorResponse {
                error: Error::MissingValue,
            }),
            Some(c) => Response::Challenge(crate::api::ChallengeResponse {
                challenge: Some(c),
                error: None,
            }),
        },
        Ok(Request::Pass(args)) => match args.authentication {
            None => Response::Error(ErrorResponse {
                error: Error::MissingValue,
            }),
            Some(id) => match get_authentication(id) {
                None => Response::Error(ErrorResponse {
                    error: Error::InvalidInput,
                }),
                Some(authentication) => match args.handle(*authentication) {
                    None => Response::Error(ErrorResponse {
                        error: Error::InvalidInput,
                    }),
                    Some(Some((k, p))) => Response::Pass(crate::api::Attempt {
                        sender: Some(k),
                        pass: Some(p),
                    }),
                    Some(None) => Response::Error(ErrorResponse {
                        error: Error::InvalidInput,
                    }),
                },
            },
        },
        Ok(Request::Prove(args)) => match args.handle() {
            None => Response::Error(ErrorResponse {
                error: Error::MissingValue,
            }),
            Some(Some((a, p, c))) => Response::Prove(Some(crate::api::Transcript {
                authenticator: Some(a),
                proof: Some(p),
                client: Some(c),
            })),
            Some(None) => Response::Prove(None),
        },
        Ok(Request::Verify(args)) => match args.handle() {
            None => Response::Error(ErrorResponse {
                error: Error::MissingValue,
            }),
            Some(Ok(())) => Response::Verify(Verification::Verified),
            Some(Err(_)) => Response::Verify(Verification::Rejected),
        },
    };
    minicbor_serde::to_vec(&response).expect("failed to serialize response")
}