Skip to content
Python
13.6 KB
Raw Blame
//! Private management routing. Only the original cluster's TLS endpoint is
//! forwarded; this proxy is not a general-purpose internet or credential proxy.
use super::*;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

pub(in super::super) struct Bridge {
    child: tokio::process::Child,
    proxy: tokio::task::JoinHandle<()>,
}
impl Drop for Bridge {
    fn drop(&mut self) {
        self.proxy.abort();
        let _ = self.child.start_kill();
    }
}
fn endpoint(kube: &Value) -> Result<String> {
    let clusters = kube["clusters"]
        .as_array()
        .filter(|a| a.len() == 1)
        .context("Expected one original cluster")?;
    let c = &clusters[0]["cluster"];
    ensure!(
        c["insecure-skip-tls-verify"] != true
            && c["certificate-authority-data"]
                .as_str()
                .is_some_and(|s| !s.is_empty()),
        "Original cluster CA required"
    );
    let u = reqwest::Url::parse(c["server"].as_str().context("Missing cluster endpoint")?)?;
    ensure!(
        u.scheme() == "https"
            && u.port_or_known_default() == Some(443)
            && u.username().is_empty()
            && u.password().is_none()
            && u.path() == "/"
            && u.query().is_none(),
        "Invalid private management endpoint"
    );
    Ok(u.host_str().context("Endpoint host missing")?.into())
}
async fn tunnel(mut incoming: tokio::net::TcpStream, host: &str, port: u16) -> Result<()> {
    let mut header = Vec::new();
    loop {
        let mut b = [0];
        incoming.read_exact(&mut b).await?;
        header.push(b[0]);
        ensure!(header.len() <= 8192, "Proxy header too large");
        if header.ends_with(b"\r\n\r\n") {
            break;
        }
    }
    let line = std::str::from_utf8(&header)?
        .split("\r\n")
        .next()
        .unwrap_or("");
    ensure!(
        line == format!("CONNECT {host}:443 HTTP/1.1")
            || line == format!("CONNECT {host}:443 HTTP/1.0"),
        "Proxy destination is outside the reviewed cluster"
    );
    let mut upstream =
        tokio::net::TcpStream::connect((std::net::Ipv4Addr::LOCALHOST, port)).await?;
    incoming
        .write_all(b"HTTP/1.1 200 Connection Established\r\n\r\n")
        .await?;
    tokio::io::copy_bidirectional(&mut incoming, &mut upstream).await?;
    Ok(())
}
impl Native<'_> {
    async fn probe(&self, kubeconfig: &Path) -> Result<Value> {
        let raw = self
            .tool(
                "kubectl",
                vec![
                    "--kubeconfig".into(),
                    arg(kubeconfig)?,
                    "--request-timeout=10s".into(),
                    "get".into(),
                    "namespace".into(),
                    "kube-system".into(),
                    "-o".into(),
                    "json".into(),
                ],
                None,
            )
            .await?;
        let v: Value = serde_json::from_slice(&raw)?;
        ensure!(
            v["metadata"]["name"] == "kube-system" && v["metadata"]["uid"].is_string(),
            "Cluster identity probe failed"
        );
        Ok(v)
    }
    async fn session_json(&self, args: Vec<String>) -> Result<Value> {
        let mut a = args;
        a.extend([
            "--profile".into(),
            self.aws_profile()?,
            "--region".into(),
            self.review.config.cloud.region().into(),
            "--output".into(),
            "json".into(),
            "--no-cli-pager".into(),
        ]);
        serde_json::from_slice(&self.tool("aws", a, None).await?).context("Invalid SSM observation")
    }
    async fn retire_session(&self, path: &Path) -> Result<()> {
        if !path.exists() {
            return Ok(());
        }
        let mut r = self.document(path)?;
        ensure!(
            r["deploymentId"] == self.review.deployment_id,
            "SSM receipt identity mismatch"
        );
        if r["phase"] == "terminated" {
            return Ok(());
        }
        let mut found = vec![];
        for state in ["Active", "History"] {
            let v = self
                .session_json(strings(&["ssm", "describe-sessions", "--state", state]))
                .await?;
            for s in v["Sessions"]
                .as_array()
                .context("SSM session inventory missing")?
            {
                if s["Reason"] == r["reason"] && s["Target"] == r["target"] {
                    found.push(s.clone());
                }
            }
        }
        ensure!(found.len()==1,"Original SSM session is not uniquely observed. Retain receipt; do not start another session.");
        let s = &found[0];
        let id = text(s, "SessionId")?;
        ensure!(
            r.get("sessionId").is_none_or(|v| v == &id),
            "SSM session changed"
        );
        r["sessionId"] = json!(id);
        write_private(path, &r)?;
        if !["Terminated", "Failed"].contains(&s["Status"].as_str().unwrap_or("")) {
            self.session_json(strings(&["ssm", "terminate-session", "--session-id", &id]))
                .await?;
        }
        r["phase"] = json!("terminated");
        write_private(path, &r)?;
        Ok(())
    }
    pub(in super::super) async fn close_access(&self) -> Result<()> {
        self.bridge.borrow_mut().take();
        if self.provider() == "aws" {
            self.retire_session(&self.root.join("ssm-session.json"))
                .await?;
        }
        Ok(())
    }
    pub(super) async fn connect_private(&self, kubeconfig: &Path) -> Result<()> {
        let mut kube = self.document(kubeconfig)?;
        let host = endpoint(&kube)?;
        if self.bridge.borrow().is_some()
            || kube["clusters"][0]["cluster"]["proxy-url"].is_null()
                && self.probe(kubeconfig).await.is_ok()
        {
            let value = self.probe(kubeconfig).await?;
            return self.access_receipt(kubeconfig, &value);
        }
        let (plan, _) = self.plan()?;
        let has_bridge = if self.provider() == "aws" {
            plan.infrastructure
                .as_ref()
                .unwrap()
                .operator_access
                .is_some()
        } else {
            plan.azure_infrastructure
                .as_ref()
                .unwrap()
                .management_access
                .is_some()
        };
        ensure!(has_bridge,"Private management API unreachable. Connect the approved private network, or configure the operator bridge before creating a new deployment. Original resources retained.");
        let config_path = self.root.join("private-route.json");
        let route = if config_path.exists() {
            self.document(&config_path)?
        } else {
            let port = std::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))?
                .local_addr()?
                .port();
            let v = json!({"deploymentId":self.review.deployment_id,"host":host,"proxyPort":port});
            write_private(&config_path, &v)?;
            v
        };
        ensure!(
            route["host"] == host && route["deploymentId"] == self.review.deployment_id,
            "Private route target changed"
        );
        let proxy_port = u16::try_from(route["proxyPort"].as_u64().context("Proxy port missing")?)?;
        let listener = tokio::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, proxy_port))
            .await
            .context(
                "Original loopback proxy port is occupied; do not alter the pinned kubeconfig",
            )?;
        let raw_port = std::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))?
            .local_addr()?
            .port();
        let (program, args) = if self.provider() == "azure" {
            let m = self.azure_material().await?;
            let ip = text(&m, "managementIp")?;
            ip.parse::<std::net::Ipv4Addr>()
                .context("Invalid owned management IP")?;
            let mut a = vec![
                "-N".into(),
                "-T".into(),
                "-o".into(),
                "BatchMode=yes".into(),
                "-o".into(),
                "ExitOnForwardFailure=yes".into(),
                "-o".into(),
                "ForwardAgent=no".into(),
                "-o".into(),
                "StrictHostKeyChecking=accept-new".into(),
                "-o".into(),
                format!(
                    "UserKnownHostsFile={}",
                    self.root.join("ssh-known-hosts").display()
                ),
                "-L".into(),
                format!("127.0.0.1:{raw_port}:{host}:443"),
            ];
            if let Some(key) = self
                .review
                .config
                .advanced
                .azure
                .as_ref()
                .and_then(|a| a.ssh_private_key_file.as_ref())
            {
                a.extend(["-i".into(), arg(key)?]);
            }
            a.push(format!("owsadmin@{ip}"));
            ("ssh", a)
        } else {
            let path = self.root.join("ssm-session.json");
            self.retire_session(&path).await?;
            if path.exists() {
                fs::rename(
                    &path,
                    self.root.join(format!(
                        "ssm-session-{}.json",
                        uuid::Uuid::new_v4().simple()
                    )),
                )?;
            }
            let status = self.cloud_status().await?;
            let target = text(
                &status["observed"]["infra"]["outputs"],
                "OperatorInstanceId",
            )?;
            ensure!(
                target.starts_with("i-") && target[2..].bytes().all(|b| b.is_ascii_hexdigit()),
                "Invalid original operator instance"
            );
            let reason = format!("ows-{}", uuid::Uuid::new_v4().simple());
            write_private(
                &path,
                &json!({"deploymentId":self.review.deployment_id,"target":target,"reason":reason,"phase":"intent"}),
            )?;
            (
                "aws",
                vec![
                    "ssm".into(),
                    "start-session".into(),
                    "--target".into(),
                    target,
                    "--document-name".into(),
                    "AWS-StartPortForwardingSessionToRemoteHost".into(),
                    "--reason".into(),
                    reason,
                    "--parameters".into(),
                    serde_json::to_string(
                        &json!({"host":[host],"portNumber":["443"],"localPortNumber":[raw_port.to_string()]}),
                    )?,
                    "--profile".into(),
                    self.aws_profile()?,
                    "--region".into(),
                    self.review.config.cloud.region().into(),
                ],
            )
        };
        let mut command = tokio::process::Command::new(program);
        command
            .args(args)
            .envs(self.environment()?)
            .stdin(std::process::Stdio::null())
            .stdout(std::process::Stdio::null())
            .stderr(std::process::Stdio::null())
            .kill_on_drop(true);
        let mut child = command.spawn().context("Start private management bridge")?;
        let mut ready = false;
        for _ in 0..30 {
            ensure!(child.try_wait()?.is_none(),"Private bridge exited; check CLI login, bridge permissions and SSH key/plugin prerequisites");
            if tokio::net::TcpStream::connect((std::net::Ipv4Addr::LOCALHOST, raw_port))
                .await
                .is_ok()
            {
                ready = true;
                break;
            }
            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
        }
        ensure!(ready, "Private management bridge did not become ready");
        let proxy = tokio::spawn(async move {
            while let Ok((socket, _)) = listener.accept().await {
                let host = host.clone();
                tokio::spawn(async move {
                    let _ = tunnel(socket, &host, raw_port).await;
                });
            }
        });
        *self.bridge.borrow_mut() = Some(Bridge { child, proxy });
        let proxy_url = format!("http://127.0.0.1:{proxy_port}");
        let current = &kube["clusters"][0]["cluster"]["proxy-url"];
        ensure!(
            current.is_null() || current == &proxy_url,
            "Unexpected kubeconfig proxy"
        );
        if current.is_null() {
            kube["clusters"][0]["cluster"]["proxy-url"] = json!(proxy_url);
            write_private(kubeconfig, &kube)?;
        }
        let value = self.probe(kubeconfig).await?;
        self.access_receipt(kubeconfig, &value)
    }
    fn access_receipt(&self, kubeconfig: &Path, value: &Value) -> Result<()> {
        let path = self.root.join("private-access.json");
        if path.exists() {
            ensure!(
                self.document(&path)?["clusterUid"] == value["metadata"]["uid"],
                "Original cluster was replaced"
            );
        }
        write_private(
            &path,
            &json!({"kubeconfig":kubeconfig,"clusterUid":value["metadata"]["uid"],"tlsVerified":true}),
        )
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn private_endpoint_requires_original_ca_and_https() {
        let mut v = json!({"clusters":[{"cluster":{"server":"https://original.internal","certificate-authority-data":"CA"}}]});
        assert_eq!(endpoint(&v).unwrap(), "original.internal");
        v["clusters"][0]["cluster"]["insecure-skip-tls-verify"] = json!(true);
        assert!(endpoint(&v).is_err());
        v["clusters"][0]["cluster"]["insecure-skip-tls-verify"] = json!(false);
        v["clusters"][0]["cluster"]["server"] = json!("https://[email protected]");
        assert!(endpoint(&v).is_err());
    }
}