116 lines
3.4 KiB
Rust
116 lines
3.4 KiB
Rust
use crate::error::MyError;
|
|
use activitystreams::primitives::XsdAnyUri;
|
|
use actix_web::client::Client;
|
|
use http_signature_normalization_actix::prelude::*;
|
|
use log::error;
|
|
use rsa::{hash::Hashes, padding::PaddingScheme, RSAPrivateKey};
|
|
use sha2::{Digest, Sha256};
|
|
|
|
#[derive(Clone)]
|
|
pub struct Requests {
|
|
client: Client,
|
|
key_id: String,
|
|
private_key: RSAPrivateKey,
|
|
config: Config,
|
|
user_agent: String,
|
|
}
|
|
|
|
impl Requests {
|
|
pub fn new(key_id: String, private_key: RSAPrivateKey, user_agent: String) -> Self {
|
|
Requests {
|
|
client: Client::default(),
|
|
key_id,
|
|
private_key,
|
|
config: Config::default().dont_use_created_field(),
|
|
user_agent,
|
|
}
|
|
}
|
|
|
|
pub async fn fetch<T>(&self, url: &str) -> Result<T, MyError>
|
|
where
|
|
T: serde::de::DeserializeOwned,
|
|
{
|
|
let mut res = self
|
|
.client
|
|
.get(url)
|
|
.header("Accept", "application/activity+json")
|
|
.header("User-Agent", self.user_agent.as_str())
|
|
.signature(&self.config, &self.key_id, |signing_string| {
|
|
self.sign(signing_string)
|
|
})?
|
|
.send()
|
|
.await
|
|
.map_err(|e| {
|
|
error!("Couldn't send request to {}, {}", url, e);
|
|
MyError::SendRequest
|
|
})?;
|
|
|
|
if !res.status().is_success() {
|
|
if let Ok(bytes) = res.body().await {
|
|
if let Ok(s) = String::from_utf8(bytes.as_ref().to_vec()) {
|
|
if !s.is_empty() {
|
|
error!("Response, {}", s);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Err(MyError::Status(res.status()));
|
|
}
|
|
|
|
res.json().await.map_err(|e| {
|
|
error!("Coudn't fetch json from {}, {}", url, e);
|
|
MyError::ReceiveResponse
|
|
})
|
|
}
|
|
|
|
pub async fn deliver<T>(&self, inbox: XsdAnyUri, item: &T) -> Result<(), MyError>
|
|
where
|
|
T: serde::ser::Serialize,
|
|
{
|
|
let mut digest = Sha256::new();
|
|
|
|
let item_string = serde_json::to_string(item)?;
|
|
|
|
let mut res = self
|
|
.client
|
|
.post(inbox.as_str())
|
|
.header("Accept", "application/activity+json")
|
|
.header("Content-Type", "application/activity+json")
|
|
.header("User-Agent", self.user_agent.as_str())
|
|
.signature_with_digest(
|
|
&self.config,
|
|
&self.key_id,
|
|
&mut digest,
|
|
item_string,
|
|
|signing_string| self.sign(signing_string),
|
|
)?
|
|
.send()
|
|
.await
|
|
.map_err(|e| {
|
|
error!("Couldn't send deliver request to {}, {}", inbox, e);
|
|
MyError::SendRequest
|
|
})?;
|
|
|
|
if !res.status().is_success() {
|
|
if let Ok(bytes) = res.body().await {
|
|
if let Ok(s) = String::from_utf8(bytes.as_ref().to_vec()) {
|
|
if !s.is_empty() {
|
|
error!("Response, {}", s);
|
|
}
|
|
}
|
|
}
|
|
return Err(MyError::Status(res.status()));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn sign(&self, signing_string: &str) -> Result<String, MyError> {
|
|
let hashed = Sha256::digest(signing_string.as_bytes());
|
|
let bytes =
|
|
self.private_key
|
|
.sign(PaddingScheme::PKCS1v15, Some(&Hashes::SHA2_256), &hashed)?;
|
|
Ok(base64::encode(bytes))
|
|
}
|
|
}
|