GitCorner

Code

ossartcraftlightcraft🌐
5a24289898fd
//! EXIF and XMP image resources in Photoshop PSD and PSB files.

use crate::Embedded;

/// The EXIF (1058) and XMP (1060) resources of the head `craft-psd` reads (header, colour mode data, image
/// resources). `None` for a head that does not parse, a second EXIF or XMP resource, or XMP that is not UTF-8.
pub(crate) fn parse(bytes: &[u8]) -> Option<Embedded> {
    let head = craft_psd::Head::from_bytes(bytes).ok()?;
    let (exif, xmp) = craft_psd::resources::unique_exif_xmp(&head.resources)?;
    Some(Embedded { exif: exif.map(crate::strip_exif_header).map(<[u8]>::to_vec), xmp: xmp.map(str::to_owned), ..Default::default() })
}

#[cfg(test)]
mod tests {
    use crate::Embedded;
    use crate::embedded;
    use crate::{DateTime, Gps, Metadata};

    fn resource(id: u16, name: &[u8], data: &[u8]) -> Vec<u8> {
        let mut out = b"8BIM".to_vec();
        out.extend_from_slice(&id.to_be_bytes());
        out.push(u8::try_from(name.len()).unwrap());
        out.extend_from_slice(name);
        if !(name.len() + 1).is_multiple_of(2) {
            out.push(0);
        }
        out.extend_from_slice(&u32::try_from(data.len()).unwrap().to_be_bytes());
        out.extend_from_slice(data);
        if !data.len().is_multiple_of(2) {
            out.push(0);
        }
        out
    }

    fn image(version: u16, colour_data: &[u8], resources: &[u8]) -> Vec<u8> {
        let mut out = b"8BPS".to_vec();
        out.extend_from_slice(&version.to_be_bytes());
        out.extend_from_slice(&[0; 6]);
        out.extend_from_slice(&3u16.to_be_bytes()); // channels
        out.extend_from_slice(&1u32.to_be_bytes()); // height
        out.extend_from_slice(&1u32.to_be_bytes()); // width
        out.extend_from_slice(&8u16.to_be_bytes()); // depth
        out.extend_from_slice(&3u16.to_be_bytes()); // RGB
        out.extend_from_slice(&u32::try_from(colour_data.len()).unwrap().to_be_bytes());
        out.extend_from_slice(colour_data);
        out.extend_from_slice(&u32::try_from(resources.len()).unwrap().to_be_bytes());
        out.extend_from_slice(resources);
        out
    }

    fn dated_metadata() -> Metadata {
        Metadata {
            capture_time: DateTime::parse_exif("2023:05:14 14:40:39"),
            gps: Some(Gps { latitude: 45.0, longitude: 7.0, altitude: None }),
            ..Default::default()
        }
    }

    fn dated_image(version: u16) -> Vec<u8> {
        let exif = crate::write_exif(&dated_metadata());
        image(version, &[], &resource(1058, b"", &exif))
    }

    #[test]
    fn psd_capture_time_is_extracted() {
        let expected = dated_metadata().capture_time;
        let actual = crate::extract(&dated_image(1));
        assert_eq!(actual.capture_time, expected);
        assert_eq!(actual.gps, dated_metadata().gps);
    }

    #[test]
    fn psb_capture_time_is_extracted() {
        let expected = dated_metadata().capture_time;
        let actual = crate::extract(&dated_image(2));
        assert_eq!(actual.capture_time, expected);
        assert_eq!(actual.gps, dated_metadata().gps);
    }

    #[test]
    fn psd_extracts_xmp_without_exif() {
        let metadata = Metadata {
            capture_time: DateTime::parse_iso("2024-02-03T04:05:06Z"),
            gps: Some(Gps { latitude: -33.9, longitude: 151.2, altitude: Some(25.0) }),
            title: Some("Embedded XMP".into()),
            ..Default::default()
        };
        let xmp = crate::write_xmp(&metadata, None);
        let file = image(1, &[], &resource(1060, b"", xmp.as_bytes()));
        let actual = crate::extract(&file);
        assert_eq!(actual.capture_time, metadata.capture_time);
        assert_eq!(actual.gps, metadata.gps);
        assert_eq!(actual.title, metadata.title);
    }

    #[test]
    fn psd_normalizes_the_optional_exif_resource_prefix() {
        let mut exif = b"Exif\0\0".to_vec();
        exif.extend(crate::write_exif(&dated_metadata()));
        let file = image(1, &[], &resource(1058, b"", &exif));
        assert_eq!(crate::extract(&file).capture_time, dated_metadata().capture_time);
    }

    #[test]
    fn try_extract_rejects_structurally_malformed_psd_exif() {
        for version in [1, 2] {
            let file = image(version, &[], &resource(1058, b"", b"not a TIFF stream"));
            assert!(matches!(crate::try_extract(&file), Err(crate::ExtractError::MalformedPsd)));
        }
    }

    #[test]
    fn try_extract_accepts_unknown_exif_tags_in_psd() {
        let mut ifd0 = craft_tiff::IfdBuilder::new();
        ifd0.set(0xc001, craft_tiff::Value::Ascii("vendor metadata".into()));
        let exif = craft_tiff::TiffWriter::default().write(&[ifd0]).unwrap();
        let file = image(1, &[], &resource(1058, b"", &exif));
        assert!(crate::try_extract(&file).is_ok());
    }

    #[test]
    fn try_extract_rejects_malformed_psd_xmp_but_extract_remains_best_effort() {
        let file = image(1, &[], &resource(1060, b"", b"<x:xmpmeta><broken"));

        assert_eq!(crate::extract(&file), Metadata::default());
        assert!(matches!(crate::try_extract(&file), Err(crate::ExtractError::MalformedPsd)));
    }

    #[test]
    fn try_extract_rejects_invalid_utf8_psd_xmp() {
        let mut xmp = crate::write_xmp(&dated_metadata(), None).into_bytes();
        let latitude = xmp.windows(2).position(|bytes| bytes == b"45").unwrap();
        xmp[latitude] = 0xff;
        let lossy = crate::parse_xmp(&String::from_utf8_lossy(&xmp)).unwrap();
        assert!(lossy.metadata.gps.is_none(), "lossy decoding hides the corrupted GPS value without an XML error");

        for version in [1, 2] {
            let file = image(version, &[], &resource(1060, b"", &xmp));
            assert!(matches!(crate::try_extract(&file), Err(crate::ExtractError::MalformedPsd)));
            assert_eq!(embedded(&file), Embedded::default());
            assert_eq!(crate::extract(&file), Metadata::default());
        }
    }

    #[test]
    fn psd_xmp_preserves_valid_utf8_and_trailing_nul_trimming() {
        let metadata = Metadata { title: Some("Café 山".into()), ..dated_metadata() };
        let xmp = crate::write_xmp(&metadata, None);
        let mut padded = xmp.as_bytes().to_vec();
        padded.extend_from_slice(b"\0\0");

        for version in [1, 2] {
            let file = image(version, &[], &resource(1060, b"", &padded));
            assert_eq!(embedded(&file).xmp.as_deref(), Some(xmp.as_str()));
            let actual = crate::try_extract(&file).unwrap();
            assert_eq!(actual.gps, metadata.gps);
            assert_eq!(actual.title, metadata.title);
        }
    }

    #[test]
    fn try_extract_rejects_duplicate_psd_exif_and_xmp_resources() {
        let gps = dated_metadata();
        let no_gps = Metadata::default();
        let gps_exif = crate::write_exif(&gps);
        let no_gps_exif = crate::write_exif(&no_gps);
        let gps_xmp = crate::write_xmp(&gps, None);
        let no_gps_xmp = crate::write_xmp(&no_gps, None);

        let duplicate_exif = [resource(1058, b"", &gps_exif), resource(1058, b"", &no_gps_exif)].concat();
        let duplicate_xmp = [resource(1060, b"", gps_xmp.as_bytes()), resource(1060, b"", no_gps_xmp.as_bytes())].concat();

        for (id, resources) in [(1058, duplicate_exif), (1060, duplicate_xmp)] {
            let file = image(1, &[], &resources);
            assert!(matches!(crate::try_extract(&file), Err(crate::ExtractError::MalformedPsd)), "duplicate resource {id} must be rejected");
        }
    }

    #[test]
    fn psd_skips_unknown_resources_with_pascal_name_and_payload_padding() {
        let exif = crate::write_exif(&dated_metadata());
        let mut resources = resource(4000, b"xy", &[1, 2, 3]);
        resources.extend(resource(1058, b"", &exif));
        let file = image(1, &[8, 7, 6], &resources);
        assert_eq!(crate::extract(&file).capture_time, dated_metadata().capture_time);
    }

    #[test]
    fn psd_truncation_and_hostile_lengths_return_no_embedded_metadata() {
        let file = dated_image(1);
        for end in 0..file.len() {
            assert_eq!(embedded(&file[..end]), Embedded::default(), "truncated at {end}");
        }

        let mut hostile_colour_length = file.clone();
        hostile_colour_length[26..30].copy_from_slice(&u32::MAX.to_be_bytes());
        assert_eq!(embedded(&hostile_colour_length), Embedded::default());

        let mut hostile_resource_length = file.clone();
        hostile_resource_length[30..34].copy_from_slice(&u32::MAX.to_be_bytes());
        assert_eq!(embedded(&hostile_resource_length), Embedded::default());

        let mut hostile_payload_length = file;
        hostile_payload_length[42..46].copy_from_slice(&u32::MAX.to_be_bytes());
        assert_eq!(embedded(&hostile_payload_length), Embedded::default());
    }

    #[test]
    fn psd_rejects_unknown_versions_and_incomplete_resource_records() {
        let file = dated_image(1);
        let mut unknown_version = file.clone();
        unknown_version[4..6].copy_from_slice(&3u16.to_be_bytes());
        assert_eq!(embedded(&unknown_version), Embedded::default());

        let mut truncated_record = file;
        truncated_record.pop();
        assert_eq!(embedded(&truncated_record), Embedded::default());
    }
}