diff --git a/crates/psd/src/descriptor.rs b/crates/psd/src/descriptor.rs index 56d75e7b3..37e7cb94b 100644 --- a/crates/psd/src/descriptor.rs +++ b/crates/psd/src/descriptor.rs @@ -114,18 +114,6 @@ impl Descriptor { } } -pub(crate) fn read_unicode(r: &mut Reader) -> Result { - let n = r.u32()? as usize; - let mut v = Vec::with_capacity(n.min(r.remaining() / 2)); - for _ in 0..n { - v.push(r.u16()?); - } - while v.last() == Some(&0) { - v.pop(); - } - Ok(String::from_utf16_lossy(&v)) -} - /// Preserve the application parser's per-container limits in the shared parser. pub(crate) const PARSE_LIMITS: craft_psd::descriptor::ParseLimits = craft_psd::descriptor::ParseLimits { max_descriptor_items: 100_000, max_list_items: 1_000_000 }; diff --git a/crates/psd/src/parse.rs b/crates/psd/src/parse.rs index 5bcb38cc0..633b5ac90 100644 --- a/crates/psd/src/parse.rs +++ b/crates/psd/src/parse.rs @@ -144,7 +144,13 @@ impl Psd { let mut r = Reader::new(b); match key { b"luni" => { - let name = descriptor::read_unicode(&mut r)?; + // Shared framing rejects truncated counts/payloads before allocation. Only + // the first record belongs to this block; UTF-16 repair and naming stay local. + let units = craft_psd::unicode_names::records(b).next().ok_or(Error::Truncated)?; + let mut name: String = char::decode_utf16(units.as_chunks::<2>().0.iter().map(|v| u16::from_be_bytes(*v))) + .map(|v| v.unwrap_or(char::REPLACEMENT_CHARACTER)) + .collect(); + name.truncate(name.trim_end_matches('\0').len()); if !name.is_empty() { l.name = name; } diff --git a/crates/psd/src/tests.rs b/crates/psd/src/tests.rs index 1f84f27b7..7406c0345 100644 --- a/crates/psd/src/tests.rs +++ b/crates/psd/src/tests.rs @@ -5,6 +5,7 @@ use crate::pixels::srgb_encode; mod integration; mod opt; mod shared_corpus; +mod unicode_name; fn gradient(w: u32, h: u32) -> Vec<[f32; 4]> { (0..w * h).map(|i| [(i % w) as f32 / (w - 1).max(1) as f32, (i / w) as f32 / (h - 1).max(1) as f32, 0.25, 1.0]).collect() diff --git a/crates/psd/src/tests/unicode_name.rs b/crates/psd/src/tests/unicode_name.rs new file mode 100644 index 000000000..8785b1a49 --- /dev/null +++ b/crates/psd/src/tests/unicode_name.rs @@ -0,0 +1,86 @@ +use super::*; + +fn record(units: &[u16]) -> Vec { + let mut bytes = (units.len() as u32).to_be_bytes().to_vec(); + bytes.extend(units.iter().flat_map(|v| v.to_be_bytes())); + bytes +} + +fn parse_name(blocks: Vec>) -> String { + let mut doc = WDoc::new(1, 1); + doc.layers = vec![WLayer::empty("Fallback", blocks.into_iter().map(|b| (*b"luni", b)).collect())]; + Psd::parse(write(&doc)).unwrap().layers.remove(0).name +} + +#[test] +fn unicode_names_preserve_lossy_utf16_and_trailing_nul_policy() { + for (units, expected) in [ + (vec![], "Fallback"), + (vec![0, 0], "Fallback"), + (vec![65], "A"), + (vec![65, 0, 0], "A"), + (vec![0, 65, 0, 66, 0], "\0A\0B"), + (vec![0x00e4, 0xd83d, 0xde00], "\u{e4}\u{1f600}"), + (vec![0xd800, 65, 0xdc00, 0], "\u{fffd}A\u{fffd}"), + (vec![0xd800, 0], "\u{fffd}"), + (vec![0xd800, 0xd83d, 0xde00, 0xdc00], "\u{fffd}\u{1f600}\u{fffd}"), + ] { + assert_eq!(parse_name(vec![record(&units)]), expected, "{units:?}"); + } +} + +#[test] +fn unicode_name_uses_first_complete_record_and_recovers_in_block_order() { + let first = record(&[65]); + let mut combined = first.clone(); + combined.extend(record(&[66])); + combined.extend([0xff, 0]); + assert_eq!(parse_name(vec![combined]), "A"); + let mut empty_then_name = record(&[]); + empty_then_name.extend(record(&[66])); + assert_eq!(parse_name(vec![empty_then_name]), "Fallback"); + for suffix in [vec![], vec![0xff], vec![0, 0, 0], vec![0xff; 8]] { + let mut bytes = first.clone(); + bytes.extend(suffix); + assert_eq!(parse_name(vec![bytes]), "A"); + } + let mut malformed = vec![vec![], vec![0], vec![0, 0], vec![0, 0, 0], vec![0, 0, 0, 1], vec![0, 0, 0, 1, 0]]; + malformed.push([2u32.to_be_bytes().as_slice(), &[0, 65, 0]].concat()); + malformed.push(u32::MAX.to_be_bytes().to_vec()); + for bad in malformed { + assert_eq!(parse_name(vec![bad.clone()]), "Fallback"); + assert_eq!(parse_name(vec![first.clone(), bad.clone(), record(&[0, 0])]), "A"); + assert_eq!(parse_name(vec![bad, record(&[66])]), "B"); + } + assert_eq!(parse_name(vec![first, record(&[66])]), "B"); +} + +#[test] +fn unicode_layer_name_writer_keeps_code_unit_count_without_added_terminator() { + for name in ["", "A", "\u{e4}\u{1f600}", "A\0", "\0B\0"] { + let mut doc = WDoc::new(1, 1); + doc.layers = vec![WLayer::empty(name, vec![])]; + let bytes = write(&doc); + let file = craft_psd::PsdFile::from_bytes(&bytes).unwrap(); + let block = file.layer_info.as_ref().unwrap().layers[0].block(b"luni").unwrap(); + let units: Vec<_> = name.encode_utf16().collect(); + assert_eq!(block.data, record(&units)); + } +} + +#[test] +fn missing_empty_or_malformed_unicode_name_keeps_pascal_name() { + let mut doc = WDoc::new(1, 1); + doc.layers = vec![WLayer::empty("Generated Unicode name", vec![])]; + let bytes = write(&doc); + for payload in [None, Some(vec![]), Some(record(&[])), Some(record(&[0, 0])), Some(vec![0, 0, 0, 1, 0]), Some(u32::MAX.to_be_bytes().to_vec())] { + let mut file = craft_psd::PsdFile::from_bytes(&bytes).unwrap(); + let layer = &mut file.layer_info.as_mut().unwrap().layers[0]; + layer.name = b"Pascal".to_vec(); + layer.blocks.retain(|b| b.key != *b"luni"); + if let Some(data) = payload { + layer.blocks.push(craft_psd::tagged::TaggedBlock::new(*b"luni", data)); + } + assert_eq!(Psd::parse(file.to_bytes().unwrap()).unwrap().layers[0].name, "Pascal"); + } +}