alien_client_core/
runtime_proofs.rs1use 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
15pub 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
58pub 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}