hyprstream_core/services/oauth/
auth.rs1use std::sync::Arc;
11
12use axum::{
13 extract::{Request, State},
14 http::{header, StatusCode},
15 middleware::Next,
16 response::{IntoResponse, Response},
17};
18use subtle::ConstantTimeEq;
19
20use super::state::OAuthState;
21pub use crate::server::middleware::AuthenticatedUser;
22
23pub async fn require_bearer_token(
32 State(state): State<Arc<OAuthState>>,
33 mut request: Request,
34 next: Next,
35) -> Response {
36 let auth_header = request
37 .headers()
38 .get(header::AUTHORIZATION)
39 .and_then(|v| v.to_str().ok())
40 .map(str::to_owned);
41
42 let (scheme, token) = match auth_header.as_deref().and_then(|h| {
43 if let Some(t) = h.strip_prefix("Bearer ") {
44 Some(("Bearer", t.to_owned()))
45 } else if let Some(t) = h.strip_prefix("DPoP ") {
46 Some(("DPoP", t.to_owned()))
47 } else {
48 None
49 }
50 }) {
51 Some(pair) => pair,
52 None => {
53 return (
54 StatusCode::UNAUTHORIZED,
55 [(header::WWW_AUTHENTICATE, "Bearer")],
56 axum::Json(serde_json::json!({"error": "invalid_token", "error_description": "Bearer token required"})),
57 )
58 .into_response();
59 }
60 };
61
62 let dpop_proof_str = if scheme == "DPoP" {
64 match request.headers().get("DPoP").and_then(|v| v.to_str().ok()) {
65 Some(p) => Some(p.to_owned()),
66 None => {
67 return (
68 StatusCode::UNAUTHORIZED,
69 [(header::WWW_AUTHENTICATE, "Bearer error=\"invalid_token\"")],
70 axum::Json(serde_json::json!({"error": "invalid_token", "error_description": "DPoP proof header required when using DPoP scheme"})),
71 )
72 .into_response();
73 }
74 }
75 } else {
76 None
77 };
78
79 let claims = match validate_oauth_access_token(&state, &token).await {
80 Ok(c) => c,
81 Err(_) => {
82 return (
83 StatusCode::UNAUTHORIZED,
84 [(header::WWW_AUTHENTICATE, "Bearer error=\"invalid_token\"")],
85 axum::Json(serde_json::json!({"error": "invalid_token", "error_description": "Token invalid or expired"})),
86 )
87 .into_response();
88 }
89 };
90
91 if claims.cnf_jkt().is_some() && dpop_proof_str.is_none() {
94 return (
95 StatusCode::UNAUTHORIZED,
96 [(header::WWW_AUTHENTICATE, "DPoP error=\"invalid_token\"")],
97 axum::Json(serde_json::json!({"error": "invalid_token", "error_description": "DPoP-bound token must use Authorization: DPoP scheme"})),
98 )
99 .into_response();
100 }
101
102 if let Some(ref proof_str) = dpop_proof_str {
104 let method = request.method().as_str();
105 let uri = request.uri();
106 let htu = format!("{}{}", state.atproto_issuer_url(), uri.path());
110 let proof = match super::dpop::verify_dpop_proof(proof_str, method, &htu, Some(&token)) {
111 Ok(p) => p,
112 Err(e) => {
113 return (
114 StatusCode::UNAUTHORIZED,
115 [(header::WWW_AUTHENTICATE, "Bearer error=\"invalid_token\"")],
116 axum::Json(serde_json::json!({"error": "invalid_dpop_proof", "error_description": e.to_string()})),
117 )
118 .into_response();
119 }
120 };
121 if !state.check_and_record_dpop_jti(&proof.jti, proof.iat) {
123 return (
124 StatusCode::UNAUTHORIZED,
125 [(header::WWW_AUTHENTICATE, "Bearer error=\"invalid_token\"")],
126 axum::Json(serde_json::json!({"error": "invalid_dpop_proof", "error_description": "DPoP proof jti already used"})),
127 )
128 .into_response();
129 }
130
131 let needs_nonce = state.dpop_client_requires_nonce(&proof.jkt).await;
135 let nonce_ok = match proof.nonce.as_deref() {
136 Some(n) => state.verify_dpop_nonce(n).await,
137 None => false,
138 };
139 if needs_nonce && !nonce_ok {
140 let fresh = state.issue_dpop_nonce().await;
141 state.mark_dpop_client_nonced(&proof.jkt).await;
142 let mut resp = (
143 StatusCode::UNAUTHORIZED,
144 [(header::WWW_AUTHENTICATE, "DPoP error=\"use_dpop_nonce\"")],
145 axum::Json(serde_json::json!({
146 "error": "use_dpop_nonce",
147 "error_description": "DPoP proof must include a server-issued nonce",
148 })),
149 )
150 .into_response();
151 if let Ok(val) = axum::http::HeaderValue::from_str(&fresh) {
152 resp.headers_mut().insert("DPoP-Nonce", val);
153 }
154 return resp;
155 }
156 if proof.nonce.is_some() && !nonce_ok {
157 let fresh = state.issue_dpop_nonce().await;
159 state.mark_dpop_client_nonced(&proof.jkt).await;
160 let mut resp = (
161 StatusCode::UNAUTHORIZED,
162 [(header::WWW_AUTHENTICATE, "DPoP error=\"use_dpop_nonce\"")],
163 axum::Json(serde_json::json!({
164 "error": "use_dpop_nonce",
165 "error_description": "DPoP nonce invalid or expired",
166 })),
167 )
168 .into_response();
169 if let Ok(val) = axum::http::HeaderValue::from_str(&fresh) {
170 resp.headers_mut().insert("DPoP-Nonce", val);
171 }
172 return resp;
173 }
174 if let Some(token_jkt) = claims.cnf_jkt() {
176 if token_jkt.as_bytes().ct_eq(proof.jkt.as_bytes()).unwrap_u8() == 0 {
177 return (
178 StatusCode::UNAUTHORIZED,
179 [(header::WWW_AUTHENTICATE, "Bearer error=\"invalid_token\"")],
180 axum::Json(serde_json::json!({"error": "invalid_token", "error_description": "cnf.jkt does not match DPoP proof key"})),
181 )
182 .into_response();
183 }
184 }
185 }
186
187 let user = AuthenticatedUser {
188 user: claims.sub,
189 verified_tenant: claims.tenant,
190 token: Some(token),
191 exp: Some(claims.exp),
192 };
193 if user.authorization_domain().is_err() {
194 return (
195 StatusCode::FORBIDDEN,
196 axum::Json(serde_json::json!({
197 "error": "insufficient_scope",
198 "error_description": "Verified hosted-account tenant binding required"
199 })),
200 )
201 .into_response();
202 }
203 request.extensions_mut().insert(user);
204
205 next.run(request).await
206}
207
208pub async fn require_global_service_authority(request: Request, next: Next) -> Response {
215 let authorized = request
216 .extensions()
217 .get::<AuthenticatedUser>()
218 .is_some_and(|user| user.authorization_domain().as_deref() == Ok("*"));
219 if !authorized {
220 return (
221 StatusCode::FORBIDDEN,
222 axum::Json(serde_json::json!({
223 "error": "insufficient_scope",
224 "error_description": "global service authority required"
225 })),
226 )
227 .into_response();
228 }
229 next.run(request).await
230}
231
232pub(super) async fn validate_oauth_access_token(
241 state: &OAuthState,
242 token: &str,
243) -> Result<hyprstream_rpc::auth::Claims, &'static str> {
244 let claims = verify_access_token(state, token, AudiencePolicy::Exact).await?;
245
246 match claims.jti.as_deref() {
252 Some(jti) => {
253 let cred_id = hyprstream_rpc::auth::CredentialId::jwt(&claims.iss, jti);
254 match hyprstream_rpc::auth::global_credential_revocation_store() {
255 Some(store) => {
256 if store.is_revoked(&cred_id).await {
257 return Err("JWT revoked");
258 }
259 }
260 None => return Err("revocation store unavailable"),
261 }
262 }
263 None => return Err("local credential missing required jti"),
264 }
265
266 let session_key = match claims.session_key() {
269 Ok(key) => key,
270 Err(_) => return Err("malformed session claims"),
271 };
272 if let Some(session_key) = session_key {
273 match hyprstream_rpc::auth::global_session_registry() {
274 Some(registry) => {
275 if registry.is_revoked(&session_key).await {
276 return Err("session revoked");
277 }
278 }
279 None => return Err("session registry unavailable"),
280 }
281 }
282 if claims
286 .client_id
287 .as_deref()
288 .is_none_or(|c| c.trim().is_empty())
289 {
290 return Err("at+jwt credential missing required client_id");
291 }
292 Ok(claims)
293}
294
295pub(super) enum AudiencePolicy {
304 Exact,
305 AnyLocalIssuer,
306}
307
308pub(super) async fn verify_access_token(
314 state: &OAuthState,
315 token: &str,
316 audience_policy: AudiencePolicy,
317) -> Result<hyprstream_rpc::auth::Claims, &'static str> {
318 let header =
319 hyprstream_rpc::auth::parse_protected_header(token).map_err(|_| "JWT header invalid")?;
320 if !hyprstream_rpc::auth::is_rfc9068_access_token_type(&header.typ) {
321 return Err("JWT type invalid");
322 }
323
324 let canonical_audience = state.atproto_issuer_url();
325 let unverified =
326 hyprstream_rpc::auth::decode_unverified(token).map_err(|_| "JWT claims invalid")?;
327
328 let expected_audience = match (&audience_policy, unverified.aud.as_deref()) {
330 (AudiencePolicy::Exact, Some(audience))
331 if audience == canonical_audience || audience == state.issuer_url.as_str() =>
332 {
333 audience.to_owned()
334 }
335 (AudiencePolicy::AnyLocalIssuer, Some(audience)) if !audience.is_empty() => {
336 audience.to_owned()
337 }
338 _ => return Err("JWT audience invalid"),
339 };
340
341 let claims = match header.alg.as_str() {
342 "ML-DSA-65-Ed25519" => {
343 let dispatch = hyprstream_rpc::auth::parse_composite_dispatch(
344 token,
345 hyprstream_rpc::auth::RFC9068_ACCESS_TOKEN_TYPES,
346 )
347 .map_err(|_| "composite JWT dispatch invalid")?;
348 let snapshot = hyprstream_rpc::auth::global_composite_key_set().snapshot();
349 let pair = snapshot
350 .pair(dispatch.kid())
351 .ok_or("composite JWT kid unknown")?;
352 hyprstream_rpc::auth::jwt::decode_composite(
353 token,
354 pair.ml_dsa(),
355 pair.ed25519(),
356 Some(&expected_audience),
357 &dispatch,
358 )
359 .map_err(|_| "composite JWT validation failed")?
360 }
361 "EdDSA" => {
362 let key = state
363 .jwt_bearer_verifying_key()
364 .await
365 .ok_or("EdDSA verification key unavailable")?;
366 hyprstream_rpc::auth::jwt::decode(token, &key, Some(&expected_audience))
367 .map_err(|_| "EdDSA JWT validation failed")?
368 }
369 _ => return Err("JWT algorithm unsupported"),
370 };
371
372 let issuer_is_local = claims.iss == canonical_audience || claims.iss == state.issuer_url;
375 if !issuer_is_local {
376 return Err("JWT issuer invalid");
377 }
378 Ok(claims)
379}