deaddrop-core 2.6.0

DeadDrop protocol, crypto, identities, chunks, and object store
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

//! Signed Space membership records. Payload-agnostic shared namespaces.

use crate::crypto::{CryptoProvider, DefaultProvider, PrivateIdentity};
use crate::{PeerId, Result};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SpaceKind {
    Private,
    InviteOnly,
    Public,
    Ephemeral,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SpaceRecord {
    pub name: String,
    pub kind: SpaceKind,
    pub members: Vec<PeerId>,
    pub retention: String,
    pub created_at: u64,
    pub founder: PeerId,
    #[serde(with = "serde_bytes")]
    pub signature: [u8; 64],
}

impl SpaceRecord {
    pub fn issue(
        author: &PrivateIdentity,
        name: String,
        kind: SpaceKind,
        members: Vec<PeerId>,
        retention: String,
        now: u64,
    ) -> Self {
        let mut rec = Self {
            name,
            kind,
            members,
            retention,
            created_at: now,
            founder: author.peer_id,
            signature: [0; 64],
        };
        rec.signature = DefaultProvider.sign(&author.signing_key(), &rec.preimage());
        rec
    }

    pub fn preimage(&self) -> Vec<u8> {
        let mut b = Vec::from(&b"ddp-space-v2"[..]);
        b.extend_from_slice(self.name.as_bytes());
        b.extend_from_slice(self.founder.as_bytes());
        b.extend_from_slice(&self.created_at.to_be_bytes());
        b
    }

    pub fn verify(&self, founder_pk: &[u8; 32]) -> Result<()> {
        DefaultProvider.verify(founder_pk, &self.preimage(), &self.signature)
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SpaceInvite {
    pub space: String,
    pub invitee: Option<PeerId>,
    pub issued_by: PeerId,
    pub created_at: u64,
    #[serde(with = "serde_bytes")]
    pub signature: [u8; 64],
}

impl SpaceInvite {
    pub fn issue(
        author: &PrivateIdentity,
        space: String,
        invitee: Option<PeerId>,
        now: u64,
    ) -> Self {
        let mut inv = Self {
            space,
            invitee,
            issued_by: author.peer_id,
            created_at: now,
            signature: [0; 64],
        };
        let mut msg = Vec::from(&b"ddp-space-invite-v2"[..]);
        msg.extend_from_slice(inv.space.as_bytes());
        msg.extend_from_slice(author.peer_id.as_bytes());
        inv.signature = DefaultProvider.sign(&author.signing_key(), &msg);
        inv
    }
}