Skip to main content

hyprstream_appview/
http.rs

1use std::sync::Arc;
2
3use axum::extract::{Extension, Query, State};
4use axum::http::StatusCode;
5use axum::response::{IntoResponse, Response};
6use axum::routing::get;
7use axum::{Json, Router};
8use hyprstream_pds_service::federation_intake::IdentityInventoryReadModel;
9use hyprstream_rpc::auth::mac::{CompartmentSet, Level, SecurityContext, VerifiedKeyMaterial};
10use serde::Deserialize;
11
12const MAX_FILTER_BYTES: usize = 256;
13const MAX_CURSOR_BYTES: usize = 2048;
14const DEFAULT_PAGE_SIZE: usize = 200;
15const MAX_PAGE_SIZE: usize = 200;
16
17#[derive(Clone)]
18struct InventoryHttpState {
19    inventory: Arc<dyn IdentityInventoryReadModel>,
20}
21
22/// Viewer clearance installed by trusted authentication/MAC middleware.
23///
24/// HTTP input cannot construct request extensions. If the extension is absent,
25/// the handler deliberately applies the unauthenticated public floor.
26#[derive(Clone, Debug)]
27pub struct InventoryViewer(SecurityContext);
28
29impl InventoryViewer {
30    /// Wrap a clearance already derived from verified server-side claims.
31    pub fn from_verified_clearance(clearance: SecurityContext) -> Self {
32        Self(clearance)
33    }
34
35    fn unauthenticated_floor() -> Self {
36        Self(SecurityContext::new(
37            Level::Public,
38            CompartmentSet::EMPTY,
39            VerifiedKeyMaterial::Unverified,
40        ))
41    }
42}
43
44#[derive(Debug, Default, Deserialize)]
45struct InventoryQuery {
46    filter: Option<String>,
47    after: Option<String>,
48    limit: Option<usize>,
49}
50
51/// Build a mountable `GET /inventory?filter=...` AppView router.
52///
53/// The response is exactly an `InventoryEntry[]`; it has no envelope in which a
54/// pre-filter total or hidden count could leak. Deployment middleware must
55/// reject an invalid presented credential with 401; only true credential
56/// absence may reach this router without an [`InventoryViewer`] extension.
57pub fn inventory_router(inventory: Arc<dyn IdentityInventoryReadModel>) -> Router {
58    Router::new()
59        .route("/inventory", get(query_inventory))
60        .with_state(InventoryHttpState { inventory })
61}
62
63async fn query_inventory(
64    State(state): State<InventoryHttpState>,
65    Query(query): Query<InventoryQuery>,
66    viewer: Option<Extension<InventoryViewer>>,
67) -> Response {
68    if query
69        .filter
70        .as_deref()
71        .is_some_and(|filter| filter.len() > MAX_FILTER_BYTES)
72        || query
73            .after
74            .as_deref()
75            .is_some_and(|after| after.len() > MAX_CURSOR_BYTES)
76        || query.limit == Some(0)
77    {
78        return (
79            StatusCode::BAD_REQUEST,
80            Json(serde_json::json!({"error": "invalid inventory query"})),
81        )
82            .into_response();
83    }
84    let limit = query.limit.unwrap_or(DEFAULT_PAGE_SIZE).min(MAX_PAGE_SIZE);
85    let viewer = viewer
86        .map(|Extension(viewer)| viewer)
87        .unwrap_or_else(InventoryViewer::unauthenticated_floor);
88    match state
89        .inventory
90        .query_page(
91            &viewer.0,
92            query.filter.as_deref(),
93            query.after.as_deref(),
94            limit,
95        )
96        .await
97    {
98        Ok(entries) => Json(entries).into_response(),
99        Err(error) => {
100            tracing::error!(error = %error, "inventory query failed");
101            (
102                StatusCode::INTERNAL_SERVER_ERROR,
103                Json(serde_json::json!({"error": "inventory unavailable"})),
104            )
105                .into_response()
106        }
107    }
108}
109
110#[cfg(test)]
111mod tests {
112    #![allow(clippy::expect_used, clippy::unwrap_used)]
113
114    use axum::body::{to_bytes, Body};
115    use axum::http::Request;
116    use hyprstream_pds_service::federation_intake::{InMemoryIdentityInventory, InventoryEntry};
117    use hyprstream_rpc::auth::mac::{Assurance, SecurityLabel};
118    use tower::ServiceExt;
119
120    use super::*;
121
122    #[tokio::test]
123    async fn get_inventory_returns_only_post_clearance_array() {
124        let inventory = Arc::new(InMemoryIdentityInventory::default());
125        inventory
126            .upsert_derived(
127                InventoryEntry::indexed_federated(
128                    "did:web:public.example",
129                    Some("alice.example".to_owned()),
130                    None,
131                )
132                .unwrap(),
133                SecurityLabel::bottom(),
134            )
135            .await
136            .unwrap();
137        inventory
138            .upsert_derived(
139                InventoryEntry::indexed_federated(
140                    "did:web:hidden.example",
141                    Some("hidden.example".to_owned()),
142                    None,
143                )
144                .unwrap(),
145                SecurityLabel::new(
146                    Level::Secret,
147                    Assurance::PqHybrid,
148                    CompartmentSet::single(9),
149                ),
150            )
151            .await
152            .unwrap();
153        let app = inventory_router(inventory);
154
155        let response = app
156            .clone()
157            .oneshot(
158                Request::get("/inventory?filter=example")
159                    .body(Body::empty())
160                    .unwrap(),
161            )
162            .await
163            .unwrap();
164        assert_eq!(response.status(), StatusCode::OK);
165        let body: serde_json::Value =
166            serde_json::from_slice(&to_bytes(response.into_body(), 8192).await.unwrap()).unwrap();
167        let entries = body.as_array().expect("response must be a bare array");
168        assert_eq!(entries.len(), 1);
169        assert_eq!(entries[0]["did"], "did:web:public.example");
170        assert!(body.get("total").is_none());
171        assert!(body.get("hiddenCount").is_none());
172
173        let response = app
174            .clone()
175            .oneshot(
176                Request::get(format!(
177                    "/inventory?filter={}",
178                    "x".repeat(MAX_FILTER_BYTES + 1)
179                ))
180                .body(Body::empty())
181                .unwrap(),
182            )
183            .await
184            .unwrap();
185        assert_eq!(response.status(), StatusCode::BAD_REQUEST);
186
187        let privileged = InventoryViewer::from_verified_clearance(SecurityContext::new(
188            Level::Secret,
189            CompartmentSet::single(9),
190            VerifiedKeyMaterial::PqHybrid,
191        ));
192        let mut request = Request::get("/inventory?limit=1")
193            .body(Body::empty())
194            .unwrap();
195        request.extensions_mut().insert(privileged.clone());
196        let response = app.clone().oneshot(request).await.unwrap();
197        let body: serde_json::Value =
198            serde_json::from_slice(&to_bytes(response.into_body(), 8192).await.unwrap()).unwrap();
199        let page = body.as_array().unwrap();
200        assert_eq!(page.len(), 1);
201        let after = page[0]["did"].as_str().unwrap();
202
203        let mut request = Request::get(format!("/inventory?limit=1&after={after}"))
204            .body(Body::empty())
205            .unwrap();
206        request.extensions_mut().insert(privileged);
207        let response = app.oneshot(request).await.unwrap();
208        let body: serde_json::Value =
209            serde_json::from_slice(&to_bytes(response.into_body(), 8192).await.unwrap()).unwrap();
210        assert_eq!(body.as_array().unwrap().len(), 1);
211    }
212}