mirror of
https://github.com/storytold/photocraft.git
synced 2026-11-21 09:26:43 +00:00
Merge remote-tracking branch 'origin/main' into fix/crop-invalid-rect
This commit is contained in:
commit
073eb4eb33
7 files changed
+131
-22
No files matched your search
@@ -17,6 +17,9 @@ const DOCUMENT_KIND: &[u8; 4] = b"nsrP";
|
||||
const MAX_TABLES: usize = 4096;
|
||||
/// Distinct ids the allocation tables may name; each costs a map slot even when only deleted.
|
||||
const MAX_ENTRIES: usize = 1 << 22;
|
||||
/// Bytes of entry names the allocation tables may name. A name is retained twice (in the entry
|
||||
/// and as its map key), and tables can point many names at the same bytes.
|
||||
const MAX_NAME_BYTES: usize = 32 << 20;
|
||||
/// zstd window ceiling: real documents use a few MiB; this stops a header from reserving gigabytes.
|
||||
const MAX_ZSTD_WINDOW: u64 = 64 << 20;
|
||||
|
||||
@@ -168,6 +171,7 @@ impl<'a> Archive<'a> {
|
||||
// Newest record per id: (table date, table index, record).
|
||||
let mut latest: HashMap<u32, (u64, usize, Option<Box<Entry>>)> = HashMap::new();
|
||||
let mut names: HashMap<u32, String> = HashMap::new();
|
||||
let mut name_bytes = 0usize;
|
||||
let mut seen = HashSet::new();
|
||||
let mut next = header.fat_offset;
|
||||
let mut tables = 0usize;
|
||||
@@ -231,8 +235,16 @@ impl<'a> Archive<'a> {
|
||||
}
|
||||
if flag == 0 {
|
||||
let len = usize::from(c.u16()?);
|
||||
let name = String::from_utf8_lossy(c.take(len)?).into_owned();
|
||||
names.entry(id).or_insert(name);
|
||||
let raw = c.take(len)?;
|
||||
// Only the first name per id is kept: charge and copy just that one.
|
||||
if let std::collections::hash_map::Entry::Vacant(slot) = names.entry(id) {
|
||||
let name = String::from_utf8_lossy(raw).into_owned();
|
||||
name_bytes = name_bytes.saturating_add(name.len());
|
||||
if name_bytes > MAX_NAME_BYTES {
|
||||
return Err(Error::Limit("archive entry names too large"));
|
||||
}
|
||||
slot.insert(name);
|
||||
}
|
||||
}
|
||||
// Equal dates: the first table in the chain (the newest) wins, as in afread.
|
||||
let replace = latest.get(&id).is_none_or(|(d, _, _)| date > *d);
|
||||
@@ -284,6 +296,9 @@ impl<'a> Archive<'a> {
|
||||
if total > self.limits.max_total {
|
||||
return Err(Error::Limit("document too large"));
|
||||
}
|
||||
// Charge before decoding: a corrupt entry that fails its checksum has already cost the
|
||||
// decompression, and an importer that recovers must not get it again for free.
|
||||
self.extracted = total;
|
||||
let mut c = Cursor::new(self.bytes, offset(e.offset)?);
|
||||
if c.take(4)? != b"#Fil" {
|
||||
return Err(Error::Malformed("archive entry has no data block"));
|
||||
@@ -303,7 +318,6 @@ impl<'a> Archive<'a> {
|
||||
if crc32fast::hash(&out) != e.crc {
|
||||
return Err(Error::Malformed("archive entry checksum mismatch"));
|
||||
}
|
||||
self.extracted = total;
|
||||
Ok(out)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -148,7 +148,21 @@ pub(crate) fn curves(r: &mut Reader, crvs: ObjId) -> Option<Path> {
|
||||
Value::UInt(n) => usize::try_from(*n).ok()?,
|
||||
_ => return None,
|
||||
};
|
||||
let corners = s.obj(crvs, b"CnrD").and_then(|c| corner_radii(s.positional(c).collect()));
|
||||
let corners = match s.obj(crvs, b"CnrD") {
|
||||
Some(c) => {
|
||||
let fields: Vec<&Value> = s.positional(c).collect();
|
||||
// The corner arrays are scanned for every occurrence of a shared curve, so charge
|
||||
// them like records before they are walked.
|
||||
if let Some(Value::Array(idx)) = fields.get(1)
|
||||
&& let Err(reason) = r.geometry_budget.records(idx.len())
|
||||
{
|
||||
r.warn(reason);
|
||||
return None;
|
||||
}
|
||||
corner_radii(fields)
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
let mut path = Path::default();
|
||||
let mut seen = 0usize;
|
||||
for index in 0..count {
|
||||
|
||||
@@ -290,6 +290,10 @@ const MAX_NODES: usize = 500_000;
|
||||
const MAX_CHILD_SLOTS: usize = 8_000_000;
|
||||
/// Bytes of layer names the model may retain across all occurrences.
|
||||
const MAX_NAME_BYTES: usize = 64 << 20;
|
||||
/// Page rectangles the model may retain across all spreads (real books have a few hundred).
|
||||
const MAX_PAGES: usize = 1 << 18;
|
||||
/// Bytes of font names the text runs may retain across the document.
|
||||
const MAX_FONT_NAME_BYTES: usize = 16 << 20;
|
||||
|
||||
/// Read a document: archive, `doc.dat` and the model.
|
||||
pub fn read(bytes: &[u8], limits: Limits) -> Result<Document, Error> {
|
||||
@@ -307,6 +311,8 @@ pub(crate) struct Reader<'s, 'a, 'b> {
|
||||
nodes: usize,
|
||||
child_slots: usize,
|
||||
name_bytes: usize,
|
||||
pages: usize,
|
||||
font_name_bytes: usize,
|
||||
active: HashSet<ObjId>,
|
||||
pub(crate) geometry_budget: crate::geometry::Budget,
|
||||
/// Decoded pixels still available ([`Limits::max_pixel_bytes`] less what the layers read so
|
||||
@@ -324,6 +330,8 @@ impl<'s, 'a, 'b> Reader<'s, 'a, 'b> {
|
||||
nodes: 0,
|
||||
child_slots: 0,
|
||||
name_bytes: 0,
|
||||
pages: 0,
|
||||
font_name_bytes: 0,
|
||||
active: HashSet::new(),
|
||||
geometry_budget: crate::geometry::Budget::default(),
|
||||
pixels_left: limits.max_pixel_bytes,
|
||||
@@ -365,7 +373,7 @@ impl<'s, 'a, 'b> Reader<'s, 'a, 'b> {
|
||||
self.warn("an unknown kind of page");
|
||||
continue;
|
||||
}
|
||||
let pages = pages(s, spread);
|
||||
let pages = self.pages(spread)?;
|
||||
let default_size = s.floats::<2>(doc, b"DfSz").filter(|[w, h]| *w > 0.0 && *h > 0.0).map(|[w, h]| Rect { x0: 0.0, y0: 0.0, x1: w, y1: h });
|
||||
let bounds = s.floats::<4>(spread, b"SprB").map(rect).or_else(|| pages.iter().copied().reduce(union)).or(default_size).unwrap_or(Rect {
|
||||
x0: 0.0,
|
||||
@@ -421,7 +429,7 @@ impl<'s, 'a, 'b> Reader<'s, 'a, 'b> {
|
||||
}
|
||||
|
||||
/// Counts raw array slots (null ones included) against [`MAX_CHILD_SLOTS`].
|
||||
fn charge_slots(&mut self, n: usize) -> Result<(), Error> {
|
||||
pub(crate) fn charge_slots(&mut self, n: usize) -> Result<(), Error> {
|
||||
self.child_slots = self.child_slots.saturating_add(n);
|
||||
if self.child_slots > MAX_CHILD_SLOTS {
|
||||
return Err(Error::Limit("too many child slots in the layer tree"));
|
||||
@@ -553,6 +561,8 @@ impl<'s, 'a, 'b> Reader<'s, 'a, 'b> {
|
||||
/// an attached mask layer is a pixel mask. Adjustments attached the same way are reported.
|
||||
fn attached_masks(&mut self, id: ObjId, world: Affine) -> Result<(Option<Path>, Option<Image>), Error> {
|
||||
let s = self.s;
|
||||
// Every occurrence of a shared layer scans its whole attachment array, null slots included.
|
||||
self.charge_slots(s.array_len(id, b"AdCh").unwrap_or(0))?;
|
||||
let attached = s.objs(id, b"AdCh");
|
||||
let mut mask: Option<Path> = None;
|
||||
let mut pixels: Option<Image> = None;
|
||||
@@ -601,21 +611,51 @@ impl<'s, 'a, 'b> Reader<'s, 'a, 'b> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Page rectangles: `SpMd.PagR[].rctp` (Publisher 2, Affinity 3) or `SprB` split into `PagC`
|
||||
/// equal pages (Publisher 1 facing spreads).
|
||||
fn pages(s: &Stream, spread: ObjId) -> Vec<Rect> {
|
||||
if let Some(md) = s.obj(spread, b"SpMd") {
|
||||
let v: Vec<Rect> = s.objs(md, b"PagR").into_iter().filter_map(|p| s.floats::<4>(p, b"rctp").map(rect)).filter(|r| r.x1 > r.x0 && r.y1 > r.y0).collect();
|
||||
if !v.is_empty() {
|
||||
return v;
|
||||
impl Reader<'_, '_, '_> {
|
||||
/// Page rectangles: `SpMd.PagR[].rctp` (Publisher 2, Affinity 3) or `SprB` split into `PagC`
|
||||
/// equal pages (Publisher 1 facing spreads). A spread listed several times, or sharing one
|
||||
/// large page array, is expanded into a new vector each time, so the slots scanned and the
|
||||
/// rectangles retained are charged across the document.
|
||||
fn pages(&mut self, spread: ObjId) -> Result<Vec<Rect>, Error> {
|
||||
let s = self.s;
|
||||
if let Some(md) = s.obj(spread, b"SpMd") {
|
||||
self.charge_slots(s.array_len(md, b"PagR").unwrap_or(0))?;
|
||||
let remaining = MAX_PAGES.saturating_sub(self.pages);
|
||||
let v: Vec<Rect> = s
|
||||
.objs(md, b"PagR")
|
||||
.into_iter()
|
||||
.filter_map(|p| s.floats::<4>(p, b"rctp").map(rect))
|
||||
.filter(|r| r.x1 > r.x0 && r.y1 > r.y0)
|
||||
.take(remaining.saturating_add(1))
|
||||
.collect();
|
||||
if !v.is_empty() {
|
||||
self.charge_pages(v.len())?;
|
||||
return Ok(v);
|
||||
}
|
||||
}
|
||||
Ok(match (s.floats::<4>(spread, b"SprB").map(rect), s.int(spread, b"PagC")) {
|
||||
(Some(b), Some(n @ 2..=16)) => {
|
||||
self.charge_pages(n as usize)?;
|
||||
let w = (b.x1 - b.x0) / n as f64;
|
||||
(0..n).map(|i| Rect { x0: b.x0 + w * i as f64, x1: b.x0 + w * (i + 1) as f64, ..b }).collect()
|
||||
}
|
||||
_ => Vec::new(),
|
||||
})
|
||||
}
|
||||
match (s.floats::<4>(spread, b"SprB").map(rect), s.int(spread, b"PagC")) {
|
||||
(Some(b), Some(n @ 2..=16)) => {
|
||||
let w = (b.x1 - b.x0) / n as f64;
|
||||
(0..n).map(|i| Rect { x0: b.x0 + w * i as f64, x1: b.x0 + w * (i + 1) as f64, ..b }).collect()
|
||||
|
||||
/// Counts retained font-name bytes against [`MAX_FONT_NAME_BYTES`]; false once it is spent.
|
||||
pub(crate) fn charge_font_name(&mut self, n: usize) -> bool {
|
||||
self.font_name_bytes = self.font_name_bytes.saturating_add(n);
|
||||
self.font_name_bytes <= MAX_FONT_NAME_BYTES
|
||||
}
|
||||
|
||||
/// Counts retained page rectangles against [`MAX_PAGES`].
|
||||
fn charge_pages(&mut self, n: usize) -> Result<(), Error> {
|
||||
self.pages = self.pages.saturating_add(n);
|
||||
if self.pages > MAX_PAGES {
|
||||
return Err(Error::Limit("too many pages"));
|
||||
}
|
||||
_ => Vec::new(),
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -232,9 +232,15 @@ pub(crate) fn descriptor(r: &mut Reader, id: ObjId, local: Affine) -> Option<Pai
|
||||
}
|
||||
};
|
||||
let grad = s.obj(fill, b"Grad")?;
|
||||
// A shared gradient is decoded again for every occurrence: charge the arrays scanned
|
||||
// and copy only as many positions as there are stops to keep.
|
||||
if r.charge_slots(s.array_len(grad, b"Cols").unwrap_or(0).saturating_add(s.array_len(grad, b"Posn").unwrap_or(0))).is_err() {
|
||||
r.warn("gradients beyond the document work budget (left empty)");
|
||||
return Some(Paint::None);
|
||||
}
|
||||
let cols = s.objs(grad, b"Cols");
|
||||
let posn: Vec<Vec<f64>> = match s.field(grad, b"Posn") {
|
||||
Some(Value::Array(a)) => a.iter().filter_map(floats).collect(),
|
||||
Some(Value::Array(a)) => a.iter().filter_map(floats).take(MAX_STOPS).collect(),
|
||||
_ => Vec::new(),
|
||||
};
|
||||
let mut stops = Vec::new();
|
||||
|
||||
@@ -193,6 +193,8 @@ fn plane(
|
||||
}
|
||||
.iter()
|
||||
.filter_map(|v| if let Value::Obj(Some(o)) = v { Some(*o) } else { None });
|
||||
// The scan below runs for every occurrence of a shared bitmap, whatever it produces.
|
||||
r.charge_slots(states.len().min(tw.saturating_mul(th)))?;
|
||||
let row = (w as usize) * bps;
|
||||
let mut out = vec![0u8; row * h as usize];
|
||||
let (bx0, bx1) = (x0 as usize * bps, (x0 + w) as usize * bps);
|
||||
|
||||
@@ -258,6 +258,20 @@ mod archive {
|
||||
assert!(matches!(a.read("doc.dat"), Err(Error::Limit(_))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_failed_read_still_spends_the_extraction_allowance() {
|
||||
let d = doc();
|
||||
let file = synth::container(&[("doc.dat", &d, Method::Zstd)], None);
|
||||
let mut broken = file.clone();
|
||||
broken[90] ^= 0x55;
|
||||
// Room for exactly one read: the failed attempt must use it up, so a caller that
|
||||
// recovers from the checksum error cannot make the same entry decode again.
|
||||
let mut a = Archive::open(&broken, Limits { max_entry: usize::MAX, max_total: d.len(), ..Limits::default() }).unwrap();
|
||||
assert!(a.read("doc.dat").is_err());
|
||||
assert_eq!(a.extracted(), d.len());
|
||||
assert!(matches!(a.read("doc.dat"), Err(Error::Limit(_))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_declared_size_smaller_than_the_data_is_rejected_not_truncated() {
|
||||
let big = vec![7u8; 1 << 20];
|
||||
|
||||
@@ -106,6 +106,24 @@ fn int(v: &Value) -> Option<i64> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Longest font name kept; real PostScript and family names are far shorter.
|
||||
const MAX_FONT_NAME: usize = 256;
|
||||
|
||||
/// A font name for one run. Runs repeat the same shared string, so its copies are charged
|
||||
/// against a document-wide byte budget; an overlong name or an exhausted budget leaves it empty.
|
||||
fn font_name(r: &mut Reader, font: Option<ObjId>, tag: &[u8; 4]) -> String {
|
||||
let name = font.and_then(|f| r.s.str(f, tag)).unwrap_or_default();
|
||||
if name.len() > MAX_FONT_NAME {
|
||||
r.warn("font names longer than 256 bytes (left empty)");
|
||||
return String::new();
|
||||
}
|
||||
if !r.charge_font_name(name.len()) {
|
||||
r.warn("font names beyond the document metadata budget (left empty)");
|
||||
return String::new();
|
||||
}
|
||||
name.to_string()
|
||||
}
|
||||
|
||||
fn run_attrs(r: &mut Reader, attrs: ObjId, text: String, world: Affine) -> TextRun {
|
||||
let s = r.s;
|
||||
let doubles = s.field(attrs, b"Doub");
|
||||
@@ -125,11 +143,12 @@ fn run_attrs(r: &mut Reader, attrs: ObjId, text: String, world: Affine) -> TextR
|
||||
r.warn("horizontally scaled text");
|
||||
}
|
||||
let font = s.obj(attrs, b"DFnt");
|
||||
let get = |tag: &[u8; 4]| font.and_then(|f| s.str(f, tag)).unwrap_or_default().to_string();
|
||||
let postscript = font_name(r, font, b"Post");
|
||||
let family = font_name(r, font, b"Famy");
|
||||
TextRun {
|
||||
text,
|
||||
postscript: get(b"Post"),
|
||||
family: get(b"Famy"),
|
||||
postscript,
|
||||
family,
|
||||
weight: font.and_then(|f| s.int(f, b"Wegt")).unwrap_or(400),
|
||||
italic: font.and_then(|f| s.bool(f, b"Ital")).unwrap_or(false),
|
||||
size,
|
||||
|
||||
Reference in new issue
Block a user