85 lines
3.9 KiB
Rust
85 lines
3.9 KiB
Rust
//! 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<String> {
|
|
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<String>) -> Result<PathBuf> {
|
|
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)
|
|
}
|