enigma_node_types/
identity.rs

1use std::convert::TryFrom;
2
3use serde::{Deserialize, Serialize};
4
5use crate::error::{EnigmaNodeTypesError, Result};
6use crate::user_id::{normalize_username, UserId};
7
8#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
9#[serde(deny_unknown_fields)]
10pub struct PublicIdentity {
11    pub user_id: UserId,
12    pub username_hint: Option<String>,
13    pub signing_public_key: Vec<u8>,
14    pub encryption_public_key: Vec<u8>,
15    pub signature: Vec<u8>,
16    pub created_at_ms: u64,
17}
18
19impl PublicIdentity {
20    pub fn validate(&self) -> Result<()> {
21        if self.signing_public_key.is_empty() {
22            return Err(EnigmaNodeTypesError::InvalidField("signing_public_key"));
23        }
24        if self.encryption_public_key.is_empty() {
25            return Err(EnigmaNodeTypesError::InvalidField("encryption_public_key"));
26        }
27        if self.signature.is_empty() {
28            return Err(EnigmaNodeTypesError::InvalidField("signature"));
29        }
30        if self.created_at_ms == 0 {
31            return Err(EnigmaNodeTypesError::InvalidField("created_at_ms"));
32        }
33        if let Some(hint) = &self.username_hint {
34            normalize_username(hint)?;
35        }
36        Ok(())
37    }
38}
39
40pub fn signed_payload(
41    username_hint: &str,
42    signing_public_key: &[u8],
43    encryption_public_key: &[u8],
44) -> Vec<u8> {
45    let hint_bytes = username_hint.as_bytes();
46    let hint_len = match u32::try_from(hint_bytes.len()) {
47        Ok(v) => v,
48        Err(_) => u32::MAX,
49    };
50    let signing_len = match u32::try_from(signing_public_key.len()) {
51        Ok(v) => v,
52        Err(_) => u32::MAX,
53    };
54    let encryption_len = match u32::try_from(encryption_public_key.len()) {
55        Ok(v) => v,
56        Err(_) => u32::MAX,
57    };
58    let mut payload = Vec::with_capacity(
59        hint_bytes.len()
60            .saturating_add(signing_public_key.len())
61            .saturating_add(encryption_public_key.len())
62            .saturating_add(12),
63    );
64    payload.extend_from_slice(&hint_len.to_be_bytes());
65    payload.extend_from_slice(hint_bytes);
66    payload.extend_from_slice(&signing_len.to_be_bytes());
67    payload.extend_from_slice(signing_public_key);
68    payload.extend_from_slice(&encryption_len.to_be_bytes());
69    payload.extend_from_slice(encryption_public_key);
70    payload
71}
72
73#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
74#[serde(deny_unknown_fields)]
75pub struct RegisterRequest {
76    pub identity: PublicIdentity,
77}
78
79#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
80#[serde(deny_unknown_fields)]
81pub struct RegisterResponse {
82    pub ok: bool,
83}
84
85#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
86#[serde(deny_unknown_fields)]
87pub struct ResolveResponse {
88    pub identity: Option<PublicIdentity>,
89}
90
91#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
92#[serde(deny_unknown_fields)]
93pub struct CheckUserResponse {
94    pub exists: bool,
95}
96
97#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
98#[serde(deny_unknown_fields)]
99pub struct SyncRequest {
100    pub identities: Vec<PublicIdentity>,
101}
102
103#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
104#[serde(deny_unknown_fields)]
105pub struct SyncResponse {
106    pub merged: usize,
107}
enigma_node_types/identity.rs

enigma_node_types/
identity.rs
