π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
use crate::Mode;
use crate::read::{Error, OutputBudget, State};
use quick_xml::events::Event;
use quick_xml::name::ResolveResult;
use quick_xml::{NsReader, XmlVersion};
use std::borrow::Cow;
pub mod namespace {
pub const EXIF: &str = "http://ns.adobe.com/exif/1.0/";
pub const EXIF_EX: &str = "http://cipa.jp/exif/1.0/";
pub const TIFF: &str = "http://ns.adobe.com/tiff/1.0/";
pub const XMP: &str = "http://ns.adobe.com/xap/1.0/";
pub const DC: &str = "http://purl.org/dc/elements/1.1/";
pub const PHOTOSHOP: &str = "http://ns.adobe.com/photoshop/1.0/";
pub const GPANO: &str = "http://ns.google.com/photos/1.0/panorama/";
pub const CAMERA: &str = "http://ns.google.com/photos/1.0/camera/";
pub const CONTAINER: &str = "http://ns.google.com/photos/1.0/container/";
pub const ITEM: &str = "http://ns.google.com/photos/1.0/container/item/";
pub const NOTE: &str = "http://ns.adobe.com/xmp/note/";
pub const RDF: &str = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
pub const XML: &str = "http://www.w3.org/XML/1998/namespace";
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Property {
pub namespace: String,
pub name: String,
pub value: String,
pub language: Option<String>,
pub item: Option<u32>,
}
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct XmpStructure {
pub nodes: Vec<XmpNode>,
pub parents: Vec<Option<u32>>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct XmpNode {
pub namespace: String,
pub name: String,
pub parent: Option<u32>,
pub item: Option<u32>,
}
pub(crate) fn read(bytes: &[u8], state: &mut State) -> Result<(), Error> {
if bytes.len() > state.limits.read_bytes {
return Err(Error::Limit("XMP bytes"));
}
let text = text(bytes, state)?;
let mut reader = NsReader::from_str(text.trim_end_matches('\0'));
reader.resolver_mut().set_max_namespace_bindings(64);
let mut stack: Vec<Frame> = Vec::new();
let mut paths = Vec::new();
let mut item_id = state
.metadata
.xmp
.iter()
.filter_map(|p| p.item)
.max()
.unwrap_or(0);
let mut saw_rdf = false;
let mut saw_root = false;
loop {
state.entries(1)?;
let event = reader
.read_event()
.map_err(|_| Error::Malformed("XMP XML"))?;
let empty = matches!(event, Event::Empty(_));
match event {
Event::Start(element) | Event::Empty(element) => {
if stack.is_empty() {
if saw_root {
return Err(Error::Malformed("multiple XML roots"));
}
saw_root = true;
}
if stack.len() >= state.limits.depth {
return Err(Error::Limit("XML depth"));
}
let (ns, local) = reader.resolver().resolve_element(element.name());
let ns = namespace_text(ns)?;
let name = local.as_ref();
if ns.len() + name.len() > state.limits.value_bytes {
return Err(Error::Limit("XML name"));
}
saw_rdf |= ns == namespace::RDF && name == "RDF";
let item = if ns == namespace::RDF && name == "li" {
item_id = item_id.checked_add(1).ok_or(Error::Limit("RDF items"))?;
Some(item_id)
} else {
stack.last().and_then(|f| f.item)
};
let mut language = stack.last().and_then(|f| f.language.clone());
for attribute in element.attributes() {
let attribute = attribute.map_err(|_| Error::Malformed("XML attribute"))?;
if attribute.key.as_ref() == "xml:lang" {
if attribute.value.len() > state.limits.value_bytes {
return Err(Error::Limit("XML language"));
}
language = Some(
attribute
.normalized_value(XmlVersion::Implicit1_0)
.map_err(|_| Error::Malformed("XML language"))?
.into_owned(),
);
}
}
if state.structure.is_some() {
let key = if ns == "adobe:ns:meta/"
|| (ns == namespace::RDF && !matches!(name, "Bag" | "Seq" | "Alt" | "li"))
{
None
} else {
Some((ns.to_owned(), name.to_owned()))
};
paths.push(PathFrame {
key,
item,
node: None,
ready: false,
});
}
let key = if ns == namespace::RDF {
stack.last().and_then(|f| f.key.clone())
} else if ns == "adobe:ns:meta/" || !wanted(state.mode, ns, name) {
None
} else {
Some((ns.to_owned(), name.to_owned()))
};
stack.push(Frame {
key,
language,
item,
text: String::new(),
});
for attribute in element.attributes() {
state.entries(1)?;
let attribute = attribute.map_err(|_| Error::Malformed("XML attribute"))?;
if attribute.key.as_ref() == "xmlns"
|| attribute.key.as_ref().starts_with("xmlns:")
{
continue;
}
let (ans, aname) = reader.resolver().resolve_attribute(attribute.key);
let ans = namespace_text(ans)?;
let aname = aname.as_ref();
let (ans, aname) = if ans == namespace::RDF && aname == "resource" {
let Some((ns, name)) = stack.last().and_then(|f| f.key.as_ref()) else {
continue;
};
(ns.as_str(), name.as_str())
} else if ans == namespace::RDF || ans == namespace::XML || ans.is_empty() {
continue;
} else {
(ans, aname)
};
if !wanted(state.mode, ans, aname) {
continue;
}
if attribute.value.len() > state.limits.value_bytes {
return Err(Error::Limit("XML attribute"));
}
let value = attribute
.normalized_value(XmlVersion::Implicit1_0)
.map_err(|_| Error::Malformed("XML attribute value"))?;
let language = stack.last().and_then(|f| f.language.as_deref());
let parent = if let Some(structure) = &mut state.structure {
path(&mut paths, &mut structure.nodes, &mut state.output)?
} else {
None
};
store(state, ans, aname, &value, language, item, parent)?;
}
if empty {
finish(&mut stack, &mut paths, state)?;
}
}
Event::End(_) => {
finish(&mut stack, &mut paths, state)?;
}
Event::Text(text) => {
if stack.last().is_some_and(|f| f.key.is_none()) {
continue;
}
let text = text.xml_content(XmlVersion::Implicit1_0);
append(&mut stack, &text, state)?;
}
Event::CData(text) => {
if stack.last().is_some_and(|f| f.key.is_none()) {
continue;
}
append(&mut stack, text.as_ref(), state)?;
}
Event::GeneralRef(entity) => {
let text = if let Some(c) = entity
.resolve_char_ref()
.map_err(|_| Error::Malformed("XML character reference"))?
{
c.to_string()
} else {
match entity.as_ref() {
"amp" => "&",
"lt" => "<",
"gt" => ">",
"apos" => "'",
"quot" => "\"",
_ => return Err(Error::Unsupported("XML entity")),
}
.to_owned()
};
append(&mut stack, &text, state)?;
}
Event::DocType(_) => return Err(Error::Unsupported("XML DTD")),
Event::Eof => break,
_ => {}
}
}
if !stack.is_empty() {
return Err(Error::Malformed("unclosed XML"));
}
if !saw_rdf {
return Err(Error::Unsupported("XMP document"));
}
Ok(())
}
fn text<'a>(bytes: &'a [u8], state: &mut State) -> Result<Cow<'a, str>, Error> {
let little = bytes.starts_with(b"\xff\xfe");
if !little && !bytes.starts_with(b"\xfe\xff") {
return std::str::from_utf8(bytes)
.map(Cow::Borrowed)
.map_err(|_| Error::Unsupported("XMP encoding"));
}
if !bytes.len().is_multiple_of(2) {
return Err(Error::Malformed("UTF-16 XMP"));
}
let units = bytes[2..].as_chunks::<2>().0.iter().map(|b| {
if little {
u16::from_le_bytes(*b)
} else {
u16::from_be_bytes(*b)
}
});
let mut decoded = String::with_capacity(bytes.len());
for ch in char::decode_utf16(units) {
let ch = ch.map_err(|_| Error::Malformed("UTF-16 XMP"))?;
if decoded.len() + ch.len_utf8() > state.limits.read_bytes {
return Err(Error::Limit("XMP bytes"));
}
decoded.push(ch);
}
state.expanded(decoded.len())?;
Ok(Cow::Owned(decoded))
}
pub(crate) fn store(
state: &mut State,
ns: &str,
name: &str,
value: &str,
language: Option<&str>,
item: Option<u32>,
parent: Option<u32>,
) -> Result<(), Error> {
if !wanted(state.mode, ns, name) {
return Ok(());
}
if value.len() > state.limits.value_bytes {
return Err(Error::Limit("property value"));
}
state.retain(
std::mem::size_of::<Property>()
+ ns.len()
+ name.len()
+ value.len()
+ language.map_or(0, str::len),
)?;
if let Some(structure) = &mut state.structure {
state.output.retain(std::mem::size_of::<Option<u32>>())?;
structure.parents.push(parent);
}
state.metadata.xmp.push(Property {
namespace: ns.to_owned(),
name: name.to_owned(),
value: value.to_owned(),
language: language.map(str::to_owned),
item,
});
Ok(())
}
fn wanted(mode: Mode, ns: &str, name: &str) -> bool {
if ns == namespace::CAMERA && name == "HdrPlusMakernote" {
return false;
}
mode == Mode::Details || selected(ns, name)
}
fn selected(ns: &str, name: &str) -> bool {
match ns {
namespace::EXIF | namespace::EXIF_EX | namespace::TIFF => matches!(
name,
"DateTimeOriginal"
| "DateTimeDigitized"
| "DateTime"
| "ImageWidth"
| "ImageLength"
| "PixelXDimension"
| "PixelYDimension"
| "Orientation"
| "GPSLatitude"
| "GPSLongitude"
| "GPSLatitudeRef"
| "GPSLongitudeRef"
| "Make"
| "Model"
),
namespace::XMP => matches!(name, "CreateDate" | "ModifyDate" | "MetadataDate"),
namespace::PHOTOSHOP => name == "DateCreated",
namespace::DC => name == "description",
namespace::GPANO => name == "ProjectionType",
namespace::CAMERA => matches!(
name,
"MotionPhoto"
| "MicroVideo"
| "MicroVideoOffset"
| "MotionPhotoPresentationTimestampUs"
),
namespace::ITEM => matches!(name, "Mime" | "Semantic" | "Length" | "Padding"),
namespace::NOTE => name == "HasExtendedXMP",
_ => false,
}
}
struct Frame {
key: Option<(String, String)>,
language: Option<String>,
item: Option<u32>,
text: String,
}
struct PathFrame {
key: Option<(String, String)>,
item: Option<u32>,
node: Option<u32>,
ready: bool,
}
fn path(
stack: &mut [PathFrame],
nodes: &mut Vec<XmpNode>,
output: &mut OutputBudget,
) -> Result<Option<u32>, Error> {
let Some((frame, rest)) = stack.split_last_mut() else {
return Ok(None);
};
if frame.ready {
return Ok(frame.node);
}
let parent = path(rest, nodes, output)?;
frame.ready = true;
let Some((ns, name)) = &frame.key else {
frame.node = parent;
return Ok(parent);
};
output.retain(std::mem::size_of::<XmpNode>() + ns.len() + name.len())?;
let index = u32::try_from(nodes.len()).map_err(|_| Error::Limit("XMP nodes"))?;
nodes.push(XmpNode {
namespace: ns.to_owned(),
name: name.to_owned(),
parent,
item: frame.item,
});
frame.node = Some(index);
Ok(Some(index))
}
fn append(stack: &mut [Frame], text: &str, state: &State) -> Result<(), Error> {
if let Some(frame) = stack.last_mut() {
if frame.key.is_none() {
return Ok(());
}
if text.len() > state.limits.value_bytes.saturating_sub(frame.text.len()) {
return Err(Error::Limit("XML text"));
}
frame.text.push_str(text);
} else if !text.trim().is_empty() {
return Err(Error::Malformed("XML text outside root"));
}
Ok(())
}
fn finish(
stack: &mut Vec<Frame>,
paths: &mut Vec<PathFrame>,
state: &mut State,
) -> Result<(), Error> {
let frame = stack.pop().ok_or(Error::Malformed("XML nesting"))?;
if let Some((ns, name)) = frame.key
&& !frame.text.trim().is_empty()
{
let parent = if let Some(structure) = &mut state.structure {
let is_item = paths
.last()
.and_then(|p| p.key.as_ref())
.is_some_and(|(ns, n)| ns == namespace::RDF && n == "li");
let len = paths.len() - usize::from(!is_item);
path(&mut paths[..len], &mut structure.nodes, &mut state.output)?
} else {
None
};
store(
state,
&ns,
&name,
frame.text.trim(),
frame.language.as_deref(),
frame.item,
parent,
)?;
}
paths.pop();
Ok(())
}
fn namespace_text(ns: ResolveResult<'_>) -> Result<&str, Error> {
match ns {
ResolveResult::Bound(ns) => Ok(ns.0),
ResolveResult::Unbound => Ok(""),
ResolveResult::Unknown(_) => Err(Error::Malformed("undeclared XML namespace")),
}
}