/* * Copyright (c) 2009-2021, Google LLC * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of Google LLC nor the * names of its contributors may be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "gmock/gmock.h" #include "gtest/gtest.h" #include "google/protobuf/test_messages_proto3.upb.h" #include "upb/def.hpp" #include "upb/fuzz_test_util.h" #include "upb/json_decode.h" #include "upb/json_encode.h" #include "upb/msg_test.upb.h" #include "upb/msg_test.upbdefs.h" #include "upb/upb.hpp" // begin:google_only // #include "testing/fuzzing/fuzztest.h" // end:google_only void VerifyMessage(const upb_test_TestExtensions* ext_msg) { EXPECT_TRUE(upb_test_TestExtensions_has_optional_int32_ext(ext_msg)); // EXPECT_FALSE(upb_test_TestExtensions_Nested_has_optional_int32_ext(ext_msg)); EXPECT_TRUE(upb_test_has_optional_msg_ext(ext_msg)); EXPECT_EQ(123, upb_test_TestExtensions_optional_int32_ext(ext_msg)); const protobuf_test_messages_proto3_TestAllTypesProto3* ext_submsg = upb_test_optional_msg_ext(ext_msg); EXPECT_TRUE(ext_submsg != nullptr); EXPECT_EQ(456, protobuf_test_messages_proto3_TestAllTypesProto3_optional_int32( ext_submsg)); } TEST(MessageTest, Extensions) { upb::Arena arena; upb_test_TestExtensions* ext_msg = upb_test_TestExtensions_new(arena.ptr()); EXPECT_FALSE(upb_test_TestExtensions_has_optional_int32_ext(ext_msg)); // EXPECT_FALSE(upb_test_TestExtensions_Nested_has_optional_int32_ext(ext_msg)); EXPECT_FALSE(upb_test_has_optional_msg_ext(ext_msg)); upb::DefPool defpool; upb::MessageDefPtr m(upb_test_TestExtensions_getmsgdef(defpool.ptr())); EXPECT_TRUE(m.ptr() != nullptr); std::string json = R"json( { "[upb_test.TestExtensions.optional_int32_ext]": 123, "[upb_test.TestExtensions.Nested.repeated_int32_ext]": [2, 4, 6], "[upb_test.optional_msg_ext]": {"optional_int32": 456} } )json"; upb::Status status; EXPECT_TRUE(upb_JsonDecode(json.data(), json.size(), ext_msg, m.ptr(), defpool.ptr(), 0, arena.ptr(), status.ptr())) << status.error_message(); VerifyMessage(ext_msg); // Test round-trip through binary format. size_t size; char* serialized = upb_test_TestExtensions_serialize(ext_msg, arena.ptr(), &size); ASSERT_TRUE(serialized != nullptr); ASSERT_GE(size, 0); upb_test_TestExtensions* ext_msg2 = upb_test_TestExtensions_parse_ex( serialized, size, upb_DefPool_ExtensionRegistry(defpool.ptr()), 0, arena.ptr()); VerifyMessage(ext_msg2); // Test round-trip through JSON format. size_t json_size = upb_JsonEncode(ext_msg, m.ptr(), defpool.ptr(), 0, NULL, 0, status.ptr()); char* json_buf = static_cast(upb_Arena_Malloc(arena.ptr(), json_size + 1)); upb_JsonEncode(ext_msg, m.ptr(), defpool.ptr(), 0, json_buf, json_size + 1, status.ptr()); upb_test_TestExtensions* ext_msg3 = upb_test_TestExtensions_new(arena.ptr()); EXPECT_TRUE(upb_JsonDecode(json_buf, json_size, ext_msg3, m.ptr(), defpool.ptr(), 0, arena.ptr(), status.ptr())) << status.error_message(); VerifyMessage(ext_msg3); } void VerifyMessageSet(const upb_test_TestMessageSet* mset_msg) { ASSERT_TRUE(mset_msg != nullptr); bool has = upb_test_MessageSetMember_has_message_set_extension(mset_msg); EXPECT_TRUE(has); if (!has) return; const upb_test_MessageSetMember* member = upb_test_MessageSetMember_message_set_extension(mset_msg); EXPECT_TRUE(member != nullptr); EXPECT_TRUE(upb_test_MessageSetMember_has_optional_int32(member)); EXPECT_EQ(234, upb_test_MessageSetMember_optional_int32(member)); } TEST(MessageTest, MessageSet) { upb::Arena arena; upb_test_TestMessageSet* ext_msg = upb_test_TestMessageSet_new(arena.ptr()); EXPECT_FALSE(upb_test_MessageSetMember_has_message_set_extension(ext_msg)); upb::DefPool defpool; upb::MessageDefPtr m(upb_test_TestMessageSet_getmsgdef(defpool.ptr())); EXPECT_TRUE(m.ptr() != nullptr); std::string json = R"json( { "[upb_test.MessageSetMember]": {"optional_int32": 234} } )json"; upb::Status status; EXPECT_TRUE(upb_JsonDecode(json.data(), json.size(), ext_msg, m.ptr(), defpool.ptr(), 0, arena.ptr(), status.ptr())) << status.error_message(); VerifyMessageSet(ext_msg); // Test round-trip through binary format. size_t size; char* serialized = upb_test_TestMessageSet_serialize(ext_msg, arena.ptr(), &size); ASSERT_TRUE(serialized != nullptr); ASSERT_GE(size, 0); upb_test_TestMessageSet* ext_msg2 = upb_test_TestMessageSet_parse_ex( serialized, size, upb_DefPool_ExtensionRegistry(defpool.ptr()), 0, arena.ptr()); VerifyMessageSet(ext_msg2); // Test round-trip through JSON format. size_t json_size = upb_JsonEncode(ext_msg, m.ptr(), defpool.ptr(), 0, NULL, 0, status.ptr()); char* json_buf = static_cast(upb_Arena_Malloc(arena.ptr(), json_size + 1)); upb_JsonEncode(ext_msg, m.ptr(), defpool.ptr(), 0, json_buf, json_size + 1, status.ptr()); upb_test_TestMessageSet* ext_msg3 = upb_test_TestMessageSet_new(arena.ptr()); EXPECT_TRUE(upb_JsonDecode(json_buf, json_size, ext_msg3, m.ptr(), defpool.ptr(), 0, arena.ptr(), status.ptr())) << status.error_message(); VerifyMessageSet(ext_msg3); } TEST(MessageTest, UnknownMessageSet) { static const char data[] = "ABCDE"; upb_StringView data_view = upb_StringView_FromString(data); upb::Arena arena; upb_test_FakeMessageSet* fake = upb_test_FakeMessageSet_new(arena.ptr()); // Add a MessageSet item that is unknown (there is no matching extension in // the .proto file) upb_test_FakeMessageSet_Item* item = upb_test_FakeMessageSet_add_item(fake, arena.ptr()); upb_test_FakeMessageSet_Item_set_type_id(item, 12345); upb_test_FakeMessageSet_Item_set_message(item, data_view); // Set unknown fields inside the message set to test that we can skip them. upb_test_FakeMessageSet_Item_set_unknown_varint(item, 12345678); upb_test_FakeMessageSet_Item_set_unknown_fixed32(item, 12345678); upb_test_FakeMessageSet_Item_set_unknown_fixed64(item, 12345678); upb_test_FakeMessageSet_Item_set_unknown_bytes(item, data_view); upb_test_FakeMessageSet_Item_mutable_unknowngroup(item, arena.ptr()); // Round trip through a true MessageSet where this item_id is unknown. size_t size; char* serialized = upb_test_FakeMessageSet_serialize(fake, arena.ptr(), &size); ASSERT_TRUE(serialized != nullptr); ASSERT_GE(size, 0); upb::DefPool defpool; upb::MessageDefPtr m(upb_test_TestMessageSet_getmsgdef(defpool.ptr())); EXPECT_TRUE(m.ptr() != nullptr); upb_test_TestMessageSet* message_set = upb_test_TestMessageSet_parse_ex( serialized, size, upb_DefPool_ExtensionRegistry(defpool.ptr()), 0, arena.ptr()); ASSERT_TRUE(message_set != nullptr); char* serialized2 = upb_test_TestMessageSet_serialize(message_set, arena.ptr(), &size); ASSERT_TRUE(serialized2 != nullptr); ASSERT_GE(size, 0); // Parse back into a fake MessageSet and verify that the unknown MessageSet // item was preserved in full (both type_id and message). upb_test_FakeMessageSet* fake2 = upb_test_FakeMessageSet_parse(serialized2, size, arena.ptr()); ASSERT_TRUE(fake2 != nullptr); const upb_test_FakeMessageSet_Item* const* items = upb_test_FakeMessageSet_item(fake2, &size); ASSERT_EQ(1, size); EXPECT_EQ(12345, upb_test_FakeMessageSet_Item_type_id(items[0])); EXPECT_TRUE(upb_StringView_IsEqual( data_view, upb_test_FakeMessageSet_Item_message(items[0]))); // The non-MessageSet unknown fields should have been discarded. EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknown_varint(items[0])); EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknown_fixed32(items[0])); EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknown_fixed64(items[0])); EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknown_bytes(items[0])); EXPECT_FALSE(upb_test_FakeMessageSet_Item_has_unknowngroup(items[0])); } TEST(MessageTest, Proto2Enum) { upb::Arena arena; upb_test_Proto2FakeEnumMessage* fake_msg = upb_test_Proto2FakeEnumMessage_new(arena.ptr()); upb_test_Proto2FakeEnumMessage_set_optional_enum(fake_msg, 999); int32_t* vals = upb_test_Proto2FakeEnumMessage_resize_repeated_enum( fake_msg, 6, arena.ptr()); vals[0] = upb_test_Proto2EnumMessage_ZERO; vals[1] = 7; // Unknown small. vals[2] = upb_test_Proto2EnumMessage_SMALL; vals[3] = 888; // Unknown large. vals[4] = upb_test_Proto2EnumMessage_LARGE; vals[5] = upb_test_Proto2EnumMessage_NEGATIVE; vals = upb_test_Proto2FakeEnumMessage_resize_packed_enum(fake_msg, 6, arena.ptr()); vals[0] = upb_test_Proto2EnumMessage_ZERO; vals[1] = 7; // Unknown small. vals[2] = upb_test_Proto2EnumMessage_SMALL; vals[3] = 888; // Unknown large. vals[4] = upb_test_Proto2EnumMessage_LARGE; vals[5] = upb_test_Proto2EnumMessage_NEGATIVE; size_t size; char* pb = upb_test_Proto2FakeEnumMessage_serialize(fake_msg, arena.ptr(), &size); // Parsing as enums puts unknown values into unknown fields. upb_test_Proto2EnumMessage* enum_msg = upb_test_Proto2EnumMessage_parse(pb, size, arena.ptr()); ASSERT_TRUE(enum_msg != nullptr); EXPECT_EQ(false, upb_test_Proto2EnumMessage_has_optional_enum(enum_msg)); const int32_t* vals_const = upb_test_Proto2EnumMessage_repeated_enum(enum_msg, &size); EXPECT_EQ(4, size); // Two unknown values moved to the unknown field set. // Parsing back into the fake message shows the original data, except the // repeated enum is rearranged. pb = upb_test_Proto2EnumMessage_serialize(enum_msg, arena.ptr(), &size); upb_test_Proto2FakeEnumMessage* fake_msg2 = upb_test_Proto2FakeEnumMessage_parse(pb, size, arena.ptr()); EXPECT_EQ(true, upb_test_Proto2FakeEnumMessage_has_optional_enum(fake_msg2)); EXPECT_EQ(999, upb_test_Proto2FakeEnumMessage_optional_enum(fake_msg2)); int32_t expected[] = { upb_test_Proto2EnumMessage_ZERO, upb_test_Proto2EnumMessage_SMALL, upb_test_Proto2EnumMessage_LARGE, upb_test_Proto2EnumMessage_NEGATIVE, 7, 888, }; vals_const = upb_test_Proto2FakeEnumMessage_repeated_enum(fake_msg2, &size); EXPECT_EQ(6, size); EXPECT_THAT(std::vector(vals_const, vals_const + size), ::testing::ElementsAreArray(expected)); vals_const = upb_test_Proto2FakeEnumMessage_packed_enum(fake_msg2, &size); EXPECT_EQ(6, size); EXPECT_THAT(std::vector(vals_const, vals_const + size), ::testing::ElementsAreArray(expected)); } TEST(MessageTest, TestBadUTF8) { upb::Arena arena; std::string serialized("r\x03\xed\xa0\x81"); EXPECT_EQ(nullptr, protobuf_test_messages_proto3_TestAllTypesProto3_parse( serialized.data(), serialized.size(), arena.ptr())); } TEST(MessageTest, DecodeRequiredFieldsTopLevelMessage) { upb::Arena arena; upb_test_TestRequiredFields* test_msg; upb_test_EmptyMessage* empty_msg; // Succeeds, because we did not request required field checks. test_msg = upb_test_TestRequiredFields_parse(NULL, 0, arena.ptr()); EXPECT_NE(nullptr, test_msg); // Fails, because required fields are missing. EXPECT_EQ(kUpb_DecodeStatus_MissingRequired, upb_Decode(NULL, 0, test_msg, &upb_test_TestRequiredFields_msg_init, NULL, kUpb_DecodeOption_CheckRequired, arena.ptr())); upb_test_TestRequiredFields_set_required_int32(test_msg, 1); size_t size; char* serialized = upb_test_TestRequiredFields_serialize(test_msg, arena.ptr(), &size); ASSERT_TRUE(serialized != nullptr); EXPECT_NE(0, size); // Fails, but the code path is slightly different because the serialized // payload is not empty. EXPECT_EQ(kUpb_DecodeStatus_MissingRequired, upb_Decode(serialized, size, test_msg, &upb_test_TestRequiredFields_msg_init, NULL, kUpb_DecodeOption_CheckRequired, arena.ptr())); empty_msg = upb_test_EmptyMessage_new(arena.ptr()); upb_test_TestRequiredFields_set_required_int32(test_msg, 1); upb_test_TestRequiredFields_set_required_int64(test_msg, 2); upb_test_TestRequiredFields_set_required_message(test_msg, empty_msg); // Succeeds, because required fields are present (though not in the input). EXPECT_EQ(kUpb_DecodeStatus_Ok, upb_Decode(NULL, 0, test_msg, &upb_test_TestRequiredFields_msg_init, NULL, kUpb_DecodeOption_CheckRequired, arena.ptr())); // Serialize a complete payload. serialized = upb_test_TestRequiredFields_serialize(test_msg, arena.ptr(), &size); ASSERT_TRUE(serialized != nullptr); EXPECT_NE(0, size); upb_test_TestRequiredFields* test_msg2 = upb_test_TestRequiredFields_parse_ex( serialized, size, NULL, kUpb_DecodeOption_CheckRequired, arena.ptr()); EXPECT_NE(nullptr, test_msg2); // When we add an incomplete sub-message, this is not flagged by the parser. // This makes parser checking unsuitable for MergeFrom(). upb_test_TestRequiredFields_set_optional_message( test_msg2, upb_test_TestRequiredFields_new(arena.ptr())); EXPECT_EQ(kUpb_DecodeStatus_Ok, upb_Decode(serialized, size, test_msg2, &upb_test_TestRequiredFields_msg_init, NULL, kUpb_DecodeOption_CheckRequired, arena.ptr())); } TEST(MessageTest, DecodeRequiredFieldsSubMessage) { upb::Arena arena; upb_test_TestRequiredFields* test_msg = upb_test_TestRequiredFields_new(arena.ptr()); upb_test_SubMessageHasRequired* sub_msg = upb_test_SubMessageHasRequired_new(arena.ptr()); upb_test_EmptyMessage* empty_msg = upb_test_EmptyMessage_new(arena.ptr()); upb_test_SubMessageHasRequired_set_optional_message(sub_msg, test_msg); size_t size; char* serialized = upb_test_SubMessageHasRequired_serialize(sub_msg, arena.ptr(), &size); EXPECT_NE(0, size); // No parse error when parsing normally. EXPECT_NE(nullptr, upb_test_SubMessageHasRequired_parse(serialized, size, arena.ptr())); // Parse error when verifying required fields, due to incomplete sub-message. EXPECT_EQ(nullptr, upb_test_SubMessageHasRequired_parse_ex( serialized, size, NULL, kUpb_DecodeOption_CheckRequired, arena.ptr())); upb_test_TestRequiredFields_set_required_int32(test_msg, 1); upb_test_TestRequiredFields_set_required_int64(test_msg, 2); upb_test_TestRequiredFields_set_required_message(test_msg, empty_msg); serialized = upb_test_SubMessageHasRequired_serialize(sub_msg, arena.ptr(), &size); EXPECT_NE(0, size); // No parse error; sub-message now is complete. EXPECT_NE(nullptr, upb_test_SubMessageHasRequired_parse_ex( serialized, size, NULL, kUpb_DecodeOption_CheckRequired, arena.ptr())); } TEST(MessageTest, EncodeRequiredFields) { upb::Arena arena; upb_test_TestRequiredFields* test_msg = upb_test_TestRequiredFields_new(arena.ptr()); // Succeeds, we didn't ask for required field checking. size_t size; char* serialized = upb_test_TestRequiredFields_serialize_ex(test_msg, 0, arena.ptr(), &size); ASSERT_TRUE(serialized != nullptr); EXPECT_EQ(size, 0); // Fails, we asked for required field checking but the required field is // missing. serialized = upb_test_TestRequiredFields_serialize_ex( test_msg, kUpb_EncodeOption_CheckRequired, arena.ptr(), &size); ASSERT_TRUE(serialized == nullptr); // Fails, some required fields are present but not others. upb_test_TestRequiredFields_set_required_int32(test_msg, 1); serialized = upb_test_TestRequiredFields_serialize_ex( test_msg, kUpb_EncodeOption_CheckRequired, arena.ptr(), &size); ASSERT_TRUE(serialized == nullptr); // Succeeds, all required fields are set. upb_test_EmptyMessage* empty_msg = upb_test_EmptyMessage_new(arena.ptr()); upb_test_TestRequiredFields_set_required_int64(test_msg, 2); upb_test_TestRequiredFields_set_required_message(test_msg, empty_msg); serialized = upb_test_TestRequiredFields_serialize_ex( test_msg, kUpb_EncodeOption_CheckRequired, arena.ptr(), &size); ASSERT_TRUE(serialized != nullptr); } TEST(MessageTest, MaxRequiredFields) { upb::Arena arena; upb_test_TestMaxRequiredFields* test_msg = upb_test_TestMaxRequiredFields_new(arena.ptr()); // Fails, we asked for required field checking but the required field is // missing. size_t size; char* serialized = upb_test_TestMaxRequiredFields_serialize_ex( test_msg, kUpb_EncodeOption_CheckRequired, arena.ptr(), &size); ASSERT_TRUE(serialized == nullptr); upb::DefPool defpool; upb::MessageDefPtr m(upb_test_TestMaxRequiredFields_getmsgdef(defpool.ptr())); upb_MessageValue val; val.int32_val = 1; for (int i = 1; i <= 61; i++) { upb::FieldDefPtr f = m.FindFieldByNumber(i); ASSERT_TRUE(f); upb_Message_Set(test_msg, f.ptr(), val, arena.ptr()); } // Fails, field 63 still isn't set. serialized = upb_test_TestMaxRequiredFields_serialize_ex( test_msg, kUpb_EncodeOption_CheckRequired, arena.ptr(), &size); ASSERT_TRUE(serialized == nullptr); // Succeeds, all required fields are set. upb::FieldDefPtr f = m.FindFieldByNumber(62); ASSERT_TRUE(f); upb_Message_Set(test_msg, f.ptr(), val, arena.ptr()); serialized = upb_test_TestMaxRequiredFields_serialize_ex( test_msg, kUpb_EncodeOption_CheckRequired, arena.ptr(), &size); ASSERT_TRUE(serialized != nullptr); } TEST(MessageTest, MapField) { upb::Arena arena; upb_test_TestMapFieldExtra* test_msg_extra = upb_test_TestMapFieldExtra_new(arena.ptr()); ASSERT_TRUE(upb_test_TestMapFieldExtra_map_field_set( test_msg_extra, 0, upb_test_TestMapFieldExtra_THREE, arena.ptr())); size_t size; char* serialized = upb_test_TestMapFieldExtra_serialize_ex( test_msg_extra, 0, arena.ptr(), &size); ASSERT_NE(nullptr, serialized); ASSERT_NE(0, size); upb_test_TestMapField* test_msg = upb_test_TestMapField_parse(serialized, size, arena.ptr()); ASSERT_NE(nullptr, test_msg); ASSERT_FALSE(upb_test_TestMapField_map_field_get(test_msg, 0, nullptr)); serialized = upb_test_TestMapField_serialize_ex(test_msg, 0, arena.ptr(), &size); ASSERT_NE(0, size); // parse into second instance upb_test_TestMapFieldExtra* test_msg_extra2 = upb_test_TestMapFieldExtra_parse(serialized, size, arena.ptr()); ASSERT_TRUE( upb_test_TestMapFieldExtra_map_field_get(test_msg_extra2, 0, nullptr)); } // begin:google_only // // static void DecodeEncodeArbitrarySchemaAndPayload( // const upb::fuzz::MiniTableFuzzInput& input, std::string_view proto_payload, // int decode_options, int encode_options) { // upb::Arena arena; // upb_ExtensionRegistry* exts; // const upb_MiniTable* mini_table = // upb::fuzz::BuildMiniTable(input, &exts, arena.ptr()); // if (!mini_table) return; // upb::Status status; // upb_Message* msg = _upb_Message_New(mini_table, arena.ptr()); // upb_Decode(proto_payload.data(), proto_payload.size(), msg, mini_table, exts, // decode_options, arena.ptr()); // char* ptr; // size_t size; // upb_Encode(msg, mini_table, encode_options, arena.ptr(), &ptr, &size); // } // FUZZ_TEST(FuzzTest, DecodeEncodeArbitrarySchemaAndPayload); // // end:google_only