miasma 0.2.8

Trap malicious AI web scrapers in an endless pit of poisoned training data.
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

mod error;
mod metrics_counter;
mod page;

use std::sync::Arc;

use axum::{Router, routing::get};
pub use error::MetricsError;
pub use metrics_counter::Metrics;

use tokio::sync::Mutex;

use crate::config::MetricsConfig;

const RESULTS_PER_PAGE: usize = 50;

#[derive(Clone)]
pub struct MetricsState {
    counter: Arc<Mutex<Metrics>>,
    auth_value: Arc<String>,
}

pub fn new_metrics_router(
    config: &Option<MetricsConfig>,
    metrics: Option<Arc<Mutex<Metrics>>>,
) -> Router {
    let Some(config) = config else {
        return Router::new();
    };
    let encoded_creds = config.encoded_credentials();
    let auth_value = format!("Basic {encoded_creds}",);

    Router::new()
        .route(&config.endpoint, get(page::metrics_handler))
        .with_state(MetricsState {
            counter: metrics.expect("metrics should be Some when config is Some"),
            auth_value: Arc::new(auth_value),
        })
}

#[cfg(test)]
mod test {
    use axum::{
        body::Body,
        http::{Request, header, status::StatusCode},
    };
    use base64::prelude::*;
    use tempfile::NamedTempFile;
    use tower::ServiceExt;

    use super::*;

    // Return the temp DB file as well so that it's dropped after the test.
    fn build_test_router() -> (Router, NamedTempFile) {
        let db_file = NamedTempFile::new().unwrap();
        let db_path = db_file.path().to_str().unwrap();
        let config = MetricsConfig::new(db_path, "admin", "admin", "/metrics");
        let metrics = Arc::new(Mutex::new(Metrics::new(db_path.to_owned()).unwrap()));

        let router = new_metrics_router(&Some(config), Some(metrics));
        (router, db_file)
    }

    #[tokio::test]
    async fn happy_path() {
        let (router, _db_file) = build_test_router();

        let req = Request::builder()
            .uri("/metrics")
            .header(
                header::AUTHORIZATION,
                format!("Basic {}", BASE64_STANDARD.encode("admin:admin")),
            )
            .body(Body::empty())
            .unwrap();

        let resp = router.oneshot(req).await.unwrap();

        assert_eq!(resp.status(), StatusCode::OK);
    }

    #[tokio::test]
    async fn rejects_unauthenticated_requests() {
        let (router, _db_file) = build_test_router();

        let req = Request::builder()
            .uri("/metrics")
            .body(Body::empty())
            .unwrap();

        let resp = router.oneshot(req).await.unwrap();

        assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
        assert_eq!(
            resp.headers().get(header::WWW_AUTHENTICATE).unwrap(),
            "Basic"
        );
    }

    #[tokio::test]
    async fn rejects_unauthorized_requests() {
        let (router, _db_file) = build_test_router();

        let req = Request::builder()
            .uri("/metrics")
            .header(
                header::AUTHORIZATION,
                format!(
                    "Basic {}",
                    BASE64_STANDARD.encode("invalid-username:invalid-password")
                ),
            )
            .body(Body::empty())
            .unwrap();

        let resp = router.oneshot(req).await.unwrap();

        assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
        assert_eq!(
            resp.headers().get(header::WWW_AUTHENTICATE).unwrap(),
            "Basic"
        );
    }
}