| // Copyright 2026 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| |
| #include "formats/tiff/extractor.h" |
| |
| #include <sys/types.h> |
| |
| #include <cstdint> |
| #include <optional> |
| #include <string> |
| #include <vector> |
| |
| #include "absl/status/status.h" |
| #include "absl/status/status_matchers.h" |
| #include "absl/status/statusor.h" |
| #include "absl/strings/string_view.h" |
| #include "formats/asset_box.h" |
| #include "formats/byte_range.h" |
| #include "formats/extractor_result.h" |
| #include "formats/tiff/constants.h" |
| #include "gmock/gmock.h" |
| #include "gtest/gtest.h" |
| #include "riegeli/bytes/string_reader.h" |
| #include "utils/byte_writers.h" |
| |
| namespace credentio { |
| namespace { |
| |
| using ::absl_testing::IsOk; |
| using ::absl_testing::StatusIs; |
| using ::testing::Eq; |
| |
| #ifndef ASSERT_OK_AND_ASSIGN |
| #define ASSERT_OK_AND_ASSIGN_CONCAT2(x, y) x##y |
| #define ASSERT_OK_AND_ASSIGN_CONCAT(x, y) ASSERT_OK_AND_ASSIGN_CONCAT2(x, y) |
| |
| #define ASSERT_OK_AND_ASSIGN(lhs, rexpr) \ |
| ASSERT_OK_AND_ASSIGN_IMPL(lhs, rexpr, __COUNTER__) |
| |
| #define ASSERT_OK_AND_ASSIGN_IMPL(lhs, rexpr, id) \ |
| auto ASSERT_OK_AND_ASSIGN_CONCAT(status_or_, id) = (rexpr); \ |
| ASSERT_THAT(ASSERT_OK_AND_ASSIGN_CONCAT(status_or_, id), \ |
| ::absl_testing::IsOk()); \ |
| lhs = std::move(*ASSERT_OK_AND_ASSIGN_CONCAT(status_or_, id)) |
| #endif |
| |
| using ::testing::HasSubstr; |
| |
| struct TestCase { |
| std::string name; |
| absl::StatusOr<std::string> contents; |
| absl::StatusOr<ExtractorResult> result; |
| }; |
| |
| void WriteTiffHeader(uint32_t next_ifd_offset, std::vector<uint8_t>& data) { |
| WriteUint16NetworkOrder(kTiffBigEndian, &data); // Endian marker |
| WriteUint16NetworkOrder(kTiffMarker, &data); // TIFF marker |
| WriteUint32NetworkOrder(next_ifd_offset, &data); // Next IFD offset |
| } |
| |
| void WriteString(absl::string_view contents, std::vector<uint8_t>& data) { |
| for (int i = 0; i < contents.size(); ++i) { |
| data.push_back(contents[i]); |
| } |
| } |
| |
| struct Ifde { |
| uint16_t tag; |
| uint16_t type; |
| uint32_t count; |
| uint32_t value; |
| }; |
| |
| void WriteIfd(std::vector<Ifde> entries, uint32_t next_ifd, |
| std::vector<uint8_t>& data) { |
| WriteUint16NetworkOrder(entries.size(), &data); // IFD entry count |
| for (const Ifde& entry : entries) { |
| WriteUint16NetworkOrder(entry.tag, &data); // Tag |
| WriteUint16NetworkOrder(entry.type, &data); // Type |
| WriteUint32NetworkOrder(entry.count, &data); // Count |
| WriteUint32NetworkOrder(entry.value, &data); // Value |
| } |
| WriteUint32NetworkOrder(next_ifd, &data); // Next IFD offset |
| } |
| |
| void WriteUint16(std::vector<uint16_t> entries, std::vector<uint8_t>& data) { |
| for (const uint16_t entry : entries) { |
| WriteUint16NetworkOrder(entry, &data); |
| } |
| } |
| |
| void WriteUint32(std::vector<uint32_t> entries, std::vector<uint8_t>& data) { |
| for (const uint32_t entry : entries) { |
| WriteUint32NetworkOrder(entry, &data); |
| } |
| } |
| |
| class ExtractorTest : public testing::TestWithParam<TestCase> { |
| public: |
| void SetUp() override { ASSERT_THAT(GetParam().contents.status(), IsOk()); } |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ExtractorTests, ExtractorTest, |
| testing::ValuesIn( |
| {TestCase{ |
| .name = "EmptyContent", |
| .contents = "", |
| .result = absl::DataLossError("kUnexpectedEof"), |
| }, |
| TestCase{ |
| .name = "InvalidEndianMarker", |
| .contents = "\x12\x34", |
| .result = absl::DataLossError("endianness"), |
| }, |
| TestCase{ |
| .name = "InvalidTiffMarker", |
| .contents = "\x4d\x4d\x12\x34", |
| .result = absl::DataLossError("invalid endianness"), |
| }, |
| TestCase{ |
| .name = "SingleIfdNoEntries", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| WriteTiffHeader(8, data); |
| WriteIfd({}, 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = absl::NotFoundError("No manifest store found"), |
| }, |
| TestCase{ |
| .name = "SingleIfdNoC2paEntry", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| WriteTiffHeader(8, data); |
| WriteIfd({{.tag = 0x1234, |
| .type = 4, |
| .count = 1, |
| .value = 0x12345678}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = absl::NotFoundError("No manifest store found"), |
| }, |
| TestCase{ |
| .name = "ValidThreeValueOffsetTag", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(45, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 33) Offset Data |
| WriteUint16({0x1234, 0x5678, 0x9abc}, data); |
| // [33, 39) Offset Val |
| WriteUint16({27, 29, 31}, data); |
| // [39, 45) Counts Val |
| WriteUint16({2, 2, 2}, data); |
| // [45, 75) IFD |
| WriteIfd( |
| {{.tag = 0x0111, .type = 3, .count = 3, .value = 33}, |
| {.tag = 0x0117, .type = 3, .count = 3, .value = 39}}, |
| 75, data); |
| // [75, 93) IFD |
| WriteIfd({{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = ExtractorResult{.manifest_store = "test_manifest_store", |
| .asset_byte_info = |
| {.manifest_store_location = |
| {.offset = 8, .length = 19}}}, |
| }, |
| TestCase{ |
| .name = "EntryWithMultipleUint8Values", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(27, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 45) First IFD |
| WriteIfd({Ifde{.tag = 0x1234, |
| .type = 1, |
| .count = 3, |
| .value = 0x01020300}}, |
| 45, data); |
| // [45, 61) Second IFD |
| WriteIfd({Ifde{.tag = kTiffTagC2pa, |
| .type = 0x0007, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = ExtractorResult{.manifest_store = "test_manifest_store", |
| .asset_byte_info = |
| {.manifest_store_location = |
| {.offset = 8, .length = 19}}}, |
| }, |
| TestCase{ |
| .name = "EntryWithMultipleUint16Values", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(27, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 45) First IFD |
| WriteIfd({Ifde{.tag = 0x1234, |
| .type = 3, |
| .count = 2, |
| .value = 0x01020304}}, |
| 45, data); |
| // [45, 61) Second IFD |
| WriteIfd({Ifde{.tag = kTiffTagC2pa, |
| .type = 0x0007, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = ExtractorResult{.manifest_store = "test_manifest_store", |
| .asset_byte_info = |
| {.manifest_store_location = |
| {.offset = 8, .length = 19}}}, |
| }, |
| TestCase{ |
| .name = "ValidSingleValueOffset", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(31, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 31) Offset Data |
| WriteUint32({0x12345678}, data); |
| // [31, 73) IFD |
| WriteIfd( |
| { |
| {.tag = 0x0111, .type = 4, .count = 1, .value = 27}, |
| {.tag = 0x0115, .type = 4, .count = 1, .value = 4}, |
| {.tag = 0x0117, .type = 4, .count = 1, .value = 4}, |
| }, |
| 73, data); |
| // [73, 91) IFD |
| WriteIfd({{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = ExtractorResult{.manifest_store = "test_manifest_store", |
| .asset_byte_info = |
| {.manifest_store_location = |
| {.offset = 8, .length = 19}}}, |
| }, |
| TestCase{ |
| .name = "ValidSingleValueOffsetWithExtraData", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(31, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 31) Offset Data |
| WriteUint32({0x12345678}, data); |
| // [31, 73) IFD |
| WriteIfd( |
| { |
| {.tag = 0x0111, .type = 4, .count = 1, .value = 27}, |
| {.tag = 0x0115, .type = 4, .count = 1, .value = 4}, |
| {.tag = 0x0117, .type = 4, .count = 1, .value = 4}, |
| }, |
| 73, data); |
| // [73, 91) IFD |
| WriteIfd({{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| // [91, 101) Extra Data (not part of the IFD) |
| return std::string(data.begin(), data.end()) + "extra_data"; |
| }(), |
| .result = ExtractorResult{.manifest_store = "test_manifest_store", |
| .asset_byte_info = |
| {.manifest_store_location = |
| {.offset = 8, .length = 19}}}, |
| }, |
| TestCase{ |
| .name = "ValidSingleSubIfd", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(45, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 45) Sub IFD |
| WriteIfd({{.tag = 0x1234, |
| .type = 4, |
| .count = 1, |
| .value = 0x12345678}}, |
| 0, data); |
| // [45, 63) IFD |
| WriteIfd( |
| {{.tag = 0x014a, .type = 4, .count = 1, .value = 27}}, |
| 63, data); |
| // [63, 81) IFD |
| WriteIfd({{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = ExtractorResult{.manifest_store = "test_manifest_store", |
| .asset_byte_info = |
| {.manifest_store_location = |
| {.offset = 8, .length = 19}}}, |
| }, |
| TestCase{ |
| .name = "ValidTwoLayerSubIfd", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(63, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 45) Child Sub IFD |
| WriteIfd({{.tag = 0x1234, |
| .type = 4, |
| .count = 1, |
| .value = 0x12345678}}, |
| 0, data); |
| // [45, 63) Parent Sub IFD |
| WriteIfd( |
| {{.tag = 0x014a, .type = 4, .count = 1, .value = 27}}, 0, |
| data); |
| // [63, 81) First Base IFD |
| WriteIfd( |
| {{.tag = 0x014a, .type = 4, .count = 1, .value = 45}}, |
| 81, data); |
| // [81, 99) Second Base IFD |
| WriteIfd({{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = ExtractorResult{.manifest_store = "test_manifest_store", |
| .asset_byte_info = |
| {.manifest_store_location = |
| {.offset = 8, .length = 19}}}, |
| }, |
| TestCase{ |
| .name = "ValidSubWithChainedIfd", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(63, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 45) Second Sub IFD |
| WriteIfd({{.tag = 0x1234, |
| .type = 4, |
| .count = 1, |
| .value = 0x12345678}}, |
| 0, data); |
| // [45, 63) First Sub IFD |
| WriteIfd({{.tag = 0x1234, |
| .type = 4, |
| .count = 1, |
| .value = 0x12345678}}, |
| 27, data); |
| // [63, 81) First Base IFD |
| WriteIfd( |
| {{.tag = 0x014a, .type = 4, .count = 1, .value = 45}}, |
| 81, data); |
| // [81, 99) Second Base IFD |
| WriteIfd({{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = ExtractorResult{.manifest_store = "test_manifest_store", |
| .asset_byte_info = |
| {.manifest_store_location = |
| {.offset = 8, .length = 19}}}, |
| }, |
| TestCase{ |
| // This is technically not a valid TIFF file, as there is no other |
| // data, but it abides by the C2PA spec. |
| .name = "SingleIfdOnlyC2paEntry", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(27, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 45) IFD |
| WriteIfd({{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = |
| ExtractorResult{ |
| .manifest_store = "test_manifest_store", |
| .asset_byte_info = {.manifest_store_location = |
| {.offset = 8, .length = 19}}}, |
| }, |
| TestCase{ |
| .name = "SingleIfdC2paEntryBeforeOtherEntry", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(27, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 45) IFD |
| WriteIfd( |
| {{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}, |
| {.tag = 0x1234, .type = 1, .count = 1, .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = |
| ExtractorResult{ |
| .manifest_store = "test_manifest_store", |
| .asset_byte_info = {.manifest_store_location = |
| {.offset = 8, .length = 19}}}, |
| }, |
| TestCase{ |
| .name = "SingleIfdC2paEntryAfterOtherEntry", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(27, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 45) IFD |
| WriteIfd({{.tag = 0x1234, .type = 1, .count = 1, .value = 8}, |
| {.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = |
| ExtractorResult{ |
| .manifest_store = "test_manifest_store", |
| .asset_byte_info = {.manifest_store_location = |
| {.offset = 8, .length = 19}}}, |
| }, |
| TestCase{ |
| .name = "MultipleIfdC2paInFirstIfd", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(27, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 45) IFD |
| WriteIfd({{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 45, data); |
| // [45, 81) Second IFD |
| WriteIfd( |
| {{.tag = 0x1234, .type = 1, .count = 1, .value = 8}}, 0, |
| data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = |
| absl::NotFoundError("Manifest Store must be in the last IFD"), |
| }, |
| TestCase{ |
| .name = "MultipleIfdC2paInSecondIfd", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(27, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 45) IFD |
| WriteIfd( |
| {{.tag = 0x1234, .type = 1, .count = 1, .value = 8}}, 45, |
| data); |
| // [45, 81) Second IFD |
| WriteIfd({{.tag = 0x1234, .type = 1, .count = 1, .value = 8}, |
| {.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = absl::NotFoundError( |
| "Manifest Store must be the only entry in the IFD"), |
| }, |
| TestCase{ |
| .name = "UnknownIfdEntryType", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(27, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 45) IFD |
| WriteIfd({{.tag = 0x1234, |
| .type = 0x1234, |
| .count = 1, |
| .value = 8}}, |
| 45, data); |
| // [45, 81) IFD |
| WriteIfd({{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = |
| ExtractorResult{ |
| .manifest_store = "test_manifest_store", |
| .asset_byte_info = {.manifest_store_location = |
| {.offset = 8, .length = 19}}}, |
| }, |
| TestCase{ |
| .name = "MultipleIfdC2paInBoth", |
| .contents = |
| []() { |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(49, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 49) Manifest Store |
| WriteString("another_manifest_store", data); |
| // [49, 67) IFD |
| WriteIfd({{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 67, data); |
| // [67, 85) IFD |
| WriteIfd({{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(), |
| .result = |
| absl::NotFoundError("Manifest Store must be in the last IFD"), |
| }, |
| TestCase{ |
| .name = "FuzzTestRegression_b421332332", |
| .contents = |
| std::string("MM\000*" |
| "\000\000\000\t\000\000\001\001JJJJ\303\303" |
| "\004\000\000\000\t\004\000\000\000", |
| 27), |
| .result = absl::InternalError("Failed to seek to offs"), |
| }, |
| { |
| .name = "FuzzTestRegression_b422060716", |
| .contents = std::string( |
| "MM\000*\000\000\000\t\000\000\002\001 " |
| "\000\003\000\000\000\002\000\000\000\000\001!" |
| "\000\004\000\000kkkkkkk\000..\000\000\000\303s\000\000", |
| 46), |
| .result = absl::InternalError("Failed to seek to offset"), |
| }, |
| { |
| .name = "FuzzTestRegression_SmallC2paSize", |
| .contents = std::string( |
| "II*" |
| "\000e\000\000\000\014\001\232\001\014\000\000\356\000\000\224" |
| "\000\000\000\001A\002\000l\205\000\0004\000\000\000\002\210" |
| "\007\000\005\000@" |
| "\304\214\000\270\000\000\300\n\377\305\324\200\377\377\000b" |
| "\000\000\000\241\001\003\000pT@" |
| "\225\257R\000\000J\001\004\000\001\003y\000\326\000\000\000" |
| "\373\377\373\372\005\022\000\000\254\322\333\000\000\035\001" |
| "\003\000\001\000A\315\007\000\004\000\000\000\362\001\000\000" |
| "\000\000\000\000\t\343\337\000\2372\010\000\000\211\000\000" |
| "\000\000\371\000\000\000r\000\000\200\340\005\000\017\004\000" |
| "\000\034\010\000\000\000\027\000\230X\353\233\005\270\372=*" |
| "\032\006\3768\332\034%" |
| "\000\000\000\000N\310\000\000\332\357\213\213\020@\003 " |
| "\000\242\027\000\001&" |
| "\023\316\000E\000\000\000\000\000\002\250\001\001\345\226\000" |
| "\000\000\000\000\200\000\000\000u\202)" |
| "\030\327u\000\000\000\000\000\000\000\000\000\000\000\000\000" |
| "\000\000\000\372\372\373\000\373PPPP\325\000\000\336@" |
| "\000\000JJ\037\265\345S\000AA\003\332\376\000U\266\004\000" |
| "\000\000\000\000\000\000\200\0148\007\000\000\000\000\000\000" |
| "\377\377\177\375\255\351\205\003\000\000\273\001^" |
| "\004E\201\034\211\371Iw\325\234\377\252\032S.\006n\344$" |
| "\277\036\000\006;t)\324\307@)\332f\003\001\000[\000\246\307b " |
| "l\177\010\000\000\000\000\257\354\334\244\243\243\243\243\243" |
| "\243\243\243\332\332\332\243\247\243\243\243\243\243\243\243" |
| "\243\243\243\243\243\243\243\243\243\243\315\243\243\243\243" |
| "\243\243\243\243\243\243\243\247\250\247{" |
| "\253\236\241\243\000\000\244\302,\230\230\230\230-" |
| "1\002x\361xx\221\221\000\000\000\346\000m\2544\024\000\030" |
| "\000\000\000\000\000\000\367\267AAAAAAAA\264\366|\304\264!" |
| "\000\005\355\000\000\000\367\372\236#" |
| "\374\000\230\300\300\300\300\300\300\300\300\300\300\300\300" |
| "\300\300\300\2304\000\000\000", |
| 487), |
| .result = |
| ExtractorResult{ |
| .manifest_store = std::string("\xF2\x01\x00\x00", 4), |
| .asset_byte_info = {.manifest_store_location = |
| {.offset = 111, .length = 4}}}, |
| }}), |
| [](const testing::TestParamInfo<ExtractorTest::ParamType>& info) { |
| return info.param.name; |
| }); |
| |
| TEST_P(ExtractorTest, ExtractManifestStore) { |
| const TestCase& test_case = GetParam(); |
| ASSERT_OK_AND_ASSIGN(std::string contents, test_case.contents); |
| riegeli::StringReader<> input(contents); |
| absl::StatusOr<std::string> result = |
| TiffExtractor().ExtractManifestStore(input); |
| |
| const auto& expected_result = test_case.result; |
| if (expected_result.ok()) { |
| ASSERT_THAT(result, IsOk()); |
| EXPECT_THAT(*result, Eq(expected_result->manifest_store)); |
| } else { |
| EXPECT_THAT(result, |
| StatusIs(expected_result.status().code(), |
| HasSubstr(expected_result.status().message()))); |
| } |
| } |
| |
| TEST_P(ExtractorTest, ExtractManifestStoreLocation) { |
| const TestCase& test_case = GetParam(); |
| ASSERT_OK_AND_ASSIGN(std::string contents, test_case.contents); |
| riegeli::StringReader<> input(contents); |
| absl::StatusOr<std::optional<ByteRange>> result = |
| TiffExtractor().ExtractManifestStoreLocation(input, {}); |
| |
| const auto& expected_result = test_case.result; |
| if (expected_result.ok()) { |
| ASSERT_THAT(result, IsOk()); |
| EXPECT_THAT(*result, |
| Eq(expected_result->asset_byte_info.manifest_store_location)); |
| } else { |
| EXPECT_THAT(result, |
| StatusIs(expected_result.status().code(), |
| HasSubstr(expected_result.status().message()))); |
| } |
| } |
| |
| TEST_P(ExtractorTest, ExtractBoxes) { |
| ASSERT_OK_AND_ASSIGN(std::string contents, GetParam().contents); |
| riegeli::StringReader<> input(contents); |
| absl::StatusOr<std::vector<AssetBox>> result = |
| TiffExtractor().ExtractBoxes(input, {}); |
| |
| EXPECT_THAT( |
| result, |
| StatusIs(absl::StatusCode::kUnimplemented, |
| HasSubstr("Extracting boxes is not supported for TIFF files."))); |
| } |
| |
| TEST(OffsetTiffExtractorTest, FailsWhenEndOffsetIsSmallerThanAsset) { |
| std::string contents = []() { |
| // Adding a prefix to the contents, need to offset all the offsets by 7. |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(27, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 45) IFD |
| WriteIfd({{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(); |
| riegeli::StringReader<> input(contents); |
| |
| EXPECT_THAT( |
| TiffExtractor().ExtractManifestStoreLocation(input, {.end_offset = 20}), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("TiffExtractor::ExtractManifestStoreLocation only " |
| "supports operations over the entire file."))); |
| } |
| |
| TEST(OffsetTiffExtractorTest, |
| FailsWhenEndOffsetEqualToAssetSizeAndCurrentOffsetIsNonZero) { |
| std::string contents = []() { |
| // Adding a prefix to the contents, need to offset all the offsets by 7. |
| std::vector<uint8_t> data = {}; |
| // [0, 8) Tiff Header |
| WriteTiffHeader(27, data); |
| // [8, 27) Manifest Store |
| WriteString("test_manifest_store", data); |
| // [27, 45) IFD |
| WriteIfd({{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 19, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(); |
| riegeli::StringReader<> input(contents); |
| |
| ASSERT_TRUE(input.Seek(7)); |
| EXPECT_THAT( |
| TiffExtractor().ExtractManifestStoreLocation( |
| input, {.end_offset = static_cast<int64_t>(contents.size())}), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("TiffExtractor::ExtractManifestStoreLocation only " |
| "supports operations over the entire file."))); |
| } |
| |
| TEST(TiffExtractorTest, UnboundedManifestStoreAllocation) { |
| std::string contents = []() { |
| std::vector<uint8_t> data = {}; |
| WriteTiffHeader(13, data); |
| WriteString("short", data); |
| WriteIfd({{.tag = kTiffTagC2pa, |
| .type = kTiffTypeUndefined, |
| .count = 11 * 1024 * 1024, |
| .value = 8}}, |
| 0, data); |
| return std::string(data.begin(), data.end()); |
| }(); |
| riegeli::StringReader<> input(contents); |
| EXPECT_THAT(TiffExtractor().ExtractManifestStore(input), |
| StatusIs(absl::StatusCode::kInvalidArgument, |
| HasSubstr("Manifest store is too large"))); |
| } |
| |
| } // namespace |
| } // namespace credentio |
