From 4d594a1130c78c88e9f9baf28891fc7d76162611 Mon Sep 17 00:00:00 2001 From: Brandon Thomas Date: Sun, 15 Nov 2026 09:30:30 -0500 Subject: [PATCH 1/3] psd: share editable TySh binary envelope from PhotoCraft Preserve transform safety work and compatibility recovery; adapt to shared array geometry and add regression tests. Co-authored-by: David Mann Co-authored-by: Sean Lavery Co-authored-by: Dylan M. Taylor --- crates/psd/src/text.rs | 3 + crates/psd/src/text/envelope.rs | 142 ++++++++++++++++++++++++++++++++ 2 files changed, 145 insertions(+) create mode 100644 crates/psd/src/text/envelope.rs diff --git a/crates/psd/src/text.rs b/crates/psd/src/text.rs index 6ba299bca..3a9e14952 100644 --- a/crates/psd/src/text.rs +++ b/crates/psd/src/text.rs @@ -150,3 +150,6 @@ mod tests { assert_eq!(t.style.size, Some(12.0)); } } + +/// Editable type-tool envelope with PhotoCraft-compatible recovery and geometry limits. +pub mod envelope; diff --git a/crates/psd/src/text/envelope.rs b/crates/psd/src/text/envelope.rs new file mode 100644 index 000000000..68664f7d7 --- /dev/null +++ b/crates/psd/src/text/envelope.rs @@ -0,0 +1,142 @@ +//! Editable PSD Type Tool Object Setting (`TySh`) envelope, extracted from PhotoCraft. +//! App-specific text styles, layout, units and editing policy stay with the consumer. +//! Parsing intentionally retains PhotoCraft's optional-warp and partial-bounds recovery. +//! Existing read-only [`super::TypeLayer`] behavior is unchanged. + +use crate::descriptor::{Descriptor, Id, Value as D, VersionedDescriptor}; + +/// Parsed `TySh` contents. +#[derive(Clone, Debug, PartialEq)] +pub struct TySh { + pub transform: [f64; 6], + pub text: Descriptor, + pub warp: Option, + /// The four trailing big-endian f32 values (left, top, right, bottom) after the warp + /// descriptor. Photoshop writes zeros for unwarped type and the text-space bounds (the + /// `bounds` descriptor's rectangle) for warped type. + pub bounds: [f32; 4], +} + +/// Whether a type transform can reach rendering. Pixel coordinates use i32 in the originating PhotoCraft consumer, so non-finite and unrepresentable affine terms are rejected (#4758). +pub fn transform_is_safe(t: &[f64; 6]) -> bool { + t.iter().all(|v| v.is_finite() && v.abs() <= f64::from(i32::MAX)) +} + +/// Parses a `TySh` block. +pub fn parse_tysh(data: &[u8]) -> Option { + let f = |at: usize| data.get(at..at + 8).map(|b| f64::from_be_bytes(b.try_into().unwrap_or([0; 8]))); + let mut m = [0.0; 6]; + for (i, v) in m.iter_mut().enumerate() { + *v = f(2 + i * 8)?; + } + if !transform_is_safe(&m) { + return None; + } + let (text, used) = VersionedDescriptor::parse_prefix(data.get(52..)?).ok()?; + let rest = data.get(52 + used..).unwrap_or(&[]); + let (warp, wused) = match rest.get(2..).and_then(|r| VersionedDescriptor::parse_prefix(r).ok()) { + Some((w, n)) => (Some(w.descriptor), n + 2), + None => (None, 0), + }; + let tail = rest.get(wused..).unwrap_or(&[]); + let mut bounds = [0f32; 4]; + for (i, b) in bounds.iter_mut().enumerate() { + if let Some(x) = tail.get(i * 4..i * 4 + 4) { + *b = f32::from_be_bytes(x.try_into().unwrap_or([0; 4])); + } + } + Some(TySh { transform: m, text: text.descriptor, warp, bounds }) +} + +/// `tysh` moved by (`dx`, `dy`): only the transform's translation changes. The text, its styles, +/// the warp and the trailing bounds (which are in text space) stay byte for byte, so a moved +/// Photoshop type layer keeps everything Photoshop wrote. `None` when the block is too short. +pub fn translate_tysh(tysh: &[u8], dx: f64, dy: f64) -> Option> { + let mut out = tysh.to_vec(); + // Version (2 bytes), then xx, xy, yx, yy, tx, ty as big-endian f64: tx at 34, ty at 42. + for (at, d) in [(34, dx), (42, dy)] { + let b = out.get_mut(at..at + 8)?; + let v = f64::from_be_bytes(b.try_into().ok()?) + d; + b.copy_from_slice(&v.to_be_bytes()); + } + Some(out) +} + +/// Serializes a `TySh` block. +pub fn write_tysh(t: &TySh) -> Vec { + let mut v = 1u16.to_be_bytes().to_vec(); + for x in t.transform { + v.extend_from_slice(&x.to_be_bytes()); + } + v.extend_from_slice(&50u16.to_be_bytes()); + v.extend(VersionedDescriptor::new(t.text.clone()).to_bytes()); + v.extend_from_slice(&1u16.to_be_bytes()); + v.extend(VersionedDescriptor::new(t.warp.clone().unwrap_or_else(default_warp)).to_bytes()); + for b in t.bounds { + v.extend_from_slice(&b.to_be_bytes()); + } + v +} + +fn default_warp() -> Descriptor { + Descriptor::new("warp") + .with("warpStyle", enumv("warpStyle", "warpNone")) + .with("warpValue", D::Double(0.0)) + .with("warpPerspective", D::Double(0.0)) + .with("warpPerspectiveOther", D::Double(0.0)) + .with("warpRotate", enumv("Ornt", "Hrzn")) +} + +fn enumv(t: &str, v: &str) -> D { + D::Enumerated { type_id: Id::new(t), value: Id::new(v) } +} + +#[cfg(test)] +mod tests { + use super::*; + fn sample() -> TySh { + TySh { + transform: [1.0, 0.0, 0.0, 1.0, 25.0, 30.0], + text: Descriptor::new("TxLr").with("EngineData", D::RawData(b"preserved".to_vec())), + warp: Some(default_warp()), + bounds: [-1.0, 2.0, 30.0, 40.0], + } + } + #[test] + fn roundtrip_preserves_descriptors_transform_and_bounds() { + let t = sample(); + let b = write_tysh(&t); + assert_eq!(parse_tysh(&b), Some(t)); + let shifted = translate_tysh(&b, 7.0, -3.0).unwrap(); + assert_eq!(&shifted[..34], &b[..34]); + assert_eq!(&shifted[50..], &b[50..]); + assert_eq!(parse_tysh(&shifted).unwrap().transform, [1.0, 0.0, 0.0, 1.0, 32.0, 27.0]); + } + #[test] + fn truncations_and_unsafe_transforms_preserve_recovery_contract() { + let mut t = sample(); + let bytes = write_tysh(&t); + let (_, n) = VersionedDescriptor::parse_prefix(&bytes[52..]).unwrap(); + for cut in 0..52 + n { + assert!(parse_tysh(&bytes[..cut]).is_none(), "{cut}"); + } + let short = parse_tysh(&bytes[..52 + n]).unwrap(); + assert!(short.warp.is_none()); + assert_eq!(short.bounds, [0.0; 4]); + for cut in 0..50 { + assert!(translate_tysh(&bytes[..cut], 1.0, 2.0).is_none()); + } + for bad in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, f64::from(i32::MAX) + 1.0] { + for i in 0..6 { + t = sample(); + t.transform[i] = bad; + assert!(parse_tysh(&write_tysh(&t)).is_none()); + } + } + t = sample(); + t.warp = None; + assert!(parse_tysh(&write_tysh(&t)).unwrap().warp.is_some()); + let partial = parse_tysh(&bytes[..bytes.len() - 4]).unwrap(); + assert_eq!(partial.bounds, [-1.0, 2.0, 30.0, 0.0]); + } +} From 1e204c51dff0d49e528637b16d58f95cfa2b283a Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 09:33:38 -0500 Subject: [PATCH 2/3] psd: bound TySh serialization and reject unsafe geometry --- crates/psd/src/text/envelope.rs | 186 ++++++++++++++++++++++++++++++-- 1 file changed, 175 insertions(+), 11 deletions(-) diff --git a/crates/psd/src/text/envelope.rs b/crates/psd/src/text/envelope.rs index 68664f7d7..e654ed390 100644 --- a/crates/psd/src/text/envelope.rs +++ b/crates/psd/src/text/envelope.rs @@ -3,7 +3,11 @@ //! Parsing intentionally retains PhotoCraft's optional-warp and partial-bounds recovery. //! Existing read-only [`super::TypeLayer`] behavior is unchanged. -use crate::descriptor::{Descriptor, Id, Value as D, VersionedDescriptor}; +use crate::descriptor::{Class, Descriptor, Id, ReferenceItem, UnicodeString, Value as D, VersionedDescriptor}; +use crate::error::{PsdError, Result}; + +/// Maximum encoded envelope size, bounding hostile input and serialized output. +pub const MAX_BYTES: usize = 8 * 1024 * 1024; /// Parsed `TySh` contents. #[derive(Clone, Debug, PartialEq)] @@ -24,6 +28,9 @@ pub fn transform_is_safe(t: &[f64; 6]) -> bool { /// Parses a `TySh` block. pub fn parse_tysh(data: &[u8]) -> Option { + if data.len() > MAX_BYTES { + return None; + } let f = |at: usize| data.get(at..at + 8).map(|b| f64::from_be_bytes(b.try_into().unwrap_or([0; 8]))); let mut m = [0.0; 6]; for (i, v) in m.iter_mut().enumerate() { @@ -45,6 +52,9 @@ pub fn parse_tysh(data: &[u8]) -> Option { *b = f32::from_be_bytes(x.try_into().unwrap_or([0; 4])); } } + if bounds.iter().any(|x| !x.is_finite()) { + return None; + } Some(TySh { transform: m, text: text.descriptor, warp, bounds }) } @@ -52,7 +62,21 @@ pub fn parse_tysh(data: &[u8]) -> Option { /// the warp and the trailing bounds (which are in text space) stay byte for byte, so a moved /// Photoshop type layer keeps everything Photoshop wrote. `None` when the block is too short. pub fn translate_tysh(tysh: &[u8], dx: f64, dy: f64) -> Option> { - let mut out = tysh.to_vec(); + if tysh.len() > MAX_BYTES || tysh.len() < 50 { + return None; + } + let mut transform = [0.0; 6]; + for (i, x) in transform.iter_mut().enumerate() { + *x = f64::from_be_bytes(tysh.get(2 + i * 8..10 + i * 8)?.try_into().ok()?); + } + transform[4] += dx; + transform[5] += dy; + if !transform_is_safe(&transform) { + return None; + } + let mut out = Vec::new(); + out.try_reserve_exact(tysh.len()).ok()?; + out.extend_from_slice(tysh); // Version (2 bytes), then xx, xy, yx, yy, tx, ty as big-endian f64: tx at 34, ty at 42. for (at, d) in [(34, dx), (42, dy)] { let b = out.get_mut(at..at + 8)?; @@ -63,19 +87,136 @@ pub fn translate_tysh(tysh: &[u8], dx: f64, dy: f64) -> Option> { } /// Serializes a `TySh` block. -pub fn write_tysh(t: &TySh) -> Vec { - let mut v = 1u16.to_be_bytes().to_vec(); +pub fn write_tysh(t: &TySh) -> Result> { + if !transform_is_safe(&t.transform) || t.bounds.iter().any(|x| !x.is_finite()) { + return Err(PsdError::LimitExceeded("TySh geometry")); + } + let default; + let warp = match &t.warp { + Some(w) => w, + None => { + default = default_warp(); + &default + } + }; + let mut budget = Budget(78); // versions, transform and trailing bounds + budget.descriptor(&t.text, 0)?; + budget.descriptor(warp, 0)?; + let mut v = Vec::new(); + v.try_reserve_exact(budget.0).map_err(|_| PsdError::OutOfMemory("TySh output"))?; + v.extend_from_slice(&1u16.to_be_bytes()); for x in t.transform { v.extend_from_slice(&x.to_be_bytes()); } v.extend_from_slice(&50u16.to_be_bytes()); - v.extend(VersionedDescriptor::new(t.text.clone()).to_bytes()); + v.extend_from_slice(&16u32.to_be_bytes()); + t.text.write(&mut v); v.extend_from_slice(&1u16.to_be_bytes()); - v.extend(VersionedDescriptor::new(t.warp.clone().unwrap_or_else(default_warp)).to_bytes()); + v.extend_from_slice(&16u32.to_be_bytes()); + warp.write(&mut v); for b in t.bounds { v.extend_from_slice(&b.to_be_bytes()); } - v + Ok(v) +} + +// Count before cloning or serializing: bound both recursive trees and total output. +struct Budget(usize); +impl Budget { + fn add(&mut self, n: usize) -> Result<()> { + self.0 = self.0.checked_add(n).filter(|n| *n <= MAX_BYTES).ok_or(PsdError::LimitExceeded("TySh bytes"))?; + Ok(()) + } + fn unicode(&mut self, s: &UnicodeString) -> Result<()> { + self.add(4)?; + self.add(s.0.len().checked_mul(2).ok_or(PsdError::LimitExceeded("TySh string"))?) + } + fn id(&mut self, id: &Id) -> Result<()> { + self.add(4)?; + self.add(id.as_bytes().len()) + } + fn class(&mut self, c: &Class) -> Result<()> { + self.unicode(&c.name)?; + self.id(&c.class_id) + } + fn descriptor(&mut self, d: &Descriptor, depth: usize) -> Result<()> { + if depth > 32 { + return Err(PsdError::LimitExceeded("TySh depth")); + } + self.unicode(&d.name)?; + self.id(&d.class_id)?; + self.add(4)?; + for (k, v) in &d.items { + self.id(k)?; + self.value(v, depth + 1)?; + } + Ok(()) + } + fn value(&mut self, v: &D, depth: usize) -> Result<()> { + if depth > 32 { + return Err(PsdError::LimitExceeded("TySh depth")); + } + self.add(4)?; + match v { + D::Descriptor(d) | D::GlobalObject(d) => self.descriptor(d, depth), + D::ObjectArray(o) => { + self.add(4)?; + self.descriptor(&o.body, depth) + } + D::List(xs) => { + self.add(4)?; + for x in xs { + self.value(x, depth + 1)?; + } + Ok(()) + } + D::Reference(xs) => { + self.add(4)?; + for x in xs { + self.add(4)?; + match x { + ReferenceItem::Property { class, key } => { + self.class(class)?; + self.id(key)?; + } + ReferenceItem::Class(c) => self.class(c)?, + ReferenceItem::Enumerated { class, type_id, value } => { + self.class(class)?; + self.id(type_id)?; + self.id(value)?; + } + ReferenceItem::Offset { class, .. } | ReferenceItem::Identifier { class, .. } | ReferenceItem::Index { class, .. } => { + self.class(class)?; + self.add(4)?; + } + ReferenceItem::Name { class, name } => { + self.class(class)?; + self.unicode(name)?; + } + } + } + Ok(()) + } + D::Text(x) => self.unicode(x), + D::Class(c) | D::GlobalClass(c) => self.class(c), + D::Enumerated { type_id, value } => { + self.id(type_id)?; + self.id(value) + } + D::UnitFloats { values, .. } => { + self.add(8)?; + self.add(values.len().checked_mul(8).ok_or(PsdError::LimitExceeded("TySh values"))?) + } + D::RawData(x) | D::Alias(x) | D::Path(x) => { + self.add(4)?; + self.add(x.len()) + } + D::Double(_) | D::LargeInteger(_) => self.add(8), + D::UnitFloat { .. } => self.add(12), + D::Integer(_) => self.add(4), + D::Boolean(_) => self.add(1), + } + } } fn default_warp() -> Descriptor { @@ -105,7 +246,7 @@ mod tests { #[test] fn roundtrip_preserves_descriptors_transform_and_bounds() { let t = sample(); - let b = write_tysh(&t); + let b = write_tysh(&t).unwrap(); assert_eq!(parse_tysh(&b), Some(t)); let shifted = translate_tysh(&b, 7.0, -3.0).unwrap(); assert_eq!(&shifted[..34], &b[..34]); @@ -115,7 +256,7 @@ mod tests { #[test] fn truncations_and_unsafe_transforms_preserve_recovery_contract() { let mut t = sample(); - let bytes = write_tysh(&t); + let bytes = write_tysh(&t).unwrap(); let (_, n) = VersionedDescriptor::parse_prefix(&bytes[52..]).unwrap(); for cut in 0..52 + n { assert!(parse_tysh(&bytes[..cut]).is_none(), "{cut}"); @@ -130,13 +271,36 @@ mod tests { for i in 0..6 { t = sample(); t.transform[i] = bad; - assert!(parse_tysh(&write_tysh(&t)).is_none()); + assert!(write_tysh(&t).is_err()); } } t = sample(); t.warp = None; - assert!(parse_tysh(&write_tysh(&t)).unwrap().warp.is_some()); + assert!(parse_tysh(&write_tysh(&t).unwrap()).unwrap().warp.is_some()); let partial = parse_tysh(&bytes[..bytes.len() - 4]).unwrap(); assert_eq!(partial.bounds, [-1.0, 2.0, 30.0, 0.0]); } + #[test] + fn hostile_output_and_translations_are_refused_before_copying() { + let bytes = write_tysh(&sample()).unwrap(); + for bad in [f64::NAN, f64::INFINITY, f64::MAX] { + assert!(translate_tysh(&bytes, bad, 0.0).is_none()); + } + let mut t = sample(); + t.bounds[0] = f32::NAN; + assert!(write_tysh(&t).is_err()); + t = sample(); + t.text = Descriptor::new("TxLr").with("data", D::RawData(vec![0; MAX_BYTES])); + assert!(write_tysh(&t).is_err()); + let oversized = vec![0; MAX_BYTES + 1]; + assert!(translate_tysh(&oversized, 0.0, 0.0).is_none()); + assert!(parse_tysh(&oversized).is_none()); + let mut nested = D::Integer(1); + for _ in 0..34 { + nested = D::List(vec![nested]); + } + t = sample(); + t.text = Descriptor::new("TxLr").with("nest", nested); + assert!(write_tysh(&t).is_err()); + } } From 2bb5d0344f03a73833576b57847513ea529d3d2c Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 10:10:41 -0500 Subject: [PATCH 3/3] docs(psd): document editable TySh envelope fields --- crates/psd/src/text/envelope.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/psd/src/text/envelope.rs b/crates/psd/src/text/envelope.rs index e654ed390..73345fa83 100644 --- a/crates/psd/src/text/envelope.rs +++ b/crates/psd/src/text/envelope.rs @@ -12,8 +12,11 @@ pub const MAX_BYTES: usize = 8 * 1024 * 1024; /// Parsed `TySh` contents. #[derive(Clone, Debug, PartialEq)] pub struct TySh { + /// Affine transform in PSD order: xx, xy, yx, yy, tx, ty. pub transform: [f64; 6], + /// Text descriptor, including text content and styling data. pub text: Descriptor, + /// Optional warp descriptor retained from the Type Tool block. pub warp: Option, /// The four trailing big-endian f32 values (left, top, right, bottom) after the warp /// descriptor. Photoshop writes zeros for unwarped type and the text-space bounds (the