apub-publickey 0.1.0

Utilities for building activitypub servers
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
146
147
148
149
150
151
152
153
154
155
156
157
158

use apub_core::{
    activitypub::PublicKey,
    repo::{Dereference, Repo},
    session::Session,
};
use apub_privatekey::KeyId;
use url::{Host, Url};

#[async_trait::async_trait(?Send)]
pub trait PublicKeyRepo {
    type Error: std::error::Error;

    async fn store(&self, public_key: &SimplePublicKey) -> Result<(), Self::Error>;

    async fn fetch(&self, key_id: &KeyId) -> Result<Option<SimplePublicKey>, Self::Error>;
}

pub trait PublicKeyRepoFactory {
    type PublicKeyRepo: PublicKeyRepo;

    fn public_key_repo(&self) -> Self::PublicKeyRepo;
}

pub struct PublicKeyClient<LocalRepo, RemoteRepo> {
    local_host: Host<String>,
    local_port: Option<u16>,
    local: LocalRepo,
    remote: RemoteRepo,
}

#[derive(Debug, thiserror::Error)]
pub enum PublicKeyError<E, R> {
    #[error("Public Key's Owner doesn't match fetched Actor")]
    OwnerMismatch,

    #[error("{0}")]
    PublicKeyRepo(#[source] E),

    #[error("{0}")]
    RemoteRepo(#[source] R),
}

struct PublicKeyId<'a>(&'a KeyId);

#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SimplePublicKey {
    pub id: KeyId,
    pub owner: Url,
    pub public_key_pem: String,
}

#[derive(Clone, Debug, serde::Deserialize)]
#[serde(untagged)]
#[serde(rename_all = "camelCase")]
pub enum PublicKeyResponse {
    /// I dream of the day when asking for a Public Key gives me a public key
    PublicKey(SimplePublicKey),

    /// Getting an Actor from a PublicKey fetch is a bug IMO but mastodon does it so :shrug:
    Actor {
        id: Url,
        public_key: SimplePublicKey,
    },
}

impl<LocalRepo, RemoteRepo> PublicKeyClient<LocalRepo, RemoteRepo>
where
    LocalRepo: PublicKeyRepo,
    RemoteRepo: Repo,
{
    pub fn new(
        local: LocalRepo,
        remote: RemoteRepo,
        local_host: Host<String>,
        local_port: Option<u16>,
    ) -> Self {
        PublicKeyClient {
            local_host,
            local_port,
            local,
            remote,
        }
    }

    pub async fn find<S: Session>(
        &self,
        key_id: &KeyId,
        session: S,
    ) -> Result<Option<SimplePublicKey>, PublicKeyError<LocalRepo::Error, RemoteRepo::Error>> {
        let opt = self
            .local
            .fetch(key_id)
            .await
            .map_err(PublicKeyError::PublicKeyRepo)?;

        if self.is_local(key_id) {
            return Ok(opt);
        }

        let response = self
            .remote
            .fetch(PublicKeyId(key_id), session)
            .await
            .map_err(PublicKeyError::RemoteRepo)?;

        if let Some(response) = response {
            let public_key = match response {
                PublicKeyResponse::Actor { id, public_key } if id == public_key.owner => public_key,
                PublicKeyResponse::PublicKey(public_key) => public_key,
                _ => return Err(PublicKeyError::OwnerMismatch),
            };

            self.local
                .store(&public_key)
                .await
                .map_err(PublicKeyError::PublicKeyRepo)?;

            return Ok(Some(public_key));
        }

        Ok(None)
    }

    fn is_local(&self, url: &Url) -> bool {
        url.host() == Some(borrow_host(&self.local_host)) && url.port() == self.local_port
    }
}

fn borrow_host(host: &Host<String>) -> Host<&str> {
    match host {
        Host::Ipv4(ip) => Host::Ipv4(*ip),
        Host::Ipv6(ip) => Host::Ipv6(*ip),
        Host::Domain(ref domain) => Host::Domain(domain),
    }
}

impl<'a> Dereference for PublicKeyId<'a> {
    type Output = PublicKeyResponse;

    fn url(&self) -> &Url {
        self.0
    }
}

impl PublicKey for SimplePublicKey {
    fn id(&self) -> &Url {
        &self.id
    }

    fn owner(&self) -> &Url {
        &self.owner
    }

    fn public_key_pem(&self) -> &str {
        &self.public_key_pem
    }
}