89 lines
2 KiB
Rust
89 lines
2 KiB
Rust
use actix_web::{http::StatusCode, web, App, HttpRequest, HttpResponse, HttpServer, ResponseError};
|
|
use http_signature_normalization_actix_extractor::{
|
|
Algorithm, Config, ConfigGenerator, PrivateKey, Signed,
|
|
};
|
|
use sha2::Sha256;
|
|
|
|
#[actix_web::main]
|
|
async fn main() -> std::io::Result<()> {
|
|
HttpServer::new(|| App::new().route("/", web::post().to(protected)))
|
|
.bind("127.0.0.1:8010")?
|
|
.run()
|
|
.await
|
|
}
|
|
|
|
async fn protected(signed_request: Signed<String, Cfg, Sha256, Key>) -> &'static str {
|
|
let (value, signature) = signed_request.into_parts();
|
|
|
|
println!("{}", value);
|
|
println!("{:#?}", signature);
|
|
|
|
"hewwo, mr obama"
|
|
}
|
|
|
|
pub struct Cfg;
|
|
|
|
impl ConfigGenerator for Cfg {
|
|
fn config() -> Config {
|
|
Config::new().require_header("accept")
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct Key;
|
|
|
|
#[async_trait::async_trait(?Send)]
|
|
impl PrivateKey for Key {
|
|
type Error = MyError;
|
|
|
|
async fn init(
|
|
_: &HttpRequest,
|
|
key_id: &str,
|
|
algorithm: Option<&Algorithm>,
|
|
) -> Result<Self, Self::Error> {
|
|
match algorithm {
|
|
Some(Algorithm::Hs2019) => (),
|
|
_ => return Err(MyError::Algorithm),
|
|
};
|
|
|
|
if key_id != "my-key-id" {
|
|
return Err(MyError::Key);
|
|
}
|
|
|
|
Ok(Key)
|
|
}
|
|
|
|
fn verify(&mut self, signature: &str, signing_string: &str) -> Result<bool, Self::Error> {
|
|
use subtle::ConstantTimeEq;
|
|
|
|
let decoded = match base64::decode(&signature) {
|
|
Ok(decoded) => decoded,
|
|
Err(_) => return Err(MyError::Decode),
|
|
};
|
|
|
|
Ok(decoded.ct_eq(signing_string.as_bytes()).into())
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, thiserror::Error)]
|
|
pub enum MyError {
|
|
#[error("Unsupported algorithm")]
|
|
Algorithm,
|
|
|
|
#[error("Couldn't decode signature")]
|
|
Decode,
|
|
|
|
#[error("Invalid key")]
|
|
Key,
|
|
}
|
|
|
|
impl ResponseError for MyError {
|
|
fn status_code(&self) -> StatusCode {
|
|
StatusCode::BAD_REQUEST
|
|
}
|
|
|
|
fn error_response(&self) -> HttpResponse {
|
|
HttpResponse::BadRequest().finish()
|
|
}
|
|
}
|