psd: bound TySh serialization and reject unsafe geometry

This commit is contained in:
Dylan M. Taylor committed 2026-11-15 09:33:38 -05:00
1 parent 4d594a1130
commit 1e204c51df
1 file changed
+175 -11
+175 -11
View File
@@ -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<TySh> {
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<TySh> {
*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<TySh> {
/// 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<Vec<u8>> {
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<Vec<u8>> {
}
/// Serializes a `TySh` block.
pub fn write_tysh(t: &TySh) -> Vec<u8> {
let mut v = 1u16.to_be_bytes().to_vec();
pub fn write_tysh(t: &TySh) -> Result<Vec<u8>> {
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());
}
}