1pub(crate) mod store;
4#[cfg(test)]
5mod tests;
6
7use crate::{api_error::ApiError, AppState};
8use axum::{
9 body::Bytes,
10 extract::{ConnectInfo, DefaultBodyLimit, OriginalUri, Path, Query, State},
11 http::{header, HeaderMap, Method, StatusCode},
12 response::{Html, IntoResponse, Response},
13 routing::{delete, get, post},
14 Json, Router,
15};
16use serde::Deserialize;
17use serde_json::json;
18use std::{collections::BTreeMap, net::SocketAddr, time::Duration};
19
20pub const DISCOVERY_SCOPE: &str = "connections:read";
21pub const READ_SCOPE: &str = "proxy:read";
22pub const WRITE_SCOPE: &str = "proxy:write";
23pub const CONNECTION_MANAGE_SCOPE: &str = "connections:manage";
24pub const SESSION_MANAGE_SCOPE: &str = "sessions:manage";
25pub const NOTIFICATION_SCOPE: &str = "notifications:consume";
26const DEVICE_GRANT: &str = "urn:ietf:params:oauth:grant-type:device_code";
27
28#[derive(Clone, Debug, Default)]
32pub struct DeviceConfig {
33 pub clients: BTreeMap<String, String>,
34 pub approval_url: Option<String>,
35}
36impl DeviceConfig {
37 pub(crate) fn from_env() -> Result<Self, String> {
38 let clients = match std::env::var("DEVICE_CLIENTS")
39 .ok()
40 .filter(|s| !s.trim().is_empty())
41 {
42 Some(value) => serde_json::from_str(&value).map_err(|_| {
43 "DEVICE_CLIENTS must be a JSON object mapping public client ids to display names"
44 })?,
45 None => BTreeMap::new(),
46 };
47 let config = Self {
48 clients,
49 approval_url: std::env::var("DEVICE_APPROVAL_URL")
50 .ok()
51 .filter(|s| !s.trim().is_empty()),
52 };
53 config.validate()?;
54 Ok(config)
55 }
56 pub(crate) fn validate(&self) -> Result<(), String> {
57 if self.clients.len() > 20
58 || self.clients.iter().any(|(id, name)| {
59 id.is_empty()
60 || id.len() > 80
61 || !id
62 .bytes()
63 .all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_')
64 || name.is_empty()
65 || name.chars().count() > 100
66 || name.chars().any(char::is_control)
67 })
68 {
69 return Err("DEVICE_CLIENTS allows at most 20 clients, with 1..80 ASCII id characters and 1..100 display name characters".into());
70 }
71 if !self.clients.is_empty() {
72 let url = self
73 .approval_url
74 .as_ref()
75 .ok_or("DEVICE_APPROVAL_URL is required when device clients are registered")?;
76 let parsed = url::Url::parse(url).map_err(|_| {
77 "DEVICE_APPROVAL_URL must be an absolute HTTPS URL (loopback HTTP for development)"
78 })?;
79 let loopback = matches!(parsed.host_str(), Some("localhost" | "127.0.0.1" | "[::1]"));
80 if !(parsed.scheme() == "https" || parsed.scheme() == "http" && loopback)
81 || !parsed.username().is_empty()
82 || parsed.password().is_some()
83 || parsed.query().is_some()
84 || parsed.fragment().is_some()
85 {
86 return Err("DEVICE_APPROVAL_URL must be an absolute HTTPS URL without credentials, query or fragment (loopback HTTP for development)".into());
87 }
88 }
89 Ok(())
90 }
91}
92
93#[derive(Debug)]
94pub(crate) struct Error {
95 code: &'static str,
96 status: StatusCode,
97}
98impl Error {
99 fn oauth(code: &'static str) -> Self {
100 Self {
101 code,
102 status: StatusCode::BAD_REQUEST,
103 }
104 }
105 fn invalid_token() -> Self {
106 Self {
107 code: "invalid_token",
108 status: StatusCode::UNAUTHORIZED,
109 }
110 }
111 fn limited() -> Self {
112 Self {
113 code: "temporarily_unavailable",
114 status: StatusCode::TOO_MANY_REQUESTS,
115 }
116 }
117}
118impl From<tokio_postgres::Error> for Error {
119 fn from(_: tokio_postgres::Error) -> Self {
120 Self {
121 code: "temporarily_unavailable",
122 status: StatusCode::SERVICE_UNAVAILABLE,
123 }
124 }
125}
126impl From<String> for Error {
127 fn from(_: String) -> Self {
128 Self {
129 code: "temporarily_unavailable",
130 status: StatusCode::SERVICE_UNAVAILABLE,
131 }
132 }
133}
134impl IntoResponse for Error {
135 fn into_response(self) -> Response {
136 let mut response = protected((self.status, Json(json!({"error":self.code}))));
137 if self.status == StatusCode::TOO_MANY_REQUESTS {
138 response
139 .headers_mut()
140 .insert(header::RETRY_AFTER, "60".parse().unwrap());
141 }
142 response
143 }
144}
145fn protected(value: impl IntoResponse) -> Response {
146 let mut response = value.into_response();
147 response
148 .headers_mut()
149 .insert(header::CACHE_CONTROL, "no-store".parse().unwrap());
150 response
151 .headers_mut()
152 .insert(header::PRAGMA, "no-cache".parse().unwrap());
153 response
154 .headers_mut()
155 .insert(header::REFERRER_POLICY, "no-referrer".parse().unwrap());
156 response
157}
158fn enabled(state: &AppState) -> Result<&crate::security::Security, Error> {
159 if state.device.clients.is_empty() {
160 return Err(Error {
161 code: "device_auth_disabled",
162 status: StatusCode::NOT_FOUND,
163 });
164 }
165 state.security.as_ref().ok_or(Error {
166 code: "temporarily_unavailable",
167 status: StatusCode::SERVICE_UNAVAILABLE,
168 })
169}
170fn client<'a>(state: &'a AppState, id: &str) -> Result<&'a str, Error> {
171 state
172 .device
173 .clients
174 .get(id)
175 .map(String::as_str)
176 .ok_or(Error::oauth("invalid_client"))
177}
178pub(crate) fn secret(prefix: &str) -> String {
179 format!("{prefix}{}", crate::connect::random())
180}
181pub(crate) fn hash(value: &str) -> String {
182 crate::signature::sha256_hex(value.as_bytes())
183}
184pub(crate) fn valid_secret(value: &str, prefix: &str) -> bool {
185 value.strip_prefix(prefix).is_some_and(|s| {
186 s.len() == 43
187 && s.bytes()
188 .all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_')
189 })
190}
191fn user_code(value: &str) -> Result<String, Error> {
192 if value.len() > 11 {
193 return Err(Error::oauth("invalid_grant"));
194 }
195 let normalized = value.replace('-', "").to_ascii_uppercase();
196 if normalized.len() != 10
197 || !normalized
198 .bytes()
199 .all(|b| b"ABCDEFGHJKLMNPQRSTUVWXYZ23456789".contains(&b))
200 {
201 return Err(Error::oauth("invalid_grant"));
202 }
203 Ok(normalized)
204}
205fn scopes(value: Option<&str>) -> Result<String, Error> {
206 let mut scopes: Vec<&str> = value
207 .unwrap_or("connections:read proxy:read")
208 .split_ascii_whitespace()
209 .collect();
210 if scopes.is_empty()
211 || scopes.iter().any(|s| {
212 ![
213 DISCOVERY_SCOPE,
214 READ_SCOPE,
215 WRITE_SCOPE,
216 CONNECTION_MANAGE_SCOPE,
217 SESSION_MANAGE_SCOPE,
218 NOTIFICATION_SCOPE,
219 ]
220 .contains(s)
221 })
222 {
223 return Err(Error::oauth("invalid_scope"));
224 }
225 scopes.sort_unstable();
226 scopes.dedup();
227 Ok(scopes.join(" "))
228}
229fn form(headers: &HeaderMap, body: &[u8]) -> Result<BTreeMap<String, String>, Error> {
230 if body.len() > 8192
231 || !headers
232 .get(header::CONTENT_TYPE)
233 .and_then(|v| v.to_str().ok())
234 .is_some_and(|s| s.split(';').next() == Some("application/x-www-form-urlencoded"))
235 {
236 return Err(Error::oauth("invalid_request"));
237 }
238 let mut fields = BTreeMap::new();
239 for (k, v) in url::form_urlencoded::parse(body) {
240 if fields.insert(k.into_owned(), v.into_owned()).is_some() {
241 return Err(Error::oauth("invalid_request"));
242 }
243 }
244 Ok(fields)
245}
246fn field<'a>(fields: &'a BTreeMap<String, String>, name: &str) -> Result<&'a str, Error> {
247 fields
248 .get(name)
249 .map(String::as_str)
250 .ok_or(Error::oauth("invalid_request"))
251}
252async fn limit(
253 state: &AppState,
254 security: &crate::security::Security,
255 headers: &HeaderMap,
256 peer: Option<SocketAddr>,
257 action: &str,
258 count: u32,
259) -> Result<(), Error> {
260 let network = crate::client_addr::client_network(state.trust_forwarded_for, headers, peer);
261 let bucket = security.key_check_bucket(&format!("device:{action}"), &network);
262 if security
263 .take_key_check_allowance(&bucket, count, Duration::from_secs(60))
264 .await?
265 .is_some()
266 {
267 return Err(Error::limited());
268 }
269 Ok(())
270}
271
272pub(crate) fn router() -> Router<AppState> {
273 Router::new()
274 .route("/.well-known/oauth-authorization-server", get(discovery))
275 .route("/oauth/device/code", post(authorize))
276 .route("/oauth/device/token", post(token))
277 .route("/oauth/device/revoke", post(revoke))
278 .route("/device", get(page))
279 .route("/device/approval.mjs", get(approval_module))
280 .route("/device/challenge", post(challenge))
281 .route("/device/approve", post(approve))
282 .route("/device/sessions", get(sessions))
283 .route("/device/sessions/:session_id", delete(revoke_session))
284 .layer(DefaultBodyLimit::max(8192))
285}
286async fn discovery(State(state): State<AppState>) -> Response {
287 if let Err(e) = enabled(&state) {
288 return e.into_response();
289 }
290 let base = &state.base_url;
291 protected(Json(
292 json!({"issuer":base,"device_authorization_endpoint":format!("{base}/oauth/device/code"),"token_endpoint":format!("{base}/oauth/device/token"),"revocation_endpoint":format!("{base}/oauth/device/revoke"),"grant_types_supported":[DEVICE_GRANT,"refresh_token"],"token_endpoint_auth_methods_supported":["none"],"revocation_endpoint_auth_methods_supported":["none"],"scopes_supported":[DISCOVERY_SCOPE,READ_SCOPE,WRITE_SCOPE,CONNECTION_MANAGE_SCOPE,SESSION_MANAGE_SCOPE,NOTIFICATION_SCOPE],"device_approval_challenge_endpoint":format!("{base}/device/challenge"),"device_approval_endpoint":format!("{base}/device/approve")}),
293 ))
294}
295async fn authorize(
296 State(state): State<AppState>,
297 peer: Option<ConnectInfo<SocketAddr>>,
298 headers: HeaderMap,
299 body: Bytes,
300) -> Response {
301 let result = async {
302 let security=enabled(&state)?;
303 limit(&state,security,&headers,peer.map(|p|p.0),"code",20).await?;
304 let fields=form(&headers,&body)?;
305 let id=field(&fields,"client_id")?;client(&state,id)?;
306 let scope=scopes(fields.get("scope").map(String::as_str))?;
307 let (device,code)=store::create(security,id,&state.base_url,&scope).await?;
308 let verification=format!("{}/device",state.base_url);
309 let mut complete=url::Url::parse(&verification).map_err(|_|Error::oauth("invalid_request"))?;
310 complete.query_pairs_mut().append_pair("user_code",&code);
311 Ok::<_,Error>(protected(Json(json!({"device_code":device,"user_code":code,"verification_uri":verification,"verification_uri_complete":complete.as_str(),"expires_in":600,"interval":5}))))
312 }.await;
313 result.unwrap_or_else(IntoResponse::into_response)
314}
315async fn token(
316 State(state): State<AppState>,
317 peer: Option<ConnectInfo<SocketAddr>>,
318 headers: HeaderMap,
319 body: Bytes,
320) -> Response {
321 let result = async {
322 let security = enabled(&state)?;
323 limit(&state, security, &headers, peer.map(|p| p.0), "token", 120).await?;
324 let fields = form(&headers, &body)?;
325 let id = field(&fields, "client_id")?;
326 client(&state, id)?;
327 if fields.contains_key("client_secret") {
328 return Err(Error::oauth("invalid_client"));
329 }
330 let value = match field(&fields, "grant_type")? {
331 DEVICE_GRANT => {
332 let code = field(&fields, "device_code")?;
333 if !valid_secret(code, "lt_device_") {
334 return Err(Error::oauth("invalid_grant"));
335 }
336 store::poll(security, code, id, &state.base_url).await?
337 }
338 "refresh_token" => {
339 if fields.contains_key("scope") {
340 return Err(Error::oauth("invalid_scope"));
341 }
342 let refresh = field(&fields, "refresh_token")?;
343 if !valid_secret(refresh, "lt_refresh_") {
344 return Err(Error::oauth("invalid_grant"));
345 }
346 store::refresh(security, refresh, id, &state.base_url).await?
347 }
348 _ => return Err(Error::oauth("unsupported_grant_type")),
349 };
350 Ok::<_, Error>(protected(Json(value)))
351 }
352 .await;
353 result.unwrap_or_else(IntoResponse::into_response)
354}
355async fn revoke(
356 State(state): State<AppState>,
357 peer: Option<ConnectInfo<SocketAddr>>,
358 headers: HeaderMap,
359 body: Bytes,
360) -> Response {
361 let result = async {
362 let security = enabled(&state)?;
363 limit(&state, security, &headers, peer.map(|p| p.0), "revoke", 60).await?;
364 let fields = form(&headers, &body)?;
365 let id = field(&fields, "client_id")?;
366 client(&state, id)?;
367 let token = field(&fields, "token")?;
368 if valid_secret(token, "lt_access_") || valid_secret(token, "lt_refresh_") {
369 store::revoke(security, token, id, &state.base_url).await?;
370 }
371 Ok::<_, Error>(protected(StatusCode::OK))
372 }
373 .await;
374 result.unwrap_or_else(IntoResponse::into_response)
375}
376
377#[derive(Deserialize)]
378#[serde(deny_unknown_fields)]
379struct Code {
380 user_code: String,
381}
382#[derive(Deserialize)]
383#[serde(deny_unknown_fields)]
384struct Approval {
385 challenge: String,
386 approve: bool,
387 connections: Vec<String>,
388}
389async fn owner(
390 state: &AppState,
391 method: &Method,
392 uri: &axum::http::Uri,
393 headers: &HeaderMap,
394 body: &[u8],
395) -> Result<crate::AgentId, ApiError> {
396 if headers.contains_key(header::AUTHORIZATION) {
397 return Err(ApiError::UnsupportedAuthorization);
398 }
399 let security = state.security.as_ref().ok_or(ApiError::Unavailable)?;
400 let owner = crate::signature::authenticate(state, security, method, uri, headers, body).await?;
401 crate::check_access(state, &owner).await?;
402 Ok(owner)
403}
404async fn owner_limit(state: &AppState, owner: &crate::AgentId) -> Result<(), Error> {
405 let security = enabled(state)?;
406 let bucket = security.key_check_bucket("device:owner", owner.as_str());
407 if security
408 .take_key_check_allowance(&bucket, 20, Duration::from_secs(60))
409 .await?
410 .is_some()
411 {
412 return Err(Error::limited());
413 }
414 Ok(())
415}
416async fn challenge(
417 State(state): State<AppState>,
418 peer: Option<ConnectInfo<SocketAddr>>,
419 method: Method,
420 OriginalUri(uri): OriginalUri,
421 headers: HeaderMap,
422 body: Bytes,
423) -> Response {
424 let result = async {
425 let security = enabled(&state).map_err(IntoResponse::into_response)?;
426 limit(
427 &state,
428 security,
429 &headers,
430 peer.map(|p| p.0),
431 "approval",
432 30,
433 )
434 .await
435 .map_err(IntoResponse::into_response)?;
436 let owner = owner(&state, &method, &uri, &headers, &body)
437 .await
438 .map_err(IntoResponse::into_response)?;
439 owner_limit(&state, &owner)
440 .await
441 .map_err(IntoResponse::into_response)?;
442 let request: Code = serde_json::from_slice(&body)
443 .map_err(|_| Error::oauth("invalid_request").into_response())?;
444 let code = user_code(&request.user_code).map_err(IntoResponse::into_response)?;
445 let mut value = store::challenge(security, &code, owner.as_str(), &state.base_url)
446 .await
447 .map_err(IntoResponse::into_response)?;
448 let (connections, _) = security
449 .list_for_owner(owner.as_str())
450 .await
451 .map_err(|_| ApiError::Unavailable.into_response())?;
452 value["client_name"] = json!(client(
453 &state,
454 value["client_id"].as_str().unwrap_or_default()
455 )
456 .map_err(IntoResponse::into_response)?);
457 value["owner"] = json!(owner.as_str());
458 value["connections"] = json!(connections
459 .into_iter()
460 .map(|c| json!({"connection_id":c.connection_id,"platform":c.platform,"label":c.label}))
461 .collect::<Vec<_>>());
462 Ok::<_, Response>(protected(Json(value)))
463 }
464 .await;
465 result.unwrap_or_else(|r| r)
466}
467async fn approve(
468 State(state): State<AppState>,
469 method: Method,
470 OriginalUri(uri): OriginalUri,
471 headers: HeaderMap,
472 body: Bytes,
473) -> Response {
474 let result = async {
475 let security = enabled(&state).map_err(IntoResponse::into_response)?;
476 let owner = owner(&state, &method, &uri, &headers, &body)
477 .await
478 .map_err(IntoResponse::into_response)?;
479 owner_limit(&state, &owner)
480 .await
481 .map_err(IntoResponse::into_response)?;
482 let request: Approval = serde_json::from_slice(&body)
483 .map_err(|_| Error::oauth("invalid_request").into_response())?;
484 if !valid_secret(&request.challenge, "lt_approval_")
485 || request.connections.len() > 20
486 || request.connections.iter().any(|c| c.len() != 43)
487 {
488 return Err(Error::oauth("invalid_request").into_response());
489 }
490 store::approve(
491 security,
492 &request.challenge,
493 owner.as_str(),
494 &state.base_url,
495 &request.connections,
496 request.approve,
497 )
498 .await
499 .map_err(IntoResponse::into_response)?;
500 Ok::<_, Response>(protected(Json(json!({"approved":request.approve}))))
501 }
502 .await;
503 result.unwrap_or_else(|r| r)
504}
505async fn management_owner(
508 state: &AppState,
509 method: &Method,
510 uri: &axum::http::Uri,
511 headers: &HeaderMap,
512 body: &[u8],
513) -> Result<crate::agent_id::AgentId, ApiError> {
514 if let Some(token) = bearer(headers)? {
515 let principal = principal(state, token).await?;
516 if !principal
517 .scope
518 .split_ascii_whitespace()
519 .any(|s| s == SESSION_MANAGE_SCOPE)
520 {
521 return Err(ApiError::TokenScope);
522 }
523 return Ok(principal.owner);
524 }
525 owner(state, method, uri, headers, body).await
526}
527
528async fn sessions(
529 State(state): State<AppState>,
530 method: Method,
531 OriginalUri(uri): OriginalUri,
532 headers: HeaderMap,
533 body: Bytes,
534) -> Response {
535 let result = async {
536 let security = enabled(&state).map_err(IntoResponse::into_response)?;
537 let owner = management_owner(&state, &method, &uri, &headers, &body)
538 .await
539 .map_err(IntoResponse::into_response)?;
540 Ok::<_, Response>(protected(Json(
541 store::sessions(security, owner.as_str(), &state.base_url)
542 .await
543 .map_err(IntoResponse::into_response)?,
544 )))
545 }
546 .await;
547 result.unwrap_or_else(|r| r)
548}
549async fn revoke_session(
550 State(state): State<AppState>,
551 Path(session): Path<String>,
552 method: Method,
553 OriginalUri(uri): OriginalUri,
554 headers: HeaderMap,
555 body: Bytes,
556) -> Response {
557 let result = async {
558 let security = enabled(&state).map_err(IntoResponse::into_response)?;
559 let owner = management_owner(&state, &method, &uri, &headers, &body)
560 .await
561 .map_err(IntoResponse::into_response)?;
562 store::revoke_owned(security, owner.as_str(), &session, &state.base_url)
563 .await
564 .map_err(IntoResponse::into_response)?;
565 Ok::<_, Response>(protected(StatusCode::NO_CONTENT))
566 }
567 .await;
568 result.unwrap_or_else(|r| r)
569}
570async fn page(
571 State(state): State<AppState>,
572 Query(query): Query<BTreeMap<String, String>>,
573) -> Response {
574 if let Err(e) = enabled(&state) {
575 return e.into_response();
576 }
577 let code = query
578 .get("user_code")
579 .and_then(|v| user_code(v).ok())
580 .unwrap_or_default();
581 let mut url =
582 url::Url::parse(state.device.approval_url.as_deref().unwrap_or_default()).unwrap();
583 if !code.is_empty() {
584 url.query_pairs_mut().append_pair("user_code", &code);
585 }
586 let escaped = url
588 .as_str()
589 .replace('&', "&")
590 .replace('"', """)
591 .replace('<', "<");
592 let mut response=protected(Html(format!("<!doctype html><meta charset=utf-8><title>Approve a CLI connection</title><h1>Approve a CLI connection</h1><p>Continue in your owner hub to authenticate as your existing Atomic owner, review the client, and select connections. Compare the code with the CLI you started. Approve only a login you initiated.</p><p>User code: <strong>{code}</strong></p><a href=\"{escaped}\">Continue to owner approval</a>")));
593 response.headers_mut().insert(
594 header::CONTENT_SECURITY_POLICY,
595 "default-src 'none'; base-uri 'none'; frame-ancestors 'none'"
596 .parse()
597 .unwrap(),
598 );
599 response
600}
601async fn approval_module() -> Response {
602 (
603 [
604 (header::CONTENT_TYPE, "text/javascript; charset=utf-8"),
605 (header::CACHE_CONTROL, "no-store"),
606 ],
607 include_str!("../../static/device-approval.mjs"),
608 )
609 .into_response()
610}
611
612pub(crate) fn bearer(headers: &HeaderMap) -> Result<Option<&str>, ApiError> {
615 if headers.get_all(header::AUTHORIZATION).iter().count() > 1 {
616 return Err(ApiError::UnsupportedAuthorization);
617 }
618 let Some(value) = headers.get(header::AUTHORIZATION) else {
619 return Ok(None);
620 };
621 let value = value
622 .to_str()
623 .map_err(|_| ApiError::UnsupportedAuthorization)?;
624 let Some((scheme, token)) = value.split_once(' ') else {
625 return Err(ApiError::UnsupportedAuthorization);
626 };
627 if !scheme.eq_ignore_ascii_case("bearer") {
628 return Ok(None);
629 }
630 if !valid_secret(token, "lt_access_") {
631 return Err(ApiError::UnsupportedAuthorization);
632 }
633 Ok(Some(token))
634}
635pub(crate) async fn principal(state: &AppState, token: &str) -> Result<store::Principal, ApiError> {
636 let security = enabled(state).map_err(|e| {
637 if e.status == StatusCode::SERVICE_UNAVAILABLE {
638 ApiError::Unavailable
639 } else {
640 ApiError::InvalidToken
641 }
642 })?;
643 let principal = store::authenticate(security, token, &state.base_url)
644 .await
645 .map_err(|e| {
646 if e.status == StatusCode::SERVICE_UNAVAILABLE {
647 ApiError::Unavailable
648 } else {
649 ApiError::InvalidToken
650 }
651 })?;
652 if !state.device.clients.contains_key(&principal.client_id) {
653 return Err(ApiError::InvalidToken);
654 }
655 crate::check_access(state, &principal.owner).await?;
656 Ok(principal)
657}
658
659pub(crate) async fn connections(state: &AppState, token: &str) -> Result<Response, ApiError> {
660 let principal = principal(state, token).await?;
661 if !principal
662 .scope
663 .split_ascii_whitespace()
664 .any(|s| s == DISCOVERY_SCOPE || s == CONNECTION_MANAGE_SCOPE)
665 {
666 return Err(ApiError::TokenScope);
667 }
668 let security = state.security.as_ref().ok_or(ApiError::Unavailable)?;
669 let (connections, _) = security
670 .list_for_owner(principal.owner.as_str())
671 .await
672 .map_err(|_| ApiError::Unavailable)?;
673 let manages = principal
674 .scope
675 .split_ascii_whitespace()
676 .any(|s| s == CONNECTION_MANAGE_SCOPE);
677 let connections:Vec<_>=connections.into_iter().filter(|c|principal.connections.contains(&c.connection_id)).map(|c| if manages { json!(c) } else { json!({"connection_id":c.connection_id,"platform":c.platform,"owner":c.owner,"label":c.label}) }).collect();
678 Ok(protected(Json(
679 json!({"owner":principal.owner.as_str(),"client_id":principal.client_id,"session_id":principal.session_id,"scope":principal.scope,"connections":connections}),
680 )))
681}