//! Guest kernel: Kata Containers release kernel, downloaded and sha256-verified. use crate::oci; use anyhow::{Context, Result, anyhow, bail}; use serde_json::{Value, json}; use sha2::{Digest, Sha256}; use std::fs; use std::path::{Path, PathBuf}; use std::process::{Command, Stdio}; const KATA_REPO: &str = "kata-containers/kata-containers"; /// Where Kata's release tarball keeps the guest kernel (VM-ready arm64 Image, all virtio built in). const KATA_KERNEL: &str = "opt/kata/share/kata-containers/vmlinux.container"; pub fn installed_kernel(h: &Path) -> Option { let v: Value = serde_json::from_slice(&fs::read(h.join("kernel/source.json")).ok()?).ok()?; v["version"].as_str().map(String::from) } /// Guest kernel from the latest (or pinned) Kata Containers release. Never re-downloads implicitly: /// runs use whatever is installed; `wsbx kernel --update` moves to a newer release. pub fn kernel(h: &Path, update: bool, version: Option) -> Result { let k = h.join("kernel/vmlinux"); let installed = installed_kernel(h); let pin = version.or_else(|| std::env::var("WSBX_KATA_VERSION").ok()); if k.exists() && !update && (pin.is_none() || pin == installed) { return Ok(k); } if let Some(v) = &pin && (v.is_empty() || !v.chars().all(|c| c.is_ascii_alphanumeric() || "._-".contains(c))) { bail!("invalid Kata version {v:?}"); } let api = match &pin { Some(v) => format!("https://api.github.com/repos/{KATA_REPO}/releases/tags/{v}"), None => format!("https://api.github.com/repos/{KATA_REPO}/releases/latest"), }; let rel: Value = serde_json::from_reader(ureq::get(&api).call().with_context(|| format!("GET {api}"))?.into_reader())?; let tag = rel["tag_name"].as_str().ok_or_else(|| anyhow!("no tag in {api}"))?; if k.exists() && installed.as_deref() == Some(tag) { eprintln!("wsbx: kernel already at Kata {tag}"); return Ok(k); } let asset = rel["assets"] .as_array() .into_iter() .flatten() .find(|a| a["name"].as_str().is_some_and(|n| n.starts_with("kata-static-") && n.ends_with("-arm64.tar.zst"))) .ok_or_else(|| anyhow!("Kata {tag} has no kata-static arm64 asset"))?; let url = asset["browser_download_url"].as_str().ok_or_else(|| anyhow!("asset without url"))?; eprintln!( "wsbx: fetching kernel from Kata Containers {tag} ({} MB, streamed; only the kernel is kept)", asset["size"].as_u64().unwrap_or(0) / 1_000_000 ); let tmp = h.join("kernel.tmp"); let _ = fs::remove_dir_all(&tmp); fs::create_dir_all(&tmp)?; // Stream download -> sha256 + bsdtar (zstd); nothing but the kernel touches the disk. let mut tar = Command::new("tar") .args(["-x", "--zstd", "-f", "-", "-C"]) .arg(&tmp) .arg(format!("{}*", KATA_KERNEL.trim_end_matches(".container"))) .stdin(Stdio::piped()) .spawn()?; let mut w = oci::HashWriter(tar.stdin.take().unwrap(), Sha256::new()); std::io::copy(&mut ureq::get(url).call()?.into_reader(), &mut w)?; let oci::HashWriter(stdin, hasher) = w; drop(stdin); if !tar.wait()?.success() { bail!("kernel extraction failed"); } let got = format!("sha256:{}", hex::encode(hasher.finalize())); match asset["digest"].as_str() { Some(want) if want != got => bail!("kernel download checksum mismatch: want {want}, got {got}"), Some(_) => {} None => eprintln!("wsbx: warning: release publishes no digest; download not verified"), } let src = fs::canonicalize(tmp.join(KATA_KERNEL))?; fs::create_dir_all(k.parent().unwrap())?; fs::rename(src, &k)?; let _ = fs::remove_file(h.join("kernel/SOURCE")); // pre-source.json format fs::write(h.join("kernel/source.json"), serde_json::to_vec_pretty(&json!({"version": tag, "url": url, "sha256": got}))?)?; fs::remove_dir_all(&tmp)?; Ok(k) }