holperf/src/gen.rs
//! Synthetic but VALID package bytes, deterministic, incompressible payloads.
use std::io::Write;
/// Deterministic pseudo-random (incompressible) bytes.
pub fn payload(seed: u64, n: usize) -> Vec<u8> {
let mut x = seed.wrapping_mul(0x9E37_79B9_7F4A_7C15) | 1;
let mut v = Vec::with_capacity(n);
// A fixed prefix, so no payload starts with an archive magic by chance (a random
// 1f 8b made the inspector refuse it as a corrupt nested gzip).
v.extend_from_slice(b"HOLPERF\0");
while v.len() < n {
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
v.extend_from_slice(&x.to_le_bytes());
}
v.truncate(n);
v
}
/// gzip(tar(files)).
pub fn tgz(files: &[(&str, &[u8])]) -> Vec<u8> {
let mut out = Vec::new();
{
let enc = flate2::write::GzEncoder::new(&mut out, flate2::Compression::fast());
let mut t = tar::Builder::new(enc);
for (p, b) in files {
let mut h = tar::Header::new_gnu();
h.set_path(p).unwrap();
h.set_size(b.len() as u64);
h.set_mode(0o644);
h.set_mtime(1_700_000_000);
h.set_cksum();
t.append(&h, *b).unwrap();
}
t.into_inner().unwrap().finish().unwrap();
}
out
}
/// plain tar(files).
pub fn tar(files: &[(&str, &[u8])]) -> Vec<u8> {
let mut t = tar::Builder::new(Vec::new());
for (p, b) in files {
let mut h = tar::Header::new_gnu();
h.set_path(p).unwrap();
h.set_size(b.len() as u64);
h.set_mode(0o644);
h.set_mtime(1_700_000_000);
h.set_cksum();
t.append(&h, *b).unwrap();
}
t.into_inner().unwrap()
}
/// zip(files), stored (payload is incompressible anyway).
pub fn zip(files: &[(&str, &[u8])]) -> Vec<u8> {
let mut buf = std::io::Cursor::new(Vec::new());
{
let mut z = zip::ZipWriter::new(&mut buf);
let o: zip::write::SimpleFileOptions = zip::write::SimpleFileOptions::default()
.compression_method(zip::CompressionMethod::Stored);
for (p, b) in files {
z.start_file(*p, o).unwrap();
z.write_all(b).unwrap();
}
z.finish().unwrap();
}
buf.into_inner()
}
pub fn crate_file(name: &str, ver: &str, size: usize, seed: u64) -> Vec<u8> {
let toml = format!("[package]\nname = \"{name}\"\nversion = \"{ver}\"\nedition = \"2021\"\n");
let p = payload(seed, size);
tgz(&[
(&format!("{name}-{ver}/Cargo.toml"), toml.as_bytes()),
(&format!("{name}-{ver}/src/blob.bin"), &p),
])
}
pub fn npm_tgz(name: &str, ver: &str, size: usize, seed: u64) -> Vec<u8> {
let pj = format!("{{\"name\":\"{name}\",\"version\":\"{ver}\"}}");
let p = payload(seed, size);
tgz(&[
("package/package.json", pj.as_bytes()),
("package/blob.bin", &p),
])
}
pub fn wheel(name: &str, ver: &str, size: usize, seed: u64) -> Vec<u8> {
let meta = format!("Metadata-Version: 2.1\nName: {name}\nVersion: {ver}\n");
let p = payload(seed, size);
zip(&[
(&format!("{name}/blob.bin"), &p),
(&format!("{name}-{ver}.dist-info/METADATA"), meta.as_bytes()),
(
&format!("{name}-{ver}.dist-info/WHEEL"),
b"Wheel-Version: 1.0\nRoot-Is-Purelib: true\nTag: py3-none-any\n",
),
(&format!("{name}-{ver}.dist-info/RECORD"), b""),
])
}
pub fn jar(g: &str, a: &str, ver: &str, size: usize, seed: u64) -> Vec<u8> {
let pom = pom(g, a, ver);
let p = payload(seed, size);
zip(&[
("META-INF/MANIFEST.MF", b"Manifest-Version: 1.0\n"),
(&format!("META-INF/maven/{g}/{a}/pom.xml"), pom.as_bytes()),
("blob.bin", &p),
])
}
pub fn pom(g: &str, a: &str, v: &str) -> String {
format!("<project><modelVersion>4.0.0</modelVersion><groupId>{g}</groupId><artifactId>{a}</artifactId><version>{v}</version></project>")
}
pub fn go_zip(module: &str, ver: &str, size: usize, seed: u64) -> Vec<u8> {
let p = payload(seed, size);
let gm = format!("module {module}\n");
zip(&[
(&format!("{module}@{ver}/go.mod"), gm.as_bytes()),
(&format!("{module}@{ver}/blob.bin"), &p),
])
}
/// A real `.deb`: ar(debian-binary, control.tar.xz, data.tar.xz-less data.tar) — Debian's
/// default control codec is xz, so the server's control parse takes the liblzma path.
pub fn deb(name: &str, ver: &str, arch: &str, size: usize, seed: u64) -> Vec<u8> {
let control = format!(
"Package: {name}\nVersion: {ver}\nArchitecture: {arch}\nMaintainer: Bench <bench@mock.invalid>\nDepends: libc6 (>= 2.14)\nDescription: bench package\n"
);
let ctar = tar(&[("./control", control.as_bytes())]);
let mut xz = Vec::new();
{
let mut enc = liblzma::write::XzEncoder::new(&mut xz, 6);
enc.write_all(&ctar).unwrap();
enc.finish().unwrap();
}
let p = payload(seed, size);
let data = tar(&[("./usr/share/bench/blob.bin", &p)]);
let members: Vec<(&str, &[u8])> = vec![
("debian-binary", b"2.0\n"),
("control.tar.xz", &xz),
("data.tar", &data),
];
let mut out = b"!<arch>\n".to_vec();
for (n, body) in members {
out.extend_from_slice(
format!(
"{:<16}{:<12}{:<6}{:<6}{:<8}{:<10}`\n",
n,
0,
0,
0,
100644,
body.len()
)
.as_bytes(),
);
out.extend_from_slice(body);
if body.len() % 2 == 1 {
out.push(b'\n');
}
}
out
}
/// A gzip'd cpio `newc` stream of one file (an rpm's payload; HOL-NCSC: the intake's
/// inspector opens it, and blocks a payload it cannot open).
fn cpio_gz(name: &str, data: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
for (name, mode, data) in [(name, 0o100644u32, data), ("TRAILER!!!", 0, &b""[..])] {
let fields = [
0,
mode,
0,
0,
1,
0,
data.len() as u32,
0,
0,
0,
0,
name.len() as u32 + 1,
0,
];
out.extend_from_slice(b"070701");
for f in fields {
out.extend_from_slice(format!("{f:08x}").as_bytes());
}
out.extend_from_slice(name.as_bytes());
out.push(0);
while out.len() % 4 != 0 {
out.push(0);
}
out.extend_from_slice(data);
while out.len() % 4 != 0 {
out.push(0);
}
}
let mut gz = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::fast());
gz.write_all(&out).unwrap();
gz.finish().unwrap()
}
/// An `.rpm` with the lead, empty signature + main headers and a payload: NEVRA from the name.
pub fn rpm(nvr: &str, size: usize, seed: u64) -> Vec<u8> {
let mut lead = vec![0xED, 0xAB, 0xEE, 0xDB, 3, 0, 0, 0, 0, 1];
let mut name = nvr.as_bytes().to_vec();
name.resize(66, 0);
lead.extend_from_slice(&name);
lead.extend_from_slice(&[0, 1, 0, 5]);
lead.resize(96, 0);
let empty = [0x8E, 0xAD, 0xE8, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
lead.extend_from_slice(&empty);
lead.extend_from_slice(&empty);
lead.extend_from_slice(&cpio_gz("./usr/share/bench/blob.bin", &payload(seed, size)));
lead
}
pub fn chart(name: &str, ver: &str, size: usize, seed: u64) -> Vec<u8> {
let cy = format!("apiVersion: v2\nname: {name}\nversion: {ver}\ndescription: bench chart\n");
let p = payload(seed, size);
tgz(&[
(&format!("{name}/Chart.yaml"), cy.as_bytes()),
(&format!("{name}/values.yaml"), b"replicas: 1\n"),
(&format!("{name}/files/blob.bin"), &p),
])
}
pub fn sha256_hex(b: &[u8]) -> String {
traits::sha256_hex(b)
}
pub fn oci_manifest(config: &str, layer: &str, layer_size: usize) -> String {
format!(
r#"{{"schemaVersion":2,"mediaType":"application/vnd.oci.image.manifest.v1+json","config":{{"mediaType":"application/vnd.oci.image.config.v1+json","digest":"{config}","size":2}},"layers":[{{"mediaType":"application/vnd.oci.image.layer.v1.tar+gzip","digest":"{layer}","size":{layer_size}}}]}}"#
)
}