Skip to main content

alien_client_core/
runtime_proofs.rs

1//! Local metadata and protected parent-session proof sources.
2
3use std::{path::PathBuf, time::Duration};
4
5use alien_error::AlienError;
6use async_trait::async_trait;
7use reqwest::{redirect::Policy, Client};
8use serde_json::{json, Value};
9#[cfg(unix)]
10use std::os::unix::fs::PermissionsExt;
11use tokio::io::AsyncReadExt;
12
13use crate::{runtime_credentials::RuntimeProofProvider, ErrorData, Result};
14
15/// GCP metadata identity token. The endpoint is fixed by the runtime, never
16/// chosen by an exchange caller.
17pub struct GcpMetadataProof;
18
19#[async_trait]
20impl RuntimeProofProvider for GcpMetadataProof {
21    async fn proof(&self, audience: &str) -> Result<Value> {
22        let client = Client::builder()
23            .redirect(Policy::none())
24            .no_proxy()
25            .timeout(Duration::from_secs(5))
26            .build()
27            .map_err(|_| failed("cannot initialize metadata transport"))?;
28        let mut response = client
29            .get("http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity")
30            .header("Metadata-Flavor", "Google")
31            .query(&[("audience", audience), ("format", "full")])
32            .send()
33            .await
34            .map_err(|_| failed("metadata request failed"))?;
35        if !response.status().is_success() {
36            return Err(failed("metadata identity request refused"));
37        }
38        let mut body = Vec::new();
39        while let Some(chunk) = response
40            .chunk()
41            .await
42            .map_err(|_| failed("metadata response failed"))?
43        {
44            if body.len() + chunk.len() > 32 * 1024 {
45                return Err(failed("metadata response exceeds limit"));
46            }
47            body.extend_from_slice(&chunk);
48        }
49        let token =
50            String::from_utf8(body).map_err(|_| failed("invalid metadata identity response"))?;
51        if token.trim().is_empty() {
52            return Err(failed("empty metadata identity response"));
53        }
54        Ok(json!({"type":"gcp", "idToken": token}))
55    }
56}
57
58/// Reads a parent session on every exchange. The session issuer owns renewal;
59/// this source cannot extend the parent's lifetime.
60pub struct SessionFileProof(pub PathBuf);
61
62#[async_trait]
63impl RuntimeProofProvider for SessionFileProof {
64    async fn proof(&self, _audience: &str) -> Result<Value> {
65        let file = tokio::fs::File::open(&self.0)
66            .await
67            .map_err(|_| failed("cannot open parent session file"))?;
68        let metadata = file
69            .metadata()
70            .await
71            .map_err(|_| failed("cannot inspect parent session file"))?;
72        if !metadata.is_file() || metadata.len() > 16 * 1024 {
73            return Err(failed("invalid parent session file"));
74        }
75        #[cfg(unix)]
76        {
77            if metadata.permissions().mode() & 0o077 != 0 {
78                return Err(failed("parent session file must be private"));
79            }
80        }
81        let mut token = String::new();
82        file.take(16 * 1024 + 1)
83            .read_to_string(&mut token)
84            .await
85            .map_err(|_| failed("cannot read parent session file"))?;
86        if token.len() > 16 * 1024 {
87            return Err(failed("parent session exceeds limit"));
88        }
89        let token = token.trim();
90        if token.is_empty() || token.starts_with("ax_cap_") {
91            return Err(failed("invalid parent session"));
92        }
93        Ok(json!({"type":"session", "token":token}))
94    }
95}
96
97fn failed(message: &str) -> crate::Error {
98    AlienError::new(ErrorData::AuthenticationError {
99        message: message.into(),
100    })
101}