mirror of
https://github.com/storytold/craft-anything.git
synced 2026-11-21 23:10:51 +01:00
A data node that failed to inflate, used an unsupported compression or decoded to a length other than its declared size was skipped, leaving zeros or older bytes in the file while it looked recovered, and an overlong raw node could overwrite the next extent. Such nodes now mark their extent damaged; a newer valid node can still replace it, and a file is left unrecovered only if a damaged extent survives into its final contents.
182 lines
7.0 KiB
Rust
182 lines
7.0 KiB
Rust
use craft_anything_formats::fsread::{Limits, jffs2};
|
|
|
|
fn image(payload: &[u8], compression: u8, declared: u32, file_size: u32) -> Vec<u8> {
|
|
let mut bytes = craft_anything_testkit::firmware::jffs2_image();
|
|
let node = 96;
|
|
bytes.truncate(node + 68);
|
|
for (field, value) in [(4, 68 + payload.len() as u32), (28, file_size), (48, payload.len() as u32), (52, declared)] {
|
|
bytes[node + field..node + field + 4].copy_from_slice(&value.to_le_bytes());
|
|
}
|
|
bytes[node + 56] = compression;
|
|
bytes.extend_from_slice(payload);
|
|
bytes.resize(bytes.len().div_ceil(4) * 4, 0);
|
|
bytes
|
|
}
|
|
|
|
fn assert_unrecovered(bytes: &[u8]) {
|
|
let result = jffs2::read(bytes, &Limits::default());
|
|
let entry = result.entries.iter().find(|entry| entry.path == "config/settings").unwrap();
|
|
assert!(entry.data.is_none(), "invalid extent became {:?}", entry.data);
|
|
assert!(!result.complete);
|
|
assert_eq!(result.bytes, 0);
|
|
assert!(result.warnings.iter().any(|warning| warning.contains("data node")));
|
|
}
|
|
|
|
fn append_node(bytes: &mut Vec<u8>, payload: &[u8], compression: u8, declared: u32, file_size: u32, offset: u32, version: u32) {
|
|
let mut node = image(payload, compression, declared, file_size).split_off(96);
|
|
node[16..20].copy_from_slice(&version.to_le_bytes());
|
|
node[44..48].copy_from_slice(&offset.to_le_bytes());
|
|
bytes.extend_from_slice(&node);
|
|
}
|
|
|
|
fn damaged_payloads() -> [(Vec<u8>, u8); 5] {
|
|
[
|
|
(b"abc".to_vec(), 0),
|
|
(b"abcde".to_vec(), 0),
|
|
(miniz_oxide::deflate::compress_to_vec_zlib(b"abc", 6), 6),
|
|
(miniz_oxide::deflate::compress_to_vec_zlib(b"abcde", 6), 6),
|
|
(b"not a zlib stream".to_vec(), 6),
|
|
]
|
|
}
|
|
|
|
fn assert_recovered_with_warning(bytes: &[u8], expected: &[u8]) {
|
|
let result = jffs2::read(bytes, &Limits::default());
|
|
let entry = result.entries.iter().find(|entry| entry.path == "config/settings").unwrap();
|
|
assert_eq!(entry.data.as_deref(), Some(expected), "{:?}", result.warnings);
|
|
assert_eq!(entry.size, expected.len() as u64);
|
|
assert_eq!(result.bytes, expected.len() as u64);
|
|
assert!(result.complete, "{:?}", result.warnings);
|
|
assert!(result.warnings.iter().any(|warning| warning.contains("data node")));
|
|
}
|
|
|
|
#[test]
|
|
fn uncompressed_nodes_must_match_their_declared_length() {
|
|
for declared in [3, 5] {
|
|
assert_unrecovered(&image(b"abcd", 0, declared, 8));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn compressed_nodes_must_match_their_declared_length() {
|
|
let compressed = miniz_oxide::deflate::compress_to_vec_zlib(b"abcd", 6);
|
|
for declared in [3, 5] {
|
|
assert_unrecovered(&image(&compressed, 6, declared, 8));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_failed_inflate_does_not_become_a_zero_filled_file() {
|
|
assert_unrecovered(&image(b"not a zlib stream", 6, 4, 4));
|
|
}
|
|
|
|
#[test]
|
|
fn exact_nodes_can_be_clipped_by_the_final_file_size() {
|
|
let compressed = miniz_oxide::deflate::compress_to_vec_zlib(b"abcd", 6);
|
|
for (payload, compression) in [(b"abcd".as_slice(), 0), (compressed.as_slice(), 6)] {
|
|
for (size, expected) in [(2, b"ab".as_slice()), (4, b"abcd".as_slice())] {
|
|
let result = jffs2::read(&image(payload, compression, 4, size), &Limits::default());
|
|
assert!(result.complete, "{:?}", result.warnings);
|
|
assert_eq!(result.entries.iter().find(|entry| entry.path == "config/settings").unwrap().data.as_deref(), Some(expected));
|
|
assert_eq!(result.bytes, u64::from(size));
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn zero_nodes_keep_their_explicit_zero_extent() {
|
|
let result = jffs2::read(&image(&[], 1, 4, 4), &Limits::default());
|
|
assert!(result.complete);
|
|
assert_eq!(result.entries.iter().find(|entry| entry.path == "config/settings").unwrap().data.as_deref(), Some([0; 4].as_slice()));
|
|
}
|
|
|
|
#[test]
|
|
fn a_newer_valid_node_recovers_a_fully_overwritten_bad_node() {
|
|
let compressed = miniz_oxide::deflate::compress_to_vec_zlib(b"good", 6);
|
|
for (damaged, compression) in damaged_payloads() {
|
|
for (replacement, replacement_compression) in [(b"good".as_slice(), 0), (compressed.as_slice(), 6)] {
|
|
for versions in [[1, 2], [2, 1]] {
|
|
let mut bytes = image(&[], 0, 0, 4);
|
|
bytes.truncate(96);
|
|
for version in versions {
|
|
let (payload, compr) = if version == 1 { (damaged.as_slice(), compression) } else { (replacement, replacement_compression) };
|
|
append_node(&mut bytes, payload, compr, 4, 4, 0, version);
|
|
}
|
|
assert_recovered_with_warning(&bytes, b"good");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn newer_valid_nodes_can_repair_a_bad_extent_in_parts() {
|
|
for (damaged, compression) in damaged_payloads() {
|
|
let mut bytes = image(&damaged, compression, 4, 4);
|
|
append_node(&mut bytes, &[], 1, 2, 4, 1, 2);
|
|
assert_unrecovered(&bytes);
|
|
append_node(&mut bytes, b"a", 0, 1, 4, 0, 3);
|
|
assert_unrecovered(&bytes);
|
|
append_node(&mut bytes, b"d", 0, 1, 4, 3, 4);
|
|
assert_recovered_with_warning(&bytes, b"a\0\0d");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_newer_bad_node_cannot_reuse_older_valid_bytes() {
|
|
for (damaged, compression) in damaged_payloads() {
|
|
let mut bytes = image(b"old!", 0, 4, 4);
|
|
append_node(&mut bytes, &damaged, compression, 4, 4, 0, 2);
|
|
assert_unrecovered(&bytes);
|
|
append_node(&mut bytes, b"od", 0, 2, 4, 2, 3);
|
|
assert_unrecovered(&bytes);
|
|
append_node(&mut bytes, b"go", 0, 2, 4, 0, 4);
|
|
assert_recovered_with_warning(&bytes, b"good");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn only_bad_bytes_within_the_final_file_size_need_replacement() {
|
|
for (damaged, compression) in damaged_payloads() {
|
|
for offset in [0, 2, u32::MAX] {
|
|
let mut bytes = image(&[], 0, 0, 4);
|
|
bytes.truncate(96);
|
|
append_node(&mut bytes, &damaged, compression, 4, 4, offset, 1);
|
|
append_node(&mut bytes, b"ok", 0, 2, 2, 0, 2);
|
|
assert_recovered_with_warning(&bytes, b"ok");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn equal_versions_keep_their_physical_order() {
|
|
let mut repaired = image(b"bad", 0, 4, 4);
|
|
append_node(&mut repaired, b"good", 0, 4, 4, 0, 1);
|
|
assert_recovered_with_warning(&repaired, b"good");
|
|
|
|
let mut damaged = image(b"good", 0, 4, 4);
|
|
append_node(&mut damaged, b"bad", 0, 4, 4, 0, 1);
|
|
assert_unrecovered(&damaged);
|
|
}
|
|
|
|
#[test]
|
|
fn a_later_bad_node_invalidates_a_previously_repaired_extent() {
|
|
let mut bytes = image(b"bad", 0, 4, 4);
|
|
append_node(&mut bytes, b"good", 0, 4, 4, 0, 2);
|
|
append_node(&mut bytes, b"x", 0, 2, 4, 1, 3);
|
|
assert_unrecovered(&bytes);
|
|
append_node(&mut bytes, b"oo", 0, 2, 4, 1, 4);
|
|
assert_recovered_with_warning(&bytes, b"good");
|
|
}
|
|
|
|
#[test]
|
|
fn unsupported_nodes_need_the_same_later_valid_coverage() {
|
|
for compression in [2, 3, 4, 5, 7, 255] {
|
|
let mut bytes = image(b"old!", 0, 4, 4);
|
|
append_node(&mut bytes, b"data", compression, 4, 4, 0, 2);
|
|
assert_unrecovered(&bytes);
|
|
append_node(&mut bytes, b"new", 0, 3, 4, 0, 3);
|
|
assert_unrecovered(&bytes);
|
|
append_node(&mut bytes, &[], 1, 1, 4, 3, 4);
|
|
assert_recovered_with_warning(&bytes, b"new\0");
|
|
}
|
|
}
|