Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

Fix metadata resource recovery and PNG text selection

Neeraj Gupta8352d2ee878f
diff --git a/rust/crates/exif/src/isobmff.rs b/rust/crates/exif/src/isobmff.rs
index 2244306f12..1115698641 100644
--- a/rust/crates/exif/src/isobmff.rs
+++ b/rust/crates/exif/src/isobmff.rs
@@ -40,6 +40,7 @@ pub(crate) fn read<R: Read + Seek>(
struct Item {
kind: [u8; 4],
mime: String,
+ protected: bool,
location: Option<Location>,
describes: Vec<u32>,
}
@@ -191,6 +192,9 @@ fn read_item<R: Read + Seek>(
idat: Option<&BoxRange>,
is_exif: bool,
) -> Result<(), Error> {
+ if item.protected {
+ return Err(Error::Unsupported("protected metadata"));
+ }
let location = item
.location
.as_ref()
@@ -283,15 +287,13 @@ fn item_info<R: Read + Seek>(
} else {
String::new()
};
- if protection != 0 && (&kind == b"Exif" || mime == "application/rdf+xml") {
- return Err(Error::Unsupported("protected metadata"));
- }
let item = meta.items.entry(id).or_default();
if item.kind != [0; 4] {
return Err(Error::Malformed("duplicate item info"));
}
item.kind = kind;
item.mime = mime;
+ item.protected = protection != 0;
}
Ok(())
}
diff --git a/rust/crates/exif/src/photoshop.rs b/rust/crates/exif/src/photoshop.rs
index d133feffb5..5bd56faa69 100644
--- a/rust/crates/exif/src/photoshop.rs
+++ b/rust/crates/exif/src/photoshop.rs
@@ -16,14 +16,15 @@ pub(crate) fn read(data: &[u8], state: &mut State) -> Result<(), Error> {
let name_length = cursor.number(1)? as usize;
cursor.take(name_length + ((name_length + 1) & 1))?;
let size = cursor.number(4)? as usize;
+ let offset = cursor.pos as u64;
let value = cursor.take(size)?;
cursor.take(size & 1)?;
- if id == 0x404 {
- iptc::read(value, state)?;
- }
- if id == 0x424 {
- xmp::read(value, state)?;
- }
+ let result = match id {
+ 0x404 => iptc::read(value, state),
+ 0x424 => xmp::read(value, state),
+ _ => Ok(()),
+ };
+ state.recover(offset, result)?;
}
Ok(())
}
diff --git a/rust/crates/exif/src/png.rs b/rust/crates/exif/src/png.rs
index 1cb6c518cd..e8543f3373 100644
--- a/rust/crates/exif/src/png.rs
+++ b/rust/crates/exif/src/png.rs
@@ -3,6 +3,8 @@ use crate::{Dimensions, Mode, iptc, photoshop, tiff, xmp};
use std::borrow::Cow;
use std::io::{Read, Seek};
+const MAX_KEYWORD_LEN: usize = 79;
+
pub(crate) fn read<R: Read + Seek>(
reader: &mut Reader<'_, R>,
state: &mut State,
@@ -24,9 +26,7 @@ pub(crate) fn read<R: Read + Seek>(
Ok(())
}
b"eXIf" => tiff::read(reader, state, start, len),
- b"iTXt" | b"zTXt" | b"tEXt" => {
- text(&reader.bytes(start, len as usize)?, &header[4..], state)
- }
+ b"iTXt" | b"zTXt" | b"tEXt" => text(reader, start, len as usize, &header[4..], state),
b"IEND" => {
if len != 0 || state.metadata.dimensions.is_none() {
return Err(Error::Malformed("PNG IEND"));
@@ -41,12 +41,45 @@ pub(crate) fn read<R: Read + Seek>(
Err(Error::Malformed("missing PNG IEND"))
}
-fn text(data: &[u8], kind: &[u8], state: &mut State) -> Result<(), Error> {
- let mut cursor = Cursor::new(data);
+fn text<R: Read + Seek>(
+ reader: &mut Reader<'_, R>,
+ start: u64,
+ len: usize,
+ kind: &[u8],
+ state: &mut State,
+) -> Result<(), Error> {
+ let mut header = [0; MAX_KEYWORD_LEN + 1];
+ let header = &mut header[..len.min(MAX_KEYWORD_LEN + 1)];
+ reader.fill(start, header)?;
+ let mut cursor = Cursor::new(header);
let key = cursor.terminated_bytes()?;
- if !(1..=79).contains(&key.len()) {
+ if !(1..=MAX_KEYWORD_LEN).contains(&key.len()) {
return Err(Error::Malformed("PNG keyword"));
}
+ let is_profile = matches!(
+ key,
+ b"Raw profile type exif"
+ | b"Raw profile type APP1"
+ | b"Raw profile type iptc"
+ | b"Raw profile type 8bim"
+ | b"Raw profile type xmp"
+ );
+ if key != b"XML:com.adobe.xmp" && !is_profile && state.mode == Mode::Summary {
+ return Ok(());
+ }
+ let prefix = &header[cursor.pos..];
+ let data = if len == header.len() {
+ Cow::Borrowed(prefix)
+ } else {
+ let remaining = len - header.len();
+ let offset = start + header.len() as u64;
+ reader.check(offset, remaining)?;
+ let mut data = vec![0; prefix.len() + remaining];
+ data[..prefix.len()].copy_from_slice(prefix);
+ reader.fill(offset, &mut data[prefix.len()..])?;
+ Cow::Owned(data)
+ };
+ let mut cursor = Cursor::new(&data);
let mut compressed = false;
let mut language = None;
if kind == b"iTXt" {
@@ -64,17 +97,6 @@ fn text(data: &[u8], kind: &[u8], state: &mut State) -> Result<(), Error> {
}
compressed = true;
}
- let is_profile = matches!(
- key,
- b"Raw profile type exif"
- | b"Raw profile type APP1"
- | b"Raw profile type iptc"
- | b"Raw profile type 8bim"
- | b"Raw profile type xmp"
- );
- if key != b"XML:com.adobe.xmp" && !is_profile && state.mode == Mode::Summary {
- return Ok(());
- }
let bytes = &data[cursor.pos..];
let decoded;
let text = if compressed {
diff --git a/rust/crates/exif/src/read.rs b/rust/crates/exif/src/read.rs
index c74c7d7a5d..c4ef6ab818 100644
--- a/rust/crates/exif/src/read.rs
+++ b/rust/crates/exif/src/read.rs
@@ -119,7 +119,7 @@ impl<'a, R: Read + Seek> Reader<'a, R> {
Ok(())
}
- fn check(&self, offset: u64, count: usize) -> Result<(), Error> {
+ pub fn check(&self, offset: u64, count: usize) -> Result<(), Error> {
if offset > self.len || count as u64 > self.len - offset {
return Err(Error::Malformed("range"));
}
diff --git a/rust/crates/exif/tests/integration/formats.rs b/rust/crates/exif/tests/integration/formats.rs
index eb72cfc821..15946f3c27 100644
--- a/rust/crates/exif/tests/integration/formats.rs
+++ b/rust/crates/exif/tests/integration/formats.rs
@@ -231,6 +231,68 @@ fn heif_exif_cannot_read_beyond_its_declared_extent() {
}
}
+#[test]
+fn heif_protected_metadata_preserves_image_dimensions() {
+ let exif = [vec![0; 4], tiff(&[(0x112, 3, 1, vec![6, 0])], false)].concat();
+ let packet = xmp("<p:ProjectionType>equirectangular</p:ProjectionType>");
+ for mime in [
+ None,
+ Some("application/rdf+xml"),
+ Some("application/xml"),
+ Some("text/xml"),
+ ] {
+ for protected in [false, true] {
+ let data = if mime.is_some() {
+ packet.as_bytes()
+ } else {
+ &exif
+ };
+ let mut info = vec![2, 0, 0, 0, 0, 2, 0, u8::from(protected)];
+ info.extend(if mime.is_some() { b"mime\0" } else { b"Exif\0" });
+ if let Some(mime) = mime {
+ info.extend(mime.as_bytes());
+ info.extend([0, 0]);
+ }
+ let mut location = vec![1, 0, 0, 0, 0x44, 0, 0, 1, 0, 2, 0, 1, 0, 0, 0, 1];
+ location.extend(0u32.to_be_bytes());
+ location.extend((data.len() as u32).to_be_bytes());
+ let image_size = box_bytes(b"ispe", &[0u32, 640, 480].map(u32::to_be_bytes).concat());
+ let mut properties = box_bytes(b"ipco", &image_size);
+ properties.extend(box_bytes(b"ipma", &[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1]));
+ let mut meta = vec![0; 4];
+ meta.extend(box_bytes(b"pitm", &[0, 0, 0, 0, 0, 1]));
+ meta.extend(box_bytes(
+ b"iinf",
+ &[vec![0, 0, 0, 0, 0, 1], box_bytes(b"infe", &info)].concat(),
+ ));
+ meta.extend(box_bytes(b"iloc", &location));
+ meta.extend(box_bytes(b"iprp", &properties));
+ meta.extend(box_bytes(b"idat", data));
+ let bytes = [
+ box_bytes(b"ftyp", b"heic\0\0\0\0mif1"),
+ box_bytes(b"meta", &meta),
+ ]
+ .concat();
+ for mode in [Mode::Summary, Mode::Details] {
+ let metadata = read(&bytes, mode);
+ assert_eq!(
+ (metadata.width(), metadata.height()),
+ (Some(640), Some(480))
+ );
+ assert_eq!(
+ metadata.orientation(),
+ (!protected && mime.is_none()).then_some(6)
+ );
+ assert_eq!(metadata.is_panorama(), !protected && mime.is_some());
+ assert_eq!(metadata.issues.len(), usize::from(protected));
+ if protected {
+ assert_eq!(metadata.issues[0].message, "protected metadata");
+ }
+ }
+ }
+ }
+}
+
#[test]
fn png_keywords_use_latin1_and_text_obeys_its_chunk_encoding() {
for (kind, value) in [
@@ -304,6 +366,50 @@ fn webp_padding_and_all_frame_headers() {
}
}
+#[test]
+fn png_summary_skips_text_within_a_small_read_budget() {
+ for (kind, fields, compressed) in [
+ (b"tEXt", b"".as_slice(), false),
+ (b"zTXt", b"\0".as_slice(), true),
+ (b"iTXt", b"\0\0en\0Comment\0".as_slice(), false),
+ (b"iTXt", b"\x01\0en\0Comment\0".as_slice(), true),
+ ] {
+ for size in [1024, 4096] {
+ let text = vec![b'a'; size];
+ let text = if compressed {
+ miniz_oxide::deflate::compress_to_vec_zlib(&text, 0)
+ } else {
+ text
+ };
+ let bytes = [
+ b"\x89PNG\r\n\x1a\n".to_vec(),
+ png_chunk(b"IHDR", &[0, 0, 0, 1, 0, 0, 0, 2, 8, 2, 0, 0, 0]),
+ png_chunk(
+ kind,
+ &[vec![b'C'; 79], vec![0], fields.to_vec(), text].concat(),
+ ),
+ png_chunk(b"eXIf", &tiff(&[(0x112, 3, 1, vec![6, 0])], false)),
+ png_chunk(b"IEND", &[]),
+ ]
+ .concat();
+ let limits = ente_exif::Limits {
+ read_bytes: 256,
+ ..ente_exif::Limits::default()
+ };
+ let metadata =
+ ente_exif::read(&mut std::io::Cursor::new(&bytes), Mode::Summary, limits).unwrap();
+ assert_eq!((metadata.width(), metadata.height()), (Some(1), Some(2)));
+ assert_eq!(metadata.orientation(), Some(6));
+ assert!(metadata.issues.is_empty());
+ assert!(metadata.xmp.is_empty());
+ assert!(matches!(
+ ente_exif::read(&mut std::io::Cursor::new(&bytes), Mode::Details, limits),
+ Err(ente_exif::Error::Limit("read bytes"))
+ ));
+ }
+ }
+}
+
#[test]
fn gif_xmp_after_image_subblocks() {
let mut bytes = b"GIF89a\x02\0\x03\0\0\0\0".to_vec();
@@ -357,6 +463,45 @@ fn photoshop_iptc_preserves_encoding_dates_and_caption() {
assert!(metadata.issues.is_empty());
}
+#[test]
+fn photoshop_recovers_each_metadata_resource() {
+ let resource = |id: u16, value: &[u8]| {
+ let mut bytes = b"8BIM".to_vec();
+ bytes.extend(id.to_be_bytes());
+ bytes.extend([0, 0]);
+ bytes.extend((value.len() as u32).to_be_bytes());
+ bytes.extend(value);
+ bytes.resize(bytes.len() + (value.len() & 1), 0);
+ bytes
+ };
+ let packet = xmp("<p:ProjectionType>equirectangular</p:ProjectionType>");
+ for (id, malformed) in [
+ (0x404, b"\x1c\x02\x78\0\x05x".as_slice()),
+ (0x424, b"<".as_slice()),
+ ] {
+ let resources = [
+ b"Photoshop 3.0\0".to_vec(),
+ resource(id, malformed),
+ resource(0x424, packet.as_bytes()),
+ ]
+ .concat();
+ let jpeg = [
+ vec![0xff, 0xd8],
+ segment(0xed, &resources),
+ jpeg(&[], "")[2..].to_vec(),
+ ]
+ .concat();
+ let tiff = tiff(&[(0x8649, 7, resources.len() as u32, resources)], false);
+ for bytes in [&jpeg, &tiff] {
+ for mode in [Mode::Summary, Mode::Details] {
+ let metadata = read(bytes, mode);
+ assert!(metadata.is_panorama());
+ assert_eq!(metadata.issues.len(), 1);
+ }
+ }
+ }
+}
+
#[test]
fn iptc_zero_tail_and_malformed_tail_recovery() {
for tail in [b"".as_slice(), b"\0", b"\0\0", b"\0\0\0", b"\0\x01"] {