π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
use crate::boxes::{BoxRange, box_at};
use crate::read::{Cursor, Error, Reader, State, be32, range};
use crate::{CleanAperture, Dimensions, Rational, Transform, tiff, xmp};
use std::collections::BTreeMap;
use std::io::{Read, Seek};
pub(crate) fn read<R: Read + Seek>(
reader: &mut Reader<'_, R>,
state: &mut State,
) -> Result<(), Error> {
let first = box_at(reader, 0, reader.len)?;
let brands = reader.bytes(
first.start,
usize::try_from(first.len).map_err(|_| Error::Limit("brands"))?,
)?;
if brands.len() < 8
|| !brands.as_chunks::<4>().0.iter().enumerate().any(|(i, b)| {
i != 1
&& matches!(
b,
b"heic" | b"heix" | b"hevc" | b"hevx" | b"mif1" | b"msf1" | b"avif" | b"avis"
)
})
{
return Err(Error::Unsupported("ISOBMFF image brand"));
}
let mut offset = first.end();
while offset < reader.len {
state.entries(1)?;
let b = box_at(reader, offset, reader.len)?;
if &b.kind == b"meta" {
return metadata(reader, state, b);
}
offset = b.end();
}
Err(Error::Malformed("missing HEIF metadata"))
}
#[derive(Default)]
struct Item {
kind: [u8; 4],
mime: String,
protected: bool,
location: Option<Location>,
describes: Vec<u32>,
}
struct Location {
method: u64,
reference: u64,
base: u64,
extents: Vec<(u64, u64)>,
}
#[derive(Default)]
struct Meta {
primary: Option<u32>,
items: BTreeMap<u32, Item>,
properties: Vec<BoxRange>,
associations: Vec<(u32, Vec<(usize, bool)>)>,
idat: Option<BoxRange>,
}
fn metadata<R: Read + Seek>(
reader: &mut Reader<'_, R>,
state: &mut State,
b: BoxRange,
) -> Result<(), Error> {
range(b.start, b.len, 0, 4)?;
let mut meta = Meta::default();
let mut offset = b.start + 4;
while offset < b.end() {
state.entries(1)?;
let child = box_at(reader, offset, b.end())?;
offset = child.end();
match &child.kind {
b"pitm" => {
let bytes = payload(reader, &child)?;
let mut c = Cursor::new(&bytes);
let version = c.number(1)?;
c.take(3)?;
if version > 1 {
return Err(Error::Unsupported("pitm version"));
}
meta.primary = Some(c.number(if version == 0 { 2 } else { 4 })? as u32);
}
b"iinf" => item_info(reader, state, &child, &mut meta)?,
b"iloc" => locations(&payload(reader, &child)?, state, &mut meta)?,
b"iref" => references(reader, state, &child, &mut meta)?,
b"iprp" => properties(reader, state, &child, &mut meta)?,
b"idat" => meta.idat = Some(child),
_ => {}
}
}
let primary = meta.primary.ok_or(Error::Malformed("primary image"))?;
for (_, props) in meta.associations.iter().filter(|(id, _)| *id == primary) {
for &(index, _) in props {
if index == 0 {
continue;
}
let p = meta
.properties
.get(index - 1)
.ok_or(Error::Malformed("property index"))?;
match &p.kind {
b"ispe" => {
if p.len != 12 {
return Err(Error::Malformed("ispe size"));
}
let bytes = reader.array::<8>(p.start + 4)?;
state.metadata.dimensions = Dimensions::new(be32(&bytes), be32(&bytes[4..]));
}
b"irot" | b"imir" => {
if p.len != 1 {
return Err(Error::Malformed("transform size"));
}
let value = reader.array::<1>(p.start)?[0];
let transform = if &p.kind == b"irot" && value <= 3 {
Transform::Rotate(value)
} else if &p.kind == b"imir" && value <= 1 {
Transform::Mirror(value)
} else {
return Err(Error::Malformed("transform value"));
};
state.retain(std::mem::size_of::<Transform>())?;
state.metadata.transforms.push(transform);
}
b"clap" => {
if p.len != 32 {
return Err(Error::Malformed("clap size"));
}
let bytes = reader.array::<32>(p.start)?;
let rational = |offset, signed| -> Result<Rational, Error> {
let n = be32(&bytes[offset..]);
let d = be32(&bytes[offset + 4..]);
if d == 0 {
return Err(Error::Malformed("clap denominator"));
}
Ok(Rational {
numerator: if signed {
i64::from(n as i32)
} else {
i64::from(n)
},
denominator: i64::from(d),
})
};
let crop = CleanAperture {
width: rational(0, false)?,
height: rational(8, false)?,
horizontal_offset: rational(16, true)?,
vertical_offset: rational(24, true)?,
};
state.retain(std::mem::size_of::<Transform>())?;
state.metadata.transforms.push(Transform::Crop(crop));
}
_ => {}
}
}
}
for is_exif in [true, false] {
let candidates = meta.items.values().filter(|item| {
if is_exif {
&item.kind == b"Exif"
} else {
&item.kind == b"mime"
&& matches!(
item.mime.as_str(),
"application/rdf+xml" | "application/xml" | "text/xml"
)
}
});
let has_primary = candidates
.clone()
.any(|item| item.describes.contains(&primary));
let mut candidates = candidates.filter(|item| {
if has_primary {
item.describes.contains(&primary)
} else {
item.describes.is_empty()
}
});
let Some(item) = candidates.next() else {
continue;
};
if candidates.next().is_some() {
state.recover(
b.start,
Err(Error::Unsupported("ambiguous primary metadata")),
)?;
continue;
}
let result = read_item(reader, state, item, meta.idat.as_ref(), is_exif);
state.recover(b.start, result)?;
}
Ok(())
}
fn read_item<R: Read + Seek>(
reader: &mut Reader<'_, R>,
state: &mut State,
item: &Item,
idat: Option<&BoxRange>,
is_exif: bool,
) -> Result<(), Error> {
if item.protected {
return Err(Error::Unsupported("protected metadata"));
}
let location = item
.location
.as_ref()
.ok_or(Error::Malformed("missing item location"))?;
if location.reference != 0 {
return Err(Error::Unsupported("external item reference"));
}
let (origin, len) = match location.method {
0 => (0, reader.len),
1 => {
let b = idat.ok_or(Error::Malformed("missing idat"))?;
(b.start, b.len)
}
_ => return Err(Error::Unsupported("item construction method")),
};
if location.extents.is_empty() {
return Err(Error::Malformed("missing item extents"));
}
let extent = |(offset, size)| {
if size == 0 {
return Err(Error::Unsupported("unbounded item extent"));
}
let offset = location
.base
.checked_add(offset)
.ok_or(Error::Malformed("extent offset overflow"))?;
Ok((range(origin, len, offset, size)?, size))
};
if is_exif && let [single] = location.extents.as_slice() {
let (start, len) = extent(*single)?;
return tiff::exif_block(reader, state, start, len);
}
let total = location.extents.iter().try_fold(0u64, |sum, (_, size)| {
sum.checked_add(*size)
.ok_or(Error::Malformed("extent length overflow"))
})?;
if total > state.limits.read_bytes as u64 {
return Err(Error::Limit("item bytes"));
}
let mut bytes = Vec::with_capacity(total as usize);
for &item in &location.extents {
let (absolute, size) = extent(item)?;
let previous = bytes.len();
bytes.resize(previous + size as usize, 0);
reader.fill(absolute, &mut bytes[previous..])?;
}
if is_exif {
let mut cursor = std::io::Cursor::new(&bytes);
let mut buffer = Reader::new(&mut cursor, state.limits)?;
tiff::exif_block(&mut buffer, state, 0, total)
} else {
xmp::read(&bytes, state)
}
}
fn item_info<R: Read + Seek>(
reader: &mut Reader<'_, R>,
state: &mut State,
b: &BoxRange,
meta: &mut Meta,
) -> Result<(), Error> {
if b.len < 6 {
return Err(Error::Malformed("iinf header"));
}
let version = reader.array::<1>(b.start)?[0];
let width = if version == 0 { 2 } else { 4 };
let bytes = reader.bytes(b.start + 4, width)?;
let count = Cursor::new(&bytes).number(width)? as usize;
state.entries(count)?;
let mut offset = b.start + 4 + width as u64;
for _ in 0..count {
let child = box_at(reader, offset, b.end())?;
offset = child.end();
if &child.kind != b"infe" {
return Err(Error::Malformed("item info box"));
}
let bytes = payload(reader, &child)?;
let mut c = Cursor::new(&bytes);
let version = c.number(1)?;
c.take(3)?;
if !matches!(version, 2 | 3) {
return Err(Error::Unsupported("infe version"));
}
let id = c.number(if version == 2 { 2 } else { 4 })? as u32;
let protection = c.number(2)?;
#[expect(
clippy::expect_used,
reason = "take returns exactly the requested four bytes"
)]
let kind: [u8; 4] = c.take(4)?.try_into().expect("item type is four bytes");
c.string()?;
let mime = if &kind == b"mime" {
c.string()?.to_owned()
} else {
String::new()
};
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(())
}
fn locations(bytes: &[u8], state: &mut State, meta: &mut Meta) -> Result<(), Error> {
let mut c = Cursor::new(bytes);
let version = c.number(1)?;
if version > 2 {
return Err(Error::Unsupported("iloc version"));
}
c.take(3)?;
let sizes = c.number(1)? as usize;
let more = c.number(1)? as usize;
let (offset_size, length_size, base_size, index_size) = (
sizes >> 4,
sizes & 15,
more >> 4,
if version == 0 { 0 } else { more & 15 },
);
let count = c.number(if version < 2 { 2 } else { 4 })? as usize;
state.entries(count)?;
for _ in 0..count {
let id = c.number(if version < 2 { 2 } else { 4 })? as u32;
let method = if version == 0 { 0 } else { c.number(2)? & 15 };
let reference = c.number(2)?;
let base = c.number(base_size)?;
let count = c.number(2)? as usize;
state.entries(count)?;
let mut extents = Vec::new();
for _ in 0..count {
c.number(index_size)?;
extents.push((c.number(offset_size)?, c.number(length_size)?));
}
let item = meta.items.entry(id).or_default();
if item.location.is_some() {
return Err(Error::Malformed("duplicate item location"));
}
item.location = Some(Location {
method,
reference,
base,
extents,
});
}
Ok(())
}
fn references<R: Read + Seek>(
reader: &mut Reader<'_, R>,
state: &mut State,
b: &BoxRange,
meta: &mut Meta,
) -> Result<(), Error> {
if b.len < 4 {
return Err(Error::Malformed("iref header"));
}
let version = reader.array::<1>(b.start)?[0];
if version > 1 {
return Err(Error::Unsupported("iref version"));
}
let width = if version == 0 { 2 } else { 4 };
let mut offset = b.start + 4;
while offset < b.end() {
state.entries(1)?;
let child = box_at(reader, offset, b.end())?;
offset = child.end();
if &child.kind != b"cdsc" {
continue;
}
let bytes = payload(reader, &child)?;
let mut c = Cursor::new(&bytes);
let id = c.number(width)? as u32;
let count = c.number(2)? as usize;
state.entries(count)?;
let item = meta.items.entry(id).or_default();
for _ in 0..count {
item.describes.push(c.number(width)? as u32);
}
}
Ok(())
}
fn properties<R: Read + Seek>(
reader: &mut Reader<'_, R>,
state: &mut State,
b: &BoxRange,
meta: &mut Meta,
) -> Result<(), Error> {
let mut offset = b.start;
while offset < b.end() {
state.entries(1)?;
let child = box_at(reader, offset, b.end())?;
offset = child.end();
match &child.kind {
b"ipco" => {
let mut offset = child.start;
while offset < child.end() {
state.entries(1)?;
let property = box_at(reader, offset, child.end())?;
offset = property.end();
meta.properties.push(property);
}
}
b"ipma" => {
let bytes = payload(reader, &child)?;
let mut c = Cursor::new(&bytes);
let version = c.number(1)?;
if version > 1 {
return Err(Error::Unsupported("ipma version"));
}
let flags = c.number(3)?;
let count = c.number(4)? as usize;
state.entries(count)?;
for _ in 0..count {
let id = c.number(if version == 0 { 2 } else { 4 })? as u32;
let count = c.number(1)? as usize;
state.entries(count)?;
let mut properties = Vec::new();
for _ in 0..count {
let width = if flags & 1 == 0 { 1 } else { 2 };
let value = c.number(width)? as usize;
let mask = 1 << (width * 8 - 1);
properties.push((value & (mask - 1), value & mask != 0));
}
meta.associations.push((id, properties));
}
}
_ => {}
}
}
Ok(())
}
fn payload<R: Read + Seek>(reader: &mut Reader<'_, R>, b: &BoxRange) -> Result<Vec<u8>, Error> {
reader.bytes(
b.start,
usize::try_from(b.len).map_err(|_| Error::Limit("box payload"))?,
)
}