mirror of
https://github.com/storytold/lightcraft.git
synced 2026-11-21 20:38:15 +00:00
security(meta): bound namespace declarations in scope while parsing XMP
* security(meta): bound namespace declarations in scope while parsing XMP * address review: a readable sidecar that fails the merge read-back is kept and the save fails * address review: a sidecar over the XMP complexity limit is kept and the save fails * merge main into fix/sec-xmp-namespace-bound * address review: text with no rdf:RDF element is backed up and replaced, not kept as readable * xmp merge: open a self-closing rdf:RDF element instead of replacing the sidecar
This commit is contained in:
@@ -784,17 +784,28 @@ fn sidecar_contents(path: &Path, fresh: String, stamp: &str) -> std::io::Result<
|
||||
return Ok((fresh, false, None));
|
||||
}
|
||||
let rules = lightcraft_meta::MergeRules { owned: OWNED, owned_if_present: OWNED_IF_STATED };
|
||||
match std::str::from_utf8(&bytes)
|
||||
.map_err(|e| e.to_string())
|
||||
.and_then(|old| lightcraft_meta::merge_xmp(old, &fresh, rules).map_err(|e| e.to_string()))
|
||||
{
|
||||
Ok(merged) => Ok((merged, true, None)),
|
||||
Err(why) => {
|
||||
let b = backup(path, stamp)?;
|
||||
log::warn!("{}: not readable as XMP ({why}); kept a copy as {} before replacing it", path.display(), b.display());
|
||||
Ok((fresh, false, Some(b)))
|
||||
}
|
||||
}
|
||||
let why = match std::str::from_utf8(&bytes) {
|
||||
Ok(old) => match lightcraft_meta::merge_xmp(old, &fresh, rules) {
|
||||
Ok(merged) => return Ok((merged, true, None)),
|
||||
// a readable sidecar whose merge fails (e.g. the merged packet exceeds the XMP limits), or one
|
||||
// that is valid but over the parser's complexity limits: fail the save and keep the file
|
||||
// as it is, rather than replace metadata that could be read
|
||||
// (text with no `rdf:RDF` element parses as empty metadata but holds nothing to keep: it is replaced
|
||||
// after a backup, as any sidecar that is not XMP)
|
||||
Err(why)
|
||||
if why == lightcraft_meta::XmpError::TooComplex
|
||||
|| (lightcraft_meta::parse_xmp(old.strip_prefix('\u{feff}').unwrap_or(old)).is_ok()
|
||||
&& !matches!(&why, lightcraft_meta::XmpError::Xml(m) if m.contains("no rdf:RDF element"))) =>
|
||||
{
|
||||
return Err(std::io::Error::other(format!("the sidecar is readable but could not be merged ({why}); it was left unchanged")));
|
||||
}
|
||||
Err(why) => why.to_string(),
|
||||
},
|
||||
Err(why) => why.to_string(),
|
||||
};
|
||||
let b = backup(path, stamp)?;
|
||||
log::warn!("{}: not readable as XMP ({why}); kept a copy as {} before replacing it", path.display(), b.display());
|
||||
Ok((fresh, false, Some(b)))
|
||||
}
|
||||
|
||||
/// Key of the stem sidecar a file maps to (case-insensitive).
|
||||
@@ -1595,6 +1606,62 @@ mod tests {
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
/// A readable sidecar whose merged packet fails read-back (too many namespace declarations in scope) is kept: the
|
||||
/// save fails instead of moving it to a backup and writing fresh content only.
|
||||
#[test]
|
||||
fn a_readable_sidecar_that_cannot_be_merged_is_kept() {
|
||||
let dir = std::env::temp_dir().join(format!("lightcraft-sidecar-keep-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let decls: String = (0..500).map(|i| format!(" xmlns:n{i}=\"urn:n:{i}\"")).collect();
|
||||
let old = format!(
|
||||
"<x:xmpmeta xmlns:x=\"adobe:ns:meta/\"><rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"{decls}><rdf:Description rdf:about=\"\"/></rdf:RDF></x:xmpmeta>"
|
||||
);
|
||||
assert!(lightcraft_meta::parse_xmp(&old).is_ok(), "the existing sidecar is readable");
|
||||
let path = dir.join("a.xmp");
|
||||
std::fs::write(&path, &old).unwrap();
|
||||
let fresh = lightcraft_meta::write_xmp_lc(&lightcraft_meta::Metadata { rating: Some(3), ..Default::default() }, &[("settings", "{}")]);
|
||||
assert!(super::sidecar_contents(&path, fresh, "t").is_err());
|
||||
assert_eq!(std::fs::read_to_string(&path).unwrap(), old);
|
||||
assert_eq!(std::fs::read_dir(&dir).unwrap().count(), 1, "no backup was made");
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
/// Text that is not XMP at all (it parses as empty metadata, but has no `rdf:RDF` element) is backed up and replaced.
|
||||
#[test]
|
||||
fn a_sidecar_with_no_rdf_element_is_backed_up_and_replaced() {
|
||||
let dir = std::env::temp_dir().join(format!("lightcraft-sidecar-plain-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let path = dir.join("a.xmp");
|
||||
std::fs::write(&path, "not xml at all").unwrap();
|
||||
let fresh = lightcraft_meta::write_xmp_lc(&lightcraft_meta::Metadata { rating: Some(3), ..Default::default() }, &[("settings", "{}")]);
|
||||
let (data, merged, backup) = super::sidecar_contents(&path, fresh.clone(), "t").unwrap();
|
||||
assert!(!merged && data == fresh);
|
||||
assert!(backup.is_some_and(|b| std::fs::read_to_string(b).unwrap() == "not xml at all"));
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
/// A sidecar over the parser's namespace-declaration limit cannot be read or merged: the save fails and the file stays.
|
||||
#[test]
|
||||
fn a_sidecar_over_the_complexity_limit_is_kept() {
|
||||
let dir = std::env::temp_dir().join(format!("lightcraft-sidecar-complex-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let decls: String = (0..600).map(|i| format!(" xmlns:n{i}=\"urn:n:{i}\"")).collect();
|
||||
let old = format!(
|
||||
"<x:xmpmeta xmlns:x=\"adobe:ns:meta/\"><rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"{decls}><rdf:Description rdf:about=\"\"/></rdf:RDF></x:xmpmeta>"
|
||||
);
|
||||
assert_eq!(lightcraft_meta::parse_xmp(&old).unwrap_err(), lightcraft_meta::XmpError::TooComplex);
|
||||
let path = dir.join("a.xmp");
|
||||
std::fs::write(&path, &old).unwrap();
|
||||
let fresh = lightcraft_meta::write_xmp_lc(&lightcraft_meta::Metadata { rating: Some(3), ..Default::default() }, &[("settings", "{}")]);
|
||||
assert!(super::sidecar_contents(&path, fresh, "t").is_err());
|
||||
assert_eq!(std::fs::read_to_string(&path).unwrap(), old);
|
||||
assert_eq!(std::fs::read_dir(&dir).unwrap().count(), 1, "no backup was made");
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
/// A sidecar written by Lightroom Classic (names flat, paths in `lr:hierarchicalSubject`)
|
||||
/// gives the photo its keywords as paths.
|
||||
#[test]
|
||||
|
||||
@@ -170,6 +170,18 @@ pub(crate) const MAX_OPAQUE_NAME_BYTES: usize = 8 * 1024 * 1024;
|
||||
/// retains its prefix once per property: node limits alone cannot bound that duplication.
|
||||
const MAX_KEY_BYTES: usize = 1 << 20;
|
||||
|
||||
/// Most namespace declarations in scope at once. Prefix lookup scans them, so declarations times the names of a
|
||||
/// start tag is the work; real packets declare a few dozen.
|
||||
const MAX_NS_DECLS: usize = 512;
|
||||
|
||||
/// Refuses a scope stack holding more than [`MAX_NS_DECLS`] declarations (one count per start tag over a stack at most [`MAX_DEPTH`] deep).
|
||||
pub(crate) fn check_scopes(scopes: &[Vec<(String, String)>]) -> Result<(), XmpError> {
|
||||
if scopes.iter().map(Vec::len).sum::<usize>() > MAX_NS_DECLS {
|
||||
return Err(XmpError::TooComplex);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Names canonicalised by namespace URI (see [`NAMESPACES`]); conflicting foreign prefixes are opaque.
|
||||
pub(crate) fn canonical_name(qname: &str, scopes: &[Vec<(String, String)>], opaque_budget: &mut usize) -> Result<String, XmpError> {
|
||||
canonical(qname, scopes, opaque_budget)
|
||||
@@ -298,6 +310,7 @@ fn parse_tree(s: &str) -> Result<Node, XmpError> {
|
||||
}
|
||||
}
|
||||
scopes.push(scope);
|
||||
check_scopes(&scopes)?;
|
||||
let name = canonical(&String::from_utf8_lossy(e.name().as_ref()), &scopes, &mut opaque_budget)?;
|
||||
let attrs =
|
||||
raw_attrs.into_iter().map(|(k, v)| Ok((canonical(&k, &scopes, &mut opaque_budget)?, v))).collect::<Result<_, XmpError>>()?;
|
||||
|
||||
@@ -563,6 +563,15 @@ fn malformed_capture_time_without_fallback_is_not_projected() {
|
||||
assert_eq!(parsed.properties["exif:DateTimeOriginal"], vec!["2026-01-01T".to_string()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_start_tag_with_thousands_of_namespace_declarations_is_refused() {
|
||||
let decls: String = (0..2000).map(|i| format!(" xmlns:p{i}=\"urn:x{i}\"")).collect();
|
||||
let xmp = format!(
|
||||
"<x:xmpmeta xmlns:x=\"adobe:ns:meta/\"><rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"><rdf:Description{decls} p1:a=\"1\"/></rdf:RDF></x:xmpmeta>"
|
||||
);
|
||||
assert!(matches!(parse_xmp(&xmp), Err(XmpError::TooComplex)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn many_ampersands_before_one_semicolon_are_read_once() {
|
||||
// 200 000 `&` then a `;`: each `&` once searched the whole rest of the attribute for the `;`
|
||||
|
||||
@@ -23,7 +23,7 @@ use std::collections::{BTreeSet, HashSet};
|
||||
|
||||
use quick_xml::events::Event;
|
||||
|
||||
use crate::xmp::{MAX_OPAQUE_NAME_BYTES, XmpError, canonical_name, parse_xmp, unescape_attr};
|
||||
use crate::xmp::{MAX_OPAQUE_NAME_BYTES, XmpError, canonical_name, check_scopes, parse_xmp, unescape_attr};
|
||||
|
||||
/// Which properties [`merge_xmp`] takes from the fresh packet. Names are canonical
|
||||
/// `prefix:name` (prefixes as [`crate::parse_xmp`] reports them); `prefix:*` is a whole namespace.
|
||||
@@ -75,6 +75,8 @@ struct Scan {
|
||||
descs: Vec<Desc>,
|
||||
/// Where the first `</rdf:RDF>` starts.
|
||||
rdf_close: Option<usize>,
|
||||
/// The span of a self-closing `<rdf:RDF/>` (used only when there is no `</rdf:RDF>`).
|
||||
rdf_empty: Option<(usize, usize)>,
|
||||
}
|
||||
|
||||
enum Kind {
|
||||
@@ -132,6 +134,7 @@ fn scan(s: &str) -> Result<Scan, XmpError> {
|
||||
raw_attrs.push((k, v));
|
||||
}
|
||||
scopes.push(scope);
|
||||
check_scopes(&scopes)?;
|
||||
let raw_name = String::from_utf8_lossy(e.name().as_ref()).into_owned();
|
||||
let name = canonical_name(&raw_name, &scopes, &mut opaque_budget)?;
|
||||
let kind = match stack.last() {
|
||||
@@ -148,6 +151,9 @@ fn scan(s: &str) -> Result<Scan, XmpError> {
|
||||
_ => Kind::Other,
|
||||
};
|
||||
if empty {
|
||||
if matches!(kind, Kind::Rdf) {
|
||||
out.rdf_empty = out.rdf_empty.or(Some((before, after)));
|
||||
}
|
||||
scopes.pop();
|
||||
if let Kind::Prop { desc, start, name } = kind
|
||||
&& let Some(d) = out.descs.get_mut(desc)
|
||||
@@ -213,7 +219,9 @@ pub fn merge_xmp(existing: &str, fresh: &str, rules: MergeRules) -> Result<Strin
|
||||
};
|
||||
parse_xmp(old)?;
|
||||
let ex = scan(old)?;
|
||||
let rdf_close = ex.rdf_close.ok_or_else(|| XmpError::Xml("no rdf:RDF element".into()))?;
|
||||
if ex.rdf_close.is_none() && ex.rdf_empty.is_none() {
|
||||
return Err(XmpError::Xml("no rdf:RDF element".into()));
|
||||
}
|
||||
let new = scan(fresh)?;
|
||||
let fresh_desc = new.descs.first().ok_or_else(|| XmpError::Xml("the new packet has no rdf:Description".into()))?;
|
||||
let fresh_names: BTreeSet<&str> = fresh_desc.props.iter().map(|p| p.name.as_str()).collect();
|
||||
@@ -261,8 +269,16 @@ pub fn merge_xmp(existing: &str, fresh: &str, rules: MergeRules) -> Result<Strin
|
||||
}
|
||||
block.push_str("\n </rdf:Description>");
|
||||
if written > 0 {
|
||||
let at = old.get(..rdf_close).map_or(rdf_close, |h| h.trim_end().len());
|
||||
edits.push((at, at, block));
|
||||
if let Some(rdf_close) = ex.rdf_close {
|
||||
let at = old.get(..rdf_close).map_or(rdf_close, |h| h.trim_end().len());
|
||||
edits.push((at, at, block));
|
||||
} else if let Some((s, e)) = ex.rdf_empty {
|
||||
// a self-closing `<rdf:RDF .../>` is opened up around the new description
|
||||
let tag = old.get(s..e).ok_or_else(|| XmpError::Xml("bad span".into()))?;
|
||||
let open = tag.trim_end().strip_suffix("/>").ok_or_else(|| XmpError::Xml("bad rdf:RDF tag".into()))?;
|
||||
let name = tag.get(1..).and_then(|t| t.split(|c: char| c.is_whitespace() || c == '/' || c == '>').next()).unwrap_or("rdf:RDF");
|
||||
edits.push((s, e, format!("{open}>{block}\n</{name}>")));
|
||||
}
|
||||
}
|
||||
edits.sort_by_key(|e| (e.0, e.1));
|
||||
// overlapping edits can't happen (properties sit inside their description, which is either
|
||||
@@ -386,6 +402,16 @@ mod tests {
|
||||
assert_eq!(merge_xmp(&again, &fresh(1, &[]), RULES).unwrap(), again, "idempotent");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_self_closing_rdf_element_is_opened_not_replaced() {
|
||||
let ex = "<!-- keep me --><x:xmpmeta xmlns:x=\"adobe:ns:meta/\"><r:RDF xmlns:r=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"/></x:xmpmeta>";
|
||||
let out = merge_xmp(ex, &fresh(3, &[]), RULES).unwrap();
|
||||
assert!(out.starts_with("<!-- keep me --><x:xmpmeta"), "{out}");
|
||||
assert!(out.contains("</r:RDF></x:xmpmeta>"), "{out}");
|
||||
assert_eq!(parse_xmp(&out).unwrap().properties.get("xmp:Rating"), Some(&vec!["3".to_string()]));
|
||||
assert!(merge_xmp("<x:xmpmeta xmlns:x=\"adobe:ns:meta/\"/>", &fresh(3, &[]), RULES).is_err(), "no RDF element at all");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn owned_if_present_and_prefix_independence() {
|
||||
// the existing packet binds the namespaces to other prefixes, and has a capture time
|
||||
|
||||
Reference in New Issue
Block a user