| // 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 "assertion/references_validator.h" | |
| #include <memory> | |
| #include <string> | |
| #include "absl/log/check.h" | |
| #include "absl/strings/str_cat.h" | |
| #include "absl/strings/str_format.h" | |
| #include "absl/strings/string_view.h" | |
| #include "absl/types/span.h" | |
| #include "assertion/hashed_uri_validator.h" | |
| #include "crypto/default/hasher.h" | |
| #include "crypto/hash.h" | |
| #include "gmock/gmock.h" | |
| #include "gtest/gtest.h" | |
| #include "jumbf/box.h" | |
| #include "jumbf/uri.h" | |
| #include "proto/actions_assertion.pb.h" | |
| #include "proto/assertion.pb.h" | |
| #include "testing/jumbf_utils.h" | |
| #include "testing/proto_test_utils.h" | |
| #include "testing/test_validation_tracker.h" | |
| namespace credentio { | |
| namespace { | |
| using ::credentio_testing::ParseTextProtoOrDie; | |
| using ::testing::IsEmpty; | |
| using ::testing::UnorderedElementsAre; | |
| constexpr absl::string_view kManifestLabel1 = | |
| "urn:uuid:F9168C5E-CEB2-4FAA-B6BF-329BF39FA1E4"; | |
| constexpr absl::string_view kManifestPath1 = | |
| "/c2pa/urn:uuid:F9168C5E-CEB2-4FAA-B6BF-329BF39FA1E4"; | |
| constexpr absl::string_view kManifestLabel2 = | |
| "urn:uuid:AFAFAFAF-0101-0202-0303-ABCDEFFEDCBA"; | |
| std::string Digest(absl::string_view data) { | |
| auto hasher = CreateHasher("sha256"); | |
| CHECK_OK(hasher); | |
| (*hasher)->Update(data); | |
| return (*hasher)->Digest(); | |
| } | |
| TEST(ReferencesValidatorTest, ValidateIngredientV3ThumbnailOkay) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("foo"); | |
| auto assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.ingredient" | |
| ingredient_v3 { | |
| thumbnail { | |
| url: "self#jumbf=/c2pa/urn:uuid:AFAFAFAF-0101-0202-0303-ABCDEFFEDCBA/c2pa.thumbnail.ingredient_1.jpg" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| jumbf::SuperBox thumbnail_box = { | |
| .description = | |
| { | |
| .label = "c2pa.thumbnail.ingredient_1.jpg", | |
| }, | |
| .raw_bytes = "00020000foo", | |
| }; | |
| jumbf::SuperBox manifest_store = CreateManifestStore( | |
| {CreateStandardManifest(kManifestLabel2, {thumbnail_box})}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| ASSERT_TRUE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetFailureStatuses(), IsEmpty()); | |
| } | |
| TEST(ReferencesValidatorTest, ValidateIngredientV3ThumbnailMissing) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("foo"); | |
| auto assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.ingredient" | |
| ingredient_v3 { | |
| thumbnail { | |
| url: "self#jumbf=/c2pa/urn:uuid:AFAFAFAF-0101-0202-0303-ABCDEFFEDCBA/c2pa.thumbnail.ingredient_1.jpg" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| jumbf::SuperBox manifest_store = | |
| CreateManifestStore({CreateStandardManifest(kManifestLabel2, {})}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| ASSERT_FALSE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetFailures(), UnorderedElementsAre("hashedUri.missing")); | |
| } | |
| TEST(ReferencesValidatorTest, ValidateIngredientV3ThumbnailMismatch) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("bar"); | |
| auto assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.ingredient" | |
| ingredient_v3 { | |
| thumbnail { | |
| url: "self#jumbf=/c2pa/urn:uuid:AFAFAFAF-0101-0202-0303-ABCDEFFEDCBA/c2pa.thumbnail.ingredient_1.jpg" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| jumbf::SuperBox thumbnail_box = { | |
| .description = | |
| { | |
| .label = "c2pa.thumbnail.ingredient_1.jpg", | |
| }, | |
| .raw_bytes = "00020000foo", | |
| }; | |
| jumbf::SuperBox manifest_store = CreateManifestStore( | |
| {CreateStandardManifest(kManifestLabel2, {thumbnail_box})}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| ASSERT_FALSE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetFailures(), | |
| UnorderedElementsAre("hashedUri.mismatch")); | |
| } | |
| TEST(ReferencesValidatorTest, ValidateIngredientV3ActiveManifestOkay) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("foo"); | |
| auto assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.ingredient.v3" | |
| ingredient_v3 { | |
| active_manifest { | |
| url: "self#jumbf=/c2pa/urn:uuid:AFAFAFAF-0101-0202-0303-ABCDEFFEDCBA" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| auto manifest_box = CreateStandardManifest(kManifestLabel2, {}); | |
| manifest_box.raw_bytes = "00020000foo"; | |
| jumbf::SuperBox manifest_store = CreateManifestStore({manifest_box}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| ASSERT_TRUE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetFailures(), IsEmpty()); | |
| } | |
| TEST(ReferencesValidatorTest, | |
| ValidateIngredientV3ActiveManifestMismatchIgnored) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("foo"); | |
| auto assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.ingredient" | |
| ingredient_v3 { | |
| active_manifest { | |
| url: "self#jumbf=/c2pa/urn:uuid:AFAFAFAF-0101-0202-0303-ABCDEFFEDCBA" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| jumbf::SuperBox manifest_store = | |
| CreateManifestStore({CreateStandardManifest(kManifestLabel2, {})}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| EXPECT_TRUE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetFailures(), IsEmpty()); | |
| } | |
| TEST(ReferencesValidatorTest, | |
| ValidateIngredientV3ClaimSignatureMismatchIgnored) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("bar"); | |
| auto assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.ingredient" | |
| ingredient_v3 { | |
| claim_signature { | |
| url: "self#jumbf=/c2pa/urn:uuid:AFAFAFAF-0101-0202-0303-ABCDEFFEDCBA/c2pa.signature" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| jumbf::SuperBox claim_signature_box = { | |
| .description = | |
| { | |
| .label = "c2pa.signature", | |
| }, | |
| .raw_bytes = "00020000foo", | |
| }; | |
| jumbf::SuperBox manifest_store = CreateManifestStore( | |
| {CreateStandardManifest(kManifestLabel2, {claim_signature_box})}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| EXPECT_TRUE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetFailures(), IsEmpty()); | |
| } | |
| TEST(ReferencesValidatorTest, ValidateActionsV1IngredientOkay) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("foo"); | |
| auto assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.action" | |
| actions_v1 { | |
| actions { | |
| action: "c2pa.opened", | |
| parameters { | |
| ingredients { | |
| url: "self#jumbf=c2pa.assertions/c2pa.ingredient__1" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| jumbf::SuperBox ingredient_box = { | |
| .description = | |
| { | |
| .label = "c2pa.ingredient__1", | |
| }, | |
| .raw_bytes = "00020000foo", | |
| }; | |
| auto assertion_store = CreateAssertionStoreBox({ingredient_box}); | |
| jumbf::SuperBox manifest_store = CreateManifestStore( | |
| {CreateStandardManifest(kManifestLabel1, {assertion_store})}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| ASSERT_TRUE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetFailures(), IsEmpty()); | |
| } | |
| TEST(ReferencesValidatorTest, ValidateActionsV1IngredientMismatch) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("bar"); | |
| auto assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.action" | |
| actions_v1 { | |
| actions { | |
| action: "c2pa.opened", | |
| parameters { | |
| ingredients { | |
| url: "self#jumbf=c2pa.assertions/c2pa.ingredient__1" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| jumbf::SuperBox ingredient_box = { | |
| .description = | |
| { | |
| .label = "c2pa.ingredient__1", | |
| }, | |
| .raw_bytes = "00020000foo", | |
| }; | |
| auto assertion_store = CreateAssertionStoreBox({ingredient_box}); | |
| jumbf::SuperBox manifest_store = CreateManifestStore( | |
| {CreateStandardManifest(kManifestLabel1, {assertion_store})}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| ASSERT_FALSE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetFailures(), | |
| UnorderedElementsAre("hashedUri.mismatch")); | |
| } | |
| TEST(ReferencesValidatorTest, ValidateActionsV2IngredientOkay) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("foo"); | |
| auto assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.action" | |
| actions { | |
| actions { | |
| action: "c2pa.opened", | |
| parameters { | |
| ingredients { | |
| url: "self#jumbf=c2pa.assertions/c2pa.ingredient__1" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| jumbf::SuperBox ingredient_box = { | |
| .description = | |
| { | |
| .label = "c2pa.ingredient__1", | |
| }, | |
| .raw_bytes = "00020000foo", | |
| }; | |
| auto assertion_store = CreateAssertionStoreBox({ingredient_box}); | |
| jumbf::SuperBox manifest_store = CreateManifestStore( | |
| {CreateStandardManifest(kManifestLabel1, {assertion_store})}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| ASSERT_TRUE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetFailures(), IsEmpty()); | |
| } | |
| TEST(ReferencesValidatorTest, ValidateActionsV2IngredientMismatch) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("bar"); | |
| auto assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.action" | |
| actions { | |
| actions { | |
| action: "c2pa.opened", | |
| parameters { | |
| ingredients { | |
| url: "self#jumbf=c2pa.assertions/c2pa.ingredient__1" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| jumbf::SuperBox ingredient_box = { | |
| .description = | |
| { | |
| .label = "c2pa.ingredient__1", | |
| }, | |
| .raw_bytes = "00020000foo", | |
| }; | |
| auto assertion_store = CreateAssertionStoreBox({ingredient_box}); | |
| jumbf::SuperBox manifest_store = CreateManifestStore( | |
| {CreateStandardManifest(kManifestLabel1, {assertion_store})}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| ASSERT_FALSE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetFailures(), | |
| UnorderedElementsAre("hashedUri.mismatch")); | |
| } | |
| TEST(ReferencesValidatorTest, ValidateActionsV2RelatedAssertionsOkay) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("foo"); | |
| Assertion assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.action" | |
| actions { | |
| actions { | |
| action: "c2pa.opened", | |
| parameters { | |
| related_assertions { | |
| url: "self#jumbf=c2pa.assertions/c2pa.other" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| jumbf::SuperBox other_assertion_box = { | |
| .description = | |
| { | |
| .label = "c2pa.other", | |
| }, | |
| .raw_bytes = "00020000foo", | |
| }; | |
| auto assertion_store = CreateAssertionStoreBox({other_assertion_box}); | |
| jumbf::SuperBox manifest_store = CreateManifestStore( | |
| {CreateStandardManifest(kManifestLabel1, {assertion_store})}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| ASSERT_TRUE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetSuccesses(), IsEmpty()); | |
| EXPECT_THAT(tracker.GetFailures(), IsEmpty()); | |
| } | |
| TEST(ReferencesValidatorTest, ValidateActionsV2RelatedAssertionsMissing) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("foo"); | |
| Assertion assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.action" | |
| actions { | |
| actions { | |
| action: "c2pa.opened", | |
| parameters { | |
| related_assertions { | |
| url: "self#jumbf=c2pa.assertions/c2pa.other" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| jumbf::SuperBox manifest_store = | |
| CreateManifestStore({CreateStandardManifest(kManifestLabel1, {})}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| ASSERT_FALSE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetSuccesses(), IsEmpty()); | |
| EXPECT_THAT( | |
| tracker.GetFailures(), | |
| UnorderedElementsAre("hashedUri.missing", "assertion.action.malformed")); | |
| } | |
| TEST(ReferencesValidatorTest, ValidateActionsV2RelatedAssertionsMismatch) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("bar"); | |
| Assertion assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.action" | |
| actions { | |
| actions { | |
| action: "c2pa.opened", | |
| parameters { | |
| related_assertions { | |
| url: "self#jumbf=c2pa.assertions/c2pa.other" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| jumbf::SuperBox other_assertion_box = { | |
| .description = | |
| { | |
| .label = "c2pa.other", | |
| }, | |
| .raw_bytes = "00020000foo", | |
| }; | |
| auto assertion_store = CreateAssertionStoreBox({other_assertion_box}); | |
| jumbf::SuperBox manifest_store = CreateManifestStore( | |
| {CreateStandardManifest(kManifestLabel1, {assertion_store})}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| ASSERT_FALSE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetSuccesses(), IsEmpty()); | |
| EXPECT_THAT( | |
| tracker.GetFailures(), | |
| UnorderedElementsAre("hashedUri.mismatch", "assertion.action.malformed")); | |
| } | |
| TEST(ReferencesValidatorTest, ValidateActionsV2RelatedAssertionsIngredient) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("foo"); | |
| Assertion assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.action" | |
| actions { | |
| actions { | |
| action: "c2pa.opened", | |
| parameters { | |
| related_assertions { | |
| url: "self#jumbf=c2pa.assertions/c2pa.ingredient__1" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| jumbf::SuperBox ingredient_box = { | |
| .description = | |
| { | |
| .label = "c2pa.ingredient__1", | |
| }, | |
| .raw_bytes = "00020000foo", | |
| }; | |
| jumbf::SuperBox assertion_store = CreateAssertionStoreBox({ingredient_box}); | |
| jumbf::SuperBox manifest_store = CreateManifestStore( | |
| {CreateStandardManifest(kManifestLabel1, {assertion_store})}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| ASSERT_FALSE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetSuccesses(), IsEmpty()); | |
| EXPECT_THAT(tracker.GetFailures(), | |
| UnorderedElementsAre("assertion.action.malformed")); | |
| } | |
| TEST(ReferencesValidatorTest, | |
| ValidateActionsV2RelatedAssertionsInSeparateManifest) { | |
| TestValidationTracker tracker; | |
| auto expected_hash = Digest("foo"); | |
| Assertion assertion = ParseTextProtoOrDie<Assertion>(absl::StrFormat( | |
| R"pb( | |
| label: "c2pa.action" | |
| actions { | |
| actions { | |
| action: "c2pa.opened", | |
| parameters { | |
| related_assertions { | |
| url: "self#jumbf=c2pa.assertions/c2pa.other" | |
| algorithm: "sha256" | |
| hash: "%s" | |
| } | |
| } | |
| } | |
| } | |
| )pb", | |
| expected_hash)); | |
| assertion.mutable_actions() | |
| ->mutable_actions(0) | |
| ->mutable_parameters() | |
| ->mutable_related_assertions(0) | |
| ->set_url(absl::StrCat("self#jumbf=/c2pa/", kManifestLabel2, | |
| "/c2pa.assertions/c2pa.other")); | |
| jumbf::SuperBox ingredient_box = { | |
| .description = | |
| { | |
| .label = "c2pa.other", | |
| }, | |
| .raw_bytes = "00020000foo", | |
| }; | |
| jumbf::SuperBox assertion_store = CreateAssertionStoreBox({ingredient_box}); | |
| jumbf::SuperBox manifest_store = CreateManifestStore( | |
| {CreateStandardManifest(kManifestLabel2, {assertion_store}), | |
| CreateStandardManifest(kManifestLabel1, {})}); | |
| jumbf::UriResolver uri_resolver = | |
| jumbf::UriResolver::WithSingleRootChild(&manifest_store); | |
| HashedUriValidator hashed_uri_validator(std::string(kManifestPath1), | |
| uri_resolver); | |
| ReferencesValidator references_validator(&hashed_uri_validator, | |
| kManifestLabel1, &tracker.tracker()); | |
| ASSERT_FALSE(references_validator.Validate(assertion)); | |
| EXPECT_THAT(tracker.GetSuccesses(), IsEmpty()); | |
| EXPECT_THAT(tracker.GetFailures(), | |
| UnorderedElementsAre("assertion.action.malformed")); | |
| } | |
| } // namespace | |
| } // namespace credentio |