Device Intelligence for Rust

use axum::{body::Bytes, http::{HeaderMap, StatusCode}, routing::post, Router};
use hmac::{Hmac, Mac};
use sha2::Sha256;
use serde::Deserialize;
type HmacSha256 = Hmac<Sha256>;
#[derive(Deserialize)]
struct Bot {
    result: String,
}
#[derive(Deserialize)]
struct Event {
    #[serde(rename = "visitorId")]
    visitor_id: String,
    bot: Bot,
}
// Recompute the HMAC-SHA256 over "<t>.<rawBody>" and compare it.
fn verify(body: &[u8], header: &str, secret: &[u8]) -> bool {
    let (mut t, mut v1) = ("", "");
    for kv in header.split(',') {
        match kv.split_once('=') {
            Some(("t", val)) => t = val,
            Some(("v1", val)) => v1 = val,
            _ => {}
        }
    }
    let mut mac = HmacSha256::new_from_slice(secret).unwrap();
    mac.update(t.as_bytes());
    mac.update(b".");
    mac.update(body);
    match hex::decode(v1) {
        Ok(sig) => mac.verify_slice(&sig).is_ok(),
        Err(_) => false,
    }
}
async fn webhook(headers: HeaderMap, body: Bytes) -> Result<&'static str, StatusCode> {
    let secret = std::env::var("TRACIO_WEBHOOK_SECRET").unwrap_or_default();
    let sig = headers
        .get("x-tracio-signature")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("");
    if !verify(&body, sig, secret.as_bytes()) {
        return Err(StatusCode::UNAUTHORIZED);
    }
    let event: Event = serde_json::from_slice(&body).map_err(|_| StatusCode::BAD_REQUEST)?;
    if event.bot.result == "bot" {
        println!("flagging bot visitor {}", event.visitor_id);
    }
    Ok("OK")
}
#[tokio::main]
async fn main() {
    let app = Router::new().route("/webhook/tracio", post(webhook));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}