zaaarf/upub
1
0
Fork 0
forked from alemi/upub
Code Pull requests Activity

feat: reimplemented from scratch http sig verify

Browse source
This commit is contained in:
əlemi 2024-04-13 05:26:50 +02:00
parent 6614f63f56
commit 437859008c
Signed by: alemi
GPG key ID: A4895B84D311642C
3 changed files with 66 additions and 98 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Cargo.toml
View file

@ -35,7 +35,6 @@ axum = "0.7"
apb = { path = "apb", features = ["unstructured", "fetch", "orm"] }
# nodeinfo = "0.0.2" # the version on crates.io doesn't re-export necessary types to build the struct!!!
nodeinfo = { git = "https://codeberg.org/thefederationinfo/nodeinfo-rs", rev = "e865094804" }
http-signature-normalization = "0.7.0"
# migrations
sea-orm-migration = { version = "0.12", optional = true }
# mastodon

138
src/server/auth.rs
View file

@ -1,10 +1,6 @@
use std::collections::BTreeMap;
use axum::{extract::{FromRef, FromRequestParts}, http::{header, request::Parts, HeaderMap, StatusCode}};
use axum::{extract::{FromRef, FromRequestParts}, http::{header, request::Parts}};
use base64::Engine;
use http_signature_normalization::Config;
use openssl::{hash::MessageDigest, pkey::PKey, sign::Verifier};
use reqwest::Method;
use sea_orm::{ColumnTrait, Condition, EntityTrait, QueryFilter};
use crate::{errors::UpubError, model, server::Context};
@ -68,49 +64,20 @@ where
.get("Signature")
.map(|v| v.to_str().unwrap_or(""))
{
let mut signature_cfg = Config::new().mastodon_compat();
let mut headers : BTreeMap<String, String> = [
("Signature".to_string(), sig.to_string()),
("Host".to_string(), header_get(&parts.headers, "Host")),
("Date".to_string(), header_get(&parts.headers, "Date")),
].into();
if parts.method == Method::POST {
signature_cfg = signature_cfg.require_header("digest");
headers.insert("Digest".to_string(), header_get(&parts.headers, "Digest"));
}
let unverified = match signature_cfg.begin_verify(
parts.method.as_str(),
parts.uri.path_and_query().map(|x| x.as_str()).unwrap_or("/"),
headers
) {
Ok(x) => x,
Err(e) => {
tracing::error!("failed preparing signature verification context: {e}");
return Err(UpubError::internal_server_error());
}
};
let user_id = unverified.key_id().replace("#main-key", "");
if let Ok(user) = ctx.fetch().user(&user_id).await {
let valid = unverified.verify(|sig, to_sign| {
let pubkey = PKey::public_key_from_pem(user.public_key.as_bytes())?;
let mut verifier = Verifier::new(MessageDigest::sha256(), &pubkey).unwrap();
verifier.update(to_sign.as_bytes())?;
Ok(verifier.verify(&base64::prelude::BASE64_URL_SAFE.decode(sig).unwrap_or_default())?) as crate::Result<bool>
});
let http_signature = HttpSignature::parse(sig);
let user_id = http_signature.key_id.replace("#main-key", "");
match ctx.fetch().user(&user_id).await {
Ok(user) => {
let to_sign = http_signature.build_string(parts);
// TODO assert payload's digest is equal to signature's
match valid {
// TODO introduce hardened mode which identifies remotes by user and not server
match verify_control_text(&to_sign, &user.public_key, &http_signature.signature) {
Ok(true) => identity = Identity::Remote(Context::server(&user_id)),
Ok(false) => return Err(UpubError::unauthorized()),
Err(e) => {
tracing::error!("failed verifying signature: {e}");
},
Ok(false) => tracing::warn!("invalid signature"),
Err(e) => tracing::error!("error verifying signature: {e}"),
}
},
Err(e) => tracing::warn!("could not fetch user (won't verify): {e}"),
}
}
@ -118,7 +85,26 @@ where
}
}
#[allow(unused)] // TODO am i gonna reimplement http signatures for verification?
fn verify_control_text(txt: &str, key: &str, control: &str) -> crate::Result<bool> {
let pubkey = PKey::public_key_from_pem(key.as_bytes())?;
let mut verifier = Verifier::new(MessageDigest::sha256(), &pubkey).unwrap();
verifier.update(txt.as_bytes())?;
Ok(verifier.verify(&base64::prelude::BASE64_URL_SAFE.decode(control).unwrap_or_default())?)
}
#[derive(Debug, Clone, Default)]
pub struct HttpSignature {
key_id: String,
algorithm: String,
@ -127,7 +113,38 @@ pub struct HttpSignature {
}
impl HttpSignature {
#[allow(unused)] // TODO am i gonna reimplement http signatures for verification?
pub fn parse(header: &str) -> Self {
let mut sig = HttpSignature::default();
header.split(',')
.filter_map(|x| x.split_once('='))
.map(|(k, v)| (k, v.trim_end_matches('"').trim_matches('"')))
.for_each(|(k, v)| match k {
"keyId" => sig.key_id = v.to_string(),
"algorithm" => sig.algorithm = v.to_string(),
"signature" => sig.signature = v.to_string(),
"headers" => sig.headers = v.split(' ').map(|x| x.to_string()).collect(),
_ => tracing::warn!("unexpected field in http signature: '{k}=\"{v}\"'"),
});
sig
}
pub fn build_string(&self, parts: &Parts) -> String {
let mut out = Vec::new();
for header in self.headers.iter() {
match header.as_str() {
"(request-target)" => out.push(
format!("(request-target): {}", parts.uri.path_and_query().map(|x| x.as_str()).unwrap_or("/"))
),
// TODO other pseudo-headers,
_ => out.push(format!("{}: {}",
header.to_lowercase(),
parts.headers.get(header).map(|x| x.to_str().unwrap_or("")).unwrap_or("")
)),
}
}
out.join("\n")
}
pub fn digest(&self) -> MessageDigest {
match self.algorithm.as_str() {
"rsa-sha512" => MessageDigest::sha512(),
@ -141,32 +158,3 @@ impl HttpSignature {
}
}
}
impl TryFrom<&str> for HttpSignature {
type Error = StatusCode; // TODO: quite ad hoc...
fn try_from(value: &str) -> Result<Self, Self::Error> {
let parameters : BTreeMap<String, String> = value
.split(',')
.filter_map(|s| { // TODO kinda ugly, can be made nicer?
let (k, v) = s.split_once("=\"")?;
let (k, mut v) = (k.to_string(), v.to_string());
v.pop();
Some((k, v))
}).collect();
let sig = HttpSignature {
key_id: parameters.get("keyId").ok_or(StatusCode::BAD_REQUEST)?.to_string(),
algorithm: parameters.get("algorithm").ok_or(StatusCode::BAD_REQUEST)?.to_string(),
headers: parameters.get("headers").map(|x| x.split(' ').map(|x| x.to_string()).collect()).unwrap_or(vec!["date".to_string()]),
signature: parameters.get("signature").ok_or(StatusCode::BAD_REQUEST)?.to_string(),
};
Ok(sig)
}
}
pub fn header_get(headers: &HeaderMap, k: &str) -> String {
headers.get(k).map(|x| x.to_str().unwrap_or("")).unwrap_or("").to_string()
}

19
src/server/fetcher.rs
View file

@ -43,7 +43,6 @@ impl Fetcher {
.header("Host", host.clone())
.header("Date", date.clone());
// let mut signature_cfg = Config::new().mastodon_compat();
let mut to_sign_raw = format!("(request-target): {} {path}\nhost: {host}\ndate: {date}", method.to_string().to_lowercase());
let mut headers_to_inspect = "(request-target) host date";
@ -51,27 +50,11 @@ impl Fetcher {
let digest = format!("sha-256={}", base64::prelude::BASE64_STANDARD.encode(openssl::sha::sha256(payload.as_bytes())));
to_sign_raw = format!("(request-target): {} {path}\nhost: {host}\ndate: {date}\ndigest: {digest}", method.to_string().to_lowercase());
headers_to_inspect = "(request-target) host date digest";
// headers.insert("Digest".to_string(), digest.clone());
// signature_cfg = signature_cfg.require_header("digest");
client = client
.header("Digest", digest)
.body(payload.to_string());
}
// let signature_header = signature_cfg
// .begin_sign("POST", &path, headers)
// .unwrap()
// .sign(format!("{from}#main-key"), |to_sign| {
// // tracing::info!("signature string:\nlib>> {to_sign}\nraw>> {to_sign_raw}");
// let mut signer = Signer::new(MessageDigest::sha256(), key)?;
// signer.update(to_sign.as_bytes())?;
// let signature = base64::prelude::BASE64_URL_SAFE.encode(signer.sign_to_vec()?);
// Ok(signature) as crate::Result<_>
// })
// .unwrap()
// .signature_header()
// .replace("hs2019", "rsa-sha256"); // TODO what the fuck??? why isn't this customizable???
let signature_header = {
let mut signer = Signer::new(MessageDigest::sha256(), key).unwrap();
signer.update(to_sign_raw.as_bytes()).unwrap();
@ -79,8 +62,6 @@ impl Fetcher {
format!("keyId=\"{from}#main-key\",algorithm=\"rsa-sha256\",headers=\"{headers_to_inspect}\",signature=\"{signature}\"")
};
// tracing::info!("signature headers:\nlib>> {signature_header_lib}\nraw>> {signature_header}");
client
.header("Signature", signature_header)
.send()