Files
marqdo/src/host/archive.rs
T

200 lines
7.6 KiB
Rust

//! Optional ZIP tasks with preflight, expansion limits and no path traversal.
use crate::{
host::{HostContext, HostFn},
value::Value,
};
use std::collections::HashMap;
#[cfg(feature = "net-host")]
use std::{
collections::HashSet,
fs,
io::{Read, Write},
path::Path,
};
type Args = HashMap<String, Value>;
#[cfg(feature = "net-host")]
fn arg<'a>(b: &'a Args, k: &str) -> Result<&'a Value, String> {
b.get(k).ok_or_else(|| format!("missing {k}"))
}
pub(super) fn call(ctx: &mut HostContext, id: HostFn, b: &Args) -> Result<Value, String> {
#[cfg(feature = "net-host")]
let answer = operate(ctx, id, b);
#[cfg(not(feature = "net-host"))]
let answer = {
let _ = (ctx, id, b);
Err("ZIP unavailable: build with net-host (native default)".into())
};
Ok(super::result::capture(
if id == HostFn::ZipPack {
"archive.pack"
} else {
"archive.unpack"
},
answer,
))
}
#[cfg(feature = "net-host")]
fn operate(ctx: &mut HostContext, id: HostFn, b: &Args) -> Result<Value, String> {
if !ctx.allow_fs_write() {
return Err("filesystem write denied by host policy".into());
}
if ctx.sandbox_session.is_some() {
return Err("ZIP unavailable in CoW sandbox".into());
}
let src = ctx.resolve_path(super::as_text(arg(b, "src")?, "src")?)?;
let dest = ctx.resolve_path(super::as_text(arg(b, "dest")?, "dest")?)?;
let max = match arg(b, "max_bytes")? {
Value::Int(n) if *n > 0 && *n <= 1024 * 1024 * 1024 => *n as u64,
_ => return Err("max_bytes must be 1..1073741824".into()),
};
if dest.exists() {
return Err("destination conflict: ZIP output must not exist".into());
}
if id == HostFn::ZipPack {
if !src.is_dir() || dest.starts_with(&src) {
return Err("pack src must be directory and dest outside src".into());
}
let mut args = HashMap::new();
args.insert("path".into(), Value::Text(src.to_string_lossy().into()));
args.insert("pattern".into(), Value::Text("**".into()));
args.insert("exclude".into(), Value::None);
args.insert("max_depth".into(), Value::Int(256));
args.insert("kind".into(), Value::Text("file".into()));
let Value::List(files) = super::fs_ops::call(ctx, HostFn::FsFind, &args)? else {
unreachable!()
};
let total = files.iter().try_fold(0u64, |n, name| {
let p = src.join(super::as_text(name, "name")?);
let size = fs::metadata(p).map_err(|e| e.to_string())?.len();
n.checked_add(size)
.ok_or_else(|| "archive size overflow".to_string())
})?;
if total > max {
return Err("archive source exceeds max_bytes".into());
}
let parent = dest.parent().ok_or("archive needs parent")?;
fs::create_dir_all(parent).map_err(|e| e.to_string())?;
let temp = parent.join(format!(".mq-zip-{}", random_name()?));
let file = fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&temp)
.map_err(|e| e.to_string())?;
let written = (|| {
let mut writer = zip::ZipWriter::new(file);
let mut buffer = [0u8; 65536];
let mut seen = 0u64;
for name in &files {
let name = super::as_text(name, "name")?;
writer
.start_file(
name,
zip::write::FileOptions::default()
.compression_method(zip::CompressionMethod::Deflated),
)
.map_err(|e| e.to_string())?;
let p = ctx.resolve_path(src.join(name).to_str().ok_or("non UTF-8 path")?)?;
let mut file = fs::File::open(p).map_err(|e| e.to_string())?;
loop {
let n = file.read(&mut buffer).map_err(|e| e.to_string())?;
if n == 0 {
break;
}
seen += n as u64;
if seen > max {
return Err("archive source grew past max_bytes".into());
}
writer.write_all(&buffer[..n]).map_err(|e| e.to_string())?;
}
}
writer
.finish()
.map_err(|e| e.to_string())?
.sync_all()
.map_err(|e| e.to_string())?;
// hard_link is an atomic no-clobber publish on the same filesystem.
fs::hard_link(&temp, &dest).map_err(|e| e.to_string())?;
Ok(Value::Int(files.len() as i64))
})();
let _ = fs::remove_file(&temp);
return written;
}
let file = fs::File::open(src).map_err(|e| e.to_string())?;
let mut zip = zip::ZipArchive::new(file).map_err(|e| e.to_string())?;
if zip.len() > 100000 {
return Err("archive exceeds 100000 entries".into());
}
let mut names = HashSet::new();
let mut total = 0u64;
for i in 0..zip.len() {
let entry = zip.by_index(i).map_err(|e| e.to_string())?;
let name = entry
.enclosed_name()
.ok_or("archive path escapes destination")?;
if entry.name().contains('\\') || name == Path::new("") || !names.insert(name.to_path_buf())
{
return Err("invalid or duplicate archive path".into());
}
if entry
.unix_mode()
.is_some_and(|mode| mode & 0o170000 == 0o120000)
{
return Err("archive symlinks unsupported".into());
}
total = total
.checked_add(entry.size())
.ok_or("archive size overflow")?;
if total > max {
return Err("archive expansion exceeds max_bytes".into());
}
}
fs::create_dir_all(dest.parent().ok_or("destination needs parent")?)
.map_err(|e| e.to_string())?;
fs::create_dir(&dest).map_err(|e| e.to_string())?;
let extracted = (|| {
let mut total = 0u64;
let mut buffer = [0u8; 65536];
for i in 0..zip.len() {
let mut entry = zip.by_index(i).map_err(|e| e.to_string())?;
let path = ctx.resolve_path(
dest.join(entry.enclosed_name().ok_or("invalid archive path")?)
.to_str()
.ok_or("non UTF-8 path")?,
)?;
if entry.is_dir() {
fs::create_dir_all(path).map_err(|e| e.to_string())?;
continue;
}
fs::create_dir_all(path.parent().ok_or("entry needs parent")?)
.map_err(|e| e.to_string())?;
let mut file = fs::OpenOptions::new()
.create_new(true)
.write(true)
.open(path)
.map_err(|e| e.to_string())?;
loop {
let n = entry.read(&mut buffer).map_err(|e| e.to_string())?;
if n == 0 {
break;
}
total += n as u64;
if total > max {
return Err("archive expansion exceeds max_bytes".into());
}
file.write_all(&buffer[..n]).map_err(|e| e.to_string())?;
}
}
Ok(Value::Int(zip.len() as i64))
})();
if extracted.is_err() {
let _ = fs::remove_dir_all(&dest);
}
extracted
}
#[cfg(feature = "net-host")]
fn random_name() -> Result<String, String> {
let mut bytes = [0u8; 16];
getrandom::getrandom(&mut bytes).map_err(|e| e.to_string())?;
Ok(bytes.iter().map(|b| format!("{b:02x}")).collect())
}