activityforge 0.1.0-pre-alpha.2

ActivityForge federated git forges over ActivityPub
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

use activitystreams_vocabulary::{
    Iri, Key, PublicKeyPem, field_access, impl_default, impl_display,
};

use serde::{Deserialize, Serialize};

use crate::crypto::{KeyType, PublicKey};
use crate::{Error, Result};

#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PemPublicKey {
    id: Iri,
    owner: Iri,
    public_key_pem: PublicKey,
}

impl PemPublicKey {
    /// Creates a new [PemPublicKey].
    pub fn new() -> Self {
        Self {
            id: Iri::new(),
            owner: Iri::new(),
            public_key_pem: PublicKey::new(),
        }
    }
}

field_access! {
    PemPublicKey {
        /// Represents the key ID used to fetch the key from a remote server.
        id: as_ref { Iri },
        /// Represents the owner ID used to fetch the actor record from a remote server.
        owner: as_ref { Iri },
        /// Represents the public key to be encoded to PEM ASN.1 DER for network transmission.
        public_key_pem: as_ref { PublicKey },
    }
}

impl_default!(PemPublicKey);
impl_display!(PemPublicKey, json);

impl TryFrom<Key> for PemPublicKey {
    type Error = Error;

    fn try_from(val: Key) -> Result<Self> {
        (&val).try_into()
    }
}

impl TryFrom<&Key> for PemPublicKey {
    type Error = Error;

    fn try_from(val: &Key) -> Result<Self> {
        let id = val.id().cloned().ok_or(Error::crypto("pem: missing ID"))?;

        let owner = val
            .owner()
            .cloned()
            .ok_or(Error::crypto("pem: missing owner"))
            .or_else(|_| {
                val.controller()
                    .cloned()
                    .ok_or(Error::crypto("pem: missing controller"))
            })?;

        let pem = val
            .public_key_pem()
            .ok_or(Error::crypto("pem: missing public key"))
            .map(|k| k.to_string())?;

        PublicKey::from_pem(KeyType::Ed25519, &pem)
            .or_else(|_| PublicKey::from_pem(KeyType::Ecdsa256, &pem))
            .or_else(|_| PublicKey::from_pem(KeyType::Ecdsa384, &pem))
            .or_else(|_| PublicKey::from_pem(KeyType::Rsa2048, &pem))
            .map_err(|err| Error::crypto(format!("pem: invalid key: {err}")))
            .map(|public_key_pem| Self {
                id,
                owner,
                public_key_pem,
            })
    }
}

impl TryFrom<PemPublicKey> for Key {
    type Error = Error;

    fn try_from(val: PemPublicKey) -> Result<Self> {
        (&val).try_into()
    }
}

impl TryFrom<&PemPublicKey> for Key {
    type Error = Error;

    fn try_from(val: &PemPublicKey) -> Result<Self> {
        val.public_key_pem().to_der().map(|der| {
            Self::new()
                .with_id(val.id().clone())
                .with_owner(val.owner().clone())
                .with_public_key_pem(PublicKeyPem::new().with_key(der))
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::crypto::Ed25519PublicKey;

    const ED25519_PUBKEY_BYTES: [u8; 32] = [
        0x7d, 0xb0, 0x56, 0xf4, 0xe, 0xa7, 0x10, 0xb6, 0x80, 0xa7, 0x6a, 0xd7, 0x26, 0xfd, 0xbd,
        0x3e, 0x70, 0xea, 0xd1, 0xd6, 0x20, 0xa7, 0x74, 0xdb, 0x4b, 0x1a, 0x2a, 0x48, 0xa0, 0xce,
        0xa3, 0xe5,
    ];

    #[test]
    fn test_pem_key() {
        let pubkey =
            PublicKey::Ed25519(Ed25519PublicKey::from_bytes(&ED25519_PUBKEY_BYTES).unwrap());
        let pubkey_json = pubkey.to_string();

        let owner_id = Iri::try_from("https://example.dev/api/v1/persons/test_user").unwrap();
        let key_id = Iri::try_from(format!("{owner_id}?keyId=test-key-ed25519")).unwrap();

        let pemkey_json = format!(
            r#"{{
  "id": "{key_id}",
  "owner": "{owner_id}",
  "publicKeyPem": {pubkey_json}
}}"#
        );

        let pemkey = PemPublicKey::new()
            .with_id(key_id)
            .with_owner(owner_id)
            .with_public_key_pem(pubkey);

        assert_eq!(serde_json::to_string_pretty(&pemkey).unwrap(), pemkey_json);
        assert_eq!(
            serde_json::from_str::<PemPublicKey>(&pemkey_json).unwrap(),
            pemkey
        );
    }
}