From 1e204c51dff0d49e528637b16d58f95cfa2b283a Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Sun, 15 Nov 2026 09:33:38 -0500 Subject: [PATCH] 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()); + } }