GitCorner

Code

ossartcraftfigcraft🌐
b45255bb6fe2
//! Budgets on what SVGZ and embedded SVG documents expand into, with reduced limits so the
//! fixtures stay small.

use std::io::Write;

use base64::Engine as _;
use figcraft_doc::Document;

use super::{import_svg, import_within};
use craft_svg::tree::Limits;

fn gzip(data: &[u8]) -> Vec<u8> {
    let mut e = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
    e.write_all(data).unwrap();
    e.finish().unwrap()
}

fn svg(body: &str) -> String {
    format!(r##"<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="100" height="100">{body}</svg>"##)
}

fn uri(svg: &[u8]) -> String {
    format!("data:image/svg+xml;base64,{}", base64::engine::general_purpose::STANDARD.encode(svg))
}

/// `levels` SVGs, each embedding the next, the innermost holding one rectangle.
fn nested(levels: usize) -> String {
    let mut s = svg(r##"<rect width="10" height="10" fill="red"/>"##);
    for _ in 1..levels {
        s = svg(&format!(r##"<image width="100" height="100" xlink:href="{}"/>"##, uri(s.as_bytes())));
    }
    s
}

/// The layers an import makes (None when it is refused).
fn layers(data: &[u8], limits: Limits) -> Result<usize, String> {
    let mut d = Document::new("budget");
    let p = d.first_page().unwrap();
    let f = import_within(&mut d, data, p, 0.0, 0.0, "x", limits).map_err(|e| e.0)?.frame;
    assert!(d.validate().is_empty(), "{:?}", d.validate());
    Ok(d.subtree(f).len())
}

#[test]
fn an_svgz_is_unpacked_and_imported() {
    let z = gzip(svg(r##"<rect width="10" height="10"/>"##).as_bytes());
    let mut d = Document::new("z");
    let p = d.first_page().unwrap();
    assert!(import_svg(&mut d, &z, p, 0.0, 0.0, "z").is_ok());
}

#[test]
fn an_svgz_that_expands_past_the_budget_is_refused_early() {
    let limits = Limits { bytes: 4096, ..Limits::default() };
    // Tiny compressed, far past 4 KiB expanded.
    let z = gzip(svg(&" ".repeat(1 << 20)).as_bytes());
    assert!(z.len() < 4096, "the bomb is small: {}", z.len());
    let e = layers(&z, limits).unwrap_err();
    assert!(e.contains("larger than the 4096 byte limit"), "{e}");
    // The same document is fine within a bigger budget.
    assert!(layers(&z, Limits { bytes: 2 << 20, ..Limits::default() }).is_ok());
}

#[test]
fn a_compressed_document_is_checked_for_nesting_once_unpacked() {
    let deep = format!("{}{}", "<g>".repeat(600), "</g>".repeat(600));
    let z = gzip(svg(&deep).as_bytes());
    assert!(layers(&z, Limits::default()).unwrap_err().contains("nested more than"));
}

#[test]
fn embedded_svgs_nest_up_to_the_depth_budget_and_no_further() {
    let data = nested(4).into_bytes();
    let full = layers(&data, Limits::default()).unwrap();
    let shallow = layers(&data, Limits { embedded_depth: 1, ..Limits::default() }).unwrap();
    assert!(shallow < full, "depth 1 drops the inner documents: {shallow} < {full}");
    // Far deeper than the budget: still imports, bounded.
    let deep = nested(40).into_bytes();
    assert!(layers(&deep, Limits::default()).is_ok());
}

#[test]
fn embedded_svgs_share_one_byte_budget() {
    let inner = svg(r##"<rect width="10" height="10"/>"##);
    let one = format!(r##"<image width="10" height="10" xlink:href="{}"/>"##, uri(inner.as_bytes()));
    let data = svg(&one.repeat(8)).into_bytes();
    let all = layers(&data, Limits::default()).unwrap();
    let limits = Limits { embedded_bytes: inner.len() * 3, ..Limits::default() };
    let some = layers(&data, limits).unwrap();
    assert!(some < all, "the budget runs out part way: {some} < {all}");
}

#[test]
fn an_embedded_compressed_bomb_is_dropped_not_expanded() {
    let bomb = gzip(svg(&" ".repeat(1 << 20)).as_bytes());
    let data = svg(&format!(
        r##"<image width="10" height="10" xlink:href="data:image/svg+xml;base64,{}"/>"##,
        base64::engine::general_purpose::STANDARD.encode(&bomb)
    ))
    .into_bytes();
    let limits = Limits { embedded_bytes: 4096, ..Limits::default() };
    let with_bomb = layers(&data, limits).unwrap();
    let empty = layers(svg("").as_bytes(), limits).unwrap();
    assert_eq!(with_bomb, empty, "the oversized embedded document left nothing behind");
}

#[test]
fn linked_files_and_other_mime_types_stay_unresolved() {
    let data = svg(
        r##"<image width="10" height="10" xlink:href="/etc/passwd"/><image width="10" height="10" xlink:href="data:application/x-foo;base64,AAAA"/>"##,
    );
    assert_eq!(layers(data.as_bytes(), Limits::default()).unwrap(), layers(svg("").as_bytes(), Limits::default()).unwrap());
}

#[test]
fn a_document_compressed_twice_is_refused_not_unpacked_again() {
    // One gzip layer is unpacked within the budget; usvg would unpack a second one without any.
    let twice = gzip(&gzip(svg(&" ".repeat(1 << 20)).as_bytes()));
    let e = layers(&twice, Limits { bytes: 4 << 20, ..Limits::default() }).unwrap_err();
    assert!(e.contains("another compressed file"), "{e}");
    // Embedded, the same is dropped.
    let inner = svg(r##"<rect width="10" height="10"/>"##);
    let data = svg(&format!(
        r##"<image width="10" height="10" xlink:href="data:image/svg+xml;base64,{}"/>"##,
        base64::engine::general_purpose::STANDARD.encode(gzip(&gzip(inner.as_bytes())))
    ))
    .into_bytes();
    assert_eq!(layers(&data, Limits::default()).unwrap(), layers(svg("").as_bytes(), Limits::default()).unwrap());
}

#[test]
fn a_refused_embedded_bomb_uses_up_the_budget_for_the_images_after_it() {
    let bomb = gzip(svg(&" ".repeat(1 << 20)).as_bytes());
    let inner = svg(r##"<rect width="10" height="10"/>"##);
    let image = |href: String| format!(r##"<image width="10" height="10" xlink:href="{href}"/>"##);
    let bomb_uri = format!("data:image/svg+xml;base64,{}", base64::engine::general_purpose::STANDARD.encode(&bomb));
    let data = svg(&format!("{}{}", image(bomb_uri).repeat(8), image(uri(inner.as_bytes())))).into_bytes();
    let limits = Limits { embedded_bytes: 4096, ..Limits::default() };
    let empty = layers(svg("").as_bytes(), limits).unwrap();
    assert_eq!(layers(&data, limits).unwrap(), empty, "the first bomb spends the allowance; nothing after it unpacks");
}