chrome/browser/extensions/api/omnibox/suggestion_parser_unittest.cc - chromium/src - Git at Google

 // Copyright 2022 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "chrome/browser/extensions/api/omnibox/suggestion_parser.h"

 #include <memory>

 #include "base/run_loop.h"
 #include "base/test/bind.h"
 #include "content/public/test/browser_task_environment.h"
 #include "services/data_decoder/public/cpp/test_support/in_process_data_decoder.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace extensions {

 namespace {

 constexpr api::omnibox::DescriptionStyleType kMatch =
     api::omnibox::DESCRIPTION_STYLE_TYPE_MATCH;
 constexpr api::omnibox::DescriptionStyleType kDim =
     api::omnibox::DESCRIPTION_STYLE_TYPE_DIM;
 constexpr api::omnibox::DescriptionStyleType kUrl =
     api::omnibox::DESCRIPTION_STYLE_TYPE_URL;

 // A custom matcher for an omnibox::MatchClassification.
 testing::Matcher<api::omnibox::MatchClassification> GetStyleMatcher(
     api::omnibox::DescriptionStyleType type,
     int offset,
     int length) {
   return testing::AllOf(
       ::testing::Field(&api::omnibox::MatchClassification::type,
                        ::testing::Eq(type)),
       ::testing::Field(&api::omnibox::MatchClassification::offset,
                        ::testing::Eq(offset)),
       ::testing::Field(&api::omnibox::MatchClassification::length,
                        ::testing::Pointee(::testing::Eq(length))));
 }

 }  // namespace

 class SuggestionParserUnitTest : public testing::Test {
  public:
   SuggestionParserUnitTest() = default;
   ~SuggestionParserUnitTest() override = default;

   // A helper method to synchronously parses `str` as input and return the
   // result.
   DescriptionAndStyles ParseSingleInput(base::StringPiece str) {
     DescriptionAndStylesResult result;
     ParseImpl({str}, &result);
     if (result.descriptions_and_styles.size() != 1) {
       ADD_FAILURE() << "Failed to parse single input. Resulting size: "
                     << result.descriptions_and_styles.size();
       return DescriptionAndStyles();
     }

     return std::move(result.descriptions_and_styles[0]);
   }
   // Same as above, accepting multiple string inputs.
   std::vector<DescriptionAndStyles> ParseInputs(
       const std::vector<base::StringPiece>& strs) {
     DescriptionAndStylesResult result;
     ParseImpl(strs, &result);
     EXPECT_EQ(std::string(), result.error);
     return std::move(result.descriptions_and_styles);
   }

   // Returns the parsing error from attempting to parse `str`.
   std::string GetParseError(base::StringPiece str) {
     DescriptionAndStylesResult result;
     ParseImpl({str}, &result);
     return result.error;
   }
   // Same as above, accepting multiple string inputs.
   std::string GetParseError(const std::vector<base::StringPiece>& strs) {
     DescriptionAndStylesResult result;
     ParseImpl(strs, &result);
     return result.error;
   }

  private:
   void ParseImpl(const std::vector<base::StringPiece>& strs,
                  DescriptionAndStylesResult* result_out) {
     base::RunLoop run_loop;
     auto get_result = [&run_loop,
                        result_out](DescriptionAndStylesResult result) {
       *result_out = std::move(result);
       run_loop.Quit();
     };

     auto get_result_callback = base::BindLambdaForTesting(get_result);
     if (strs.size() == 1) {
       ParseDescriptionAndStyles(strs[0], std::move(get_result_callback));
     } else {
       ParseDescriptionsAndStyles(strs, std::move(get_result_callback));
     }

     run_loop.Run();

     // Exactly one of error and result should be populated.
     bool has_parsed_entries = !result_out->descriptions_and_styles.empty();
     bool has_error = !result_out->error.empty();
     EXPECT_TRUE(has_parsed_entries ^ has_error)
         << has_parsed_entries << ", " << has_error;
   }

   content::BrowserTaskEnvironment task_environment_;
   data_decoder::test::InProcessDataDecoder data_decoder_;
 };

 // Tests a number of basic cases for XML suggestion parsing.
 TEST_F(SuggestionParserUnitTest, BasicCases) {
   {
     DescriptionAndStyles result =
         ParseSingleInput("hello <match>match</match> world");
     EXPECT_EQ(u"hello match world", result.description);
     EXPECT_THAT(result.styles,
                 testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
   }
   {
     DescriptionAndStyles result = ParseSingleInput(
         "<dim>hello</dim> <match>match</match> <url>world</url>");
     EXPECT_EQ(u"hello match world", result.description);
     EXPECT_THAT(result.styles,
                 testing::ElementsAre(GetStyleMatcher(kDim, 0, 5),
                                      GetStyleMatcher(kMatch, 6, 5),
                                      GetStyleMatcher(kUrl, 12, 5)));
   }
   {
     DescriptionAndStyles result =
         ParseSingleInput("hello <dim>dim <match>dimmed match</match></dim>");
     EXPECT_EQ(u"hello dim dimmed match", result.description);
     EXPECT_THAT(result.styles,
                 testing::ElementsAre(GetStyleMatcher(kDim, 6, 16),
                                      GetStyleMatcher(kMatch, 10, 12)));
   }
 }

 // Tests parsing multiple entries passed to the suggestion parsing.
 TEST_F(SuggestionParserUnitTest, MultipleEntries) {
   {
     std::vector<DescriptionAndStyles> result = ParseInputs(
         {"first <match>match</match> entry", "second <url>url</url> entry",
          "final <dim>dim</dim> entry"});
     ASSERT_EQ(3u, result.size());
     EXPECT_EQ(u"first match entry", result[0].description);
     EXPECT_THAT(result[0].styles,
                 testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
     EXPECT_EQ(u"second url entry", result[1].description);
     EXPECT_THAT(result[1].styles,
                 testing::ElementsAre(GetStyleMatcher(kUrl, 7, 3)));
     EXPECT_EQ(u"final dim entry", result[2].description);
     EXPECT_THAT(result[2].styles,
                 testing::ElementsAre(GetStyleMatcher(kDim, 6, 3)));
   }
   {
     // A fun "hack" that extensions can pull: When parsing multiple suggestions,
     // we join them together with each as an element with the
     // "internal-suggestion" tag. This means that, if an extension wanted to,
     // it could inject inner </internal-suggestion> tags to synthesize extra
     // suggestions. This isn't a security risk at all - it can't do anything
     // besides get extra suggestions, and we don't limit the number of
     // suggestions extensions can provide. There's no reason for extensions to
     // do this, but we add a test as documentation of this "quirk".
     constexpr char kJointSuggestion[] =
         "first <match>match</match></internal-suggestion><internal-suggestion>"
         "second <url>url</url>";
     std::vector<DescriptionAndStyles> result =
         ParseInputs({kJointSuggestion, "final <dim>dim</dim>"});
     ASSERT_EQ(3u, result.size());
     EXPECT_EQ(u"first match", result[0].description);
     EXPECT_THAT(result[0].styles,
                 testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
     EXPECT_EQ(u"second url", result[1].description);
     EXPECT_THAT(result[1].styles,
                 testing::ElementsAre(GetStyleMatcher(kUrl, 7, 3)));
     EXPECT_EQ(u"final dim", result[2].description);
     EXPECT_THAT(result[2].styles,
                 testing::ElementsAre(GetStyleMatcher(kDim, 6, 3)));
   }
 }

 // Tests cases where XML parsing is expected to fail.
 TEST_F(SuggestionParserUnitTest, ParsingFails) {
   // Note: These aren't expected to be terribly robust tests, since XML parsing
   // is exercised significantly more in the XmlParser-related tests.
   EXPECT_THAT(GetParseError("<dim>no closing tag"),
               testing::HasSubstr("Opening and ending tag mismatch"));
   EXPECT_THAT(GetParseError("<dim>hello <url>foo</dim> world</url>"),
               testing::HasSubstr("Opening and ending tag mismatch"));
   // Test an error in one of three inputs.
   EXPECT_THAT(GetParseError({"first <match>match</match> entry",
                              "second <url>url<url> entry",
                              "final <dim>dim</dim> entry"}),
               testing::HasSubstr("Opening and ending tag mismatch"));

   // Test "injection" attacks. Because we synthesize XML documents for and don't
   // do any escaping for the element tags we use ("fragment" and
   // "internal-suggestion"), extensions can prematurely end our tags. This is
   // safe; it just results in invalid XML.
   EXPECT_THAT(GetParseError("first </fragment>DROP TABLE supersecret"),
               testing::HasSubstr("Extra content at the end of the document"));
   EXPECT_THAT(
       GetParseError(
           {"first "
            "</internal-suggestion></fragment>fetch('https://example.com');",
            "second entry"}),
       testing::HasSubstr("Extra content at the end of the document"));

   // Test a suggestion that would add a second "fragment" element to the
   // parsed XML. The XML that ends up being parsed is:
   // <fragment>first suggestion</fragment>
   // <fragment>second</fragment>
   EXPECT_THAT(
       GetParseError("first suggestion</fragment><fragment>second</fragment>"),
       testing::HasSubstr("Extra content at the end of the document"));

   // Test an injection that inserts unexpected children in our synthesized XML
   // document. The XML that ends up being parsed is:
   // <fragment>
   //   <internal-suggestion>first</internal-suggestion>
   //   <other-class>Foobar</other-class>   <-- This was snuck in.
   //   <internal-suggestion>second></internal-suggestion>
   //   <internal-suggestion>final</internal-suggestion>
   // </fragment>
   // This is actually valid XML, and we reject it with our generic error in the
   // handling of the parsed value.
   {
     constexpr char kSneakyXML[] =
         "first</internal-suggestion><other-class>Foobar</other-class>"
         "<internal-suggestion>second";
     EXPECT_EQ("Invalid XML", GetParseError({kSneakyXML, "final suggestion"}));
   }
 }

 // Tests that XML strings are properly sanitized from any forbidden characters.
 TEST_F(SuggestionParserUnitTest, Sanitization) {
   {
     DescriptionAndStyles result =
         ParseSingleInput("  hello <match>match</match> world");
     EXPECT_EQ(u"hello match world", result.description);
     EXPECT_THAT(result.styles,
                 testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
   }
   {
     DescriptionAndStyles result =
         ParseSingleInput("hell\ro <match>ma\ttch</match> wor\nld");
     EXPECT_EQ(u"hello match world", result.description);
     EXPECT_THAT(result.styles,
                 testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
   }
 }

 // Tests that unknown tag types and attributes are properly ignored.
 TEST_F(SuggestionParserUnitTest, UnknownTagsAndAttributesAreIgnored) {
   {
     DescriptionAndStyles result =
         ParseSingleInput("hello <match some-attr=\"foo\">match</match> world");
     EXPECT_EQ(u"hello match world", result.description);
     EXPECT_THAT(result.styles,
                 testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
   }
   {
     DescriptionAndStyles result =
         ParseSingleInput("hello <unknown>match</unknown> world");
     EXPECT_EQ(u"hello match world", result.description);
     EXPECT_THAT(result.styles, testing::IsEmpty());
   }
 }

 }  // namespace extensions
	// Copyright 2022 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "chrome/browser/extensions/api/omnibox/suggestion_parser.h"

	#include <memory>

	#include "base/run_loop.h"
	#include "base/test/bind.h"
	#include "content/public/test/browser_task_environment.h"
	#include "services/data_decoder/public/cpp/test_support/in_process_data_decoder.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace extensions {

	namespace {

	constexpr api::omnibox::DescriptionStyleType kMatch =
	api::omnibox::DESCRIPTION_STYLE_TYPE_MATCH;
	constexpr api::omnibox::DescriptionStyleType kDim =
	api::omnibox::DESCRIPTION_STYLE_TYPE_DIM;
	constexpr api::omnibox::DescriptionStyleType kUrl =
	api::omnibox::DESCRIPTION_STYLE_TYPE_URL;

	// A custom matcher for an omnibox::MatchClassification.
	testing::Matcher<api::omnibox::MatchClassification> GetStyleMatcher(
	api::omnibox::DescriptionStyleType type,
	int offset,
	int length) {
	return testing::AllOf(
	::testing::Field(&api::omnibox::MatchClassification::type,
	::testing::Eq(type)),
	::testing::Field(&api::omnibox::MatchClassification::offset,
	::testing::Eq(offset)),
	::testing::Field(&api::omnibox::MatchClassification::length,
	::testing::Pointee(::testing::Eq(length))));
	}

	} // namespace

	class SuggestionParserUnitTest : public testing::Test {
	public:
	SuggestionParserUnitTest() = default;
	~SuggestionParserUnitTest() override = default;

	// A helper method to synchronously parses `str` as input and return the
	// result.
	DescriptionAndStyles ParseSingleInput(base::StringPiece str) {
	DescriptionAndStylesResult result;
	ParseImpl({str}, &result);
	if (result.descriptions_and_styles.size() != 1) {
	ADD_FAILURE() << "Failed to parse single input. Resulting size: "
	<< result.descriptions_and_styles.size();
	return DescriptionAndStyles();
	}

	return std::move(result.descriptions_and_styles[0]);
	}
	// Same as above, accepting multiple string inputs.
	std::vector<DescriptionAndStyles> ParseInputs(
	const std::vector<base::StringPiece>& strs) {
	DescriptionAndStylesResult result;
	ParseImpl(strs, &result);
	EXPECT_EQ(std::string(), result.error);
	return std::move(result.descriptions_and_styles);
	}

	// Returns the parsing error from attempting to parse `str`.
	std::string GetParseError(base::StringPiece str) {
	DescriptionAndStylesResult result;
	ParseImpl({str}, &result);
	return result.error;
	}
	// Same as above, accepting multiple string inputs.
	std::string GetParseError(const std::vector<base::StringPiece>& strs) {
	DescriptionAndStylesResult result;
	ParseImpl(strs, &result);
	return result.error;
	}

	private:
	void ParseImpl(const std::vector<base::StringPiece>& strs,
	DescriptionAndStylesResult* result_out) {
	base::RunLoop run_loop;
	auto get_result = [&run_loop,
	result_out](DescriptionAndStylesResult result) {
	*result_out = std::move(result);
	run_loop.Quit();
	};

	auto get_result_callback = base::BindLambdaForTesting(get_result);
	if (strs.size() == 1) {
	ParseDescriptionAndStyles(strs[0], std::move(get_result_callback));
	} else {
	ParseDescriptionsAndStyles(strs, std::move(get_result_callback));
	}

	run_loop.Run();

	// Exactly one of error and result should be populated.
	bool has_parsed_entries = !result_out->descriptions_and_styles.empty();
	bool has_error = !result_out->error.empty();
	EXPECT_TRUE(has_parsed_entries ^ has_error)
	<< has_parsed_entries << ", " << has_error;
	}

	content::BrowserTaskEnvironment task_environment_;
	data_decoder::test::InProcessDataDecoder data_decoder_;
	};

	// Tests a number of basic cases for XML suggestion parsing.
	TEST_F(SuggestionParserUnitTest, BasicCases) {
	{
	DescriptionAndStyles result =
	ParseSingleInput("hello <match>match</match> world");
	EXPECT_EQ(u"hello match world", result.description);
	EXPECT_THAT(result.styles,
	testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
	}
	{
	DescriptionAndStyles result = ParseSingleInput(
	"<dim>hello</dim> <match>match</match> <url>world</url>");
	EXPECT_EQ(u"hello match world", result.description);
	EXPECT_THAT(result.styles,
	testing::ElementsAre(GetStyleMatcher(kDim, 0, 5),
	GetStyleMatcher(kMatch, 6, 5),
	GetStyleMatcher(kUrl, 12, 5)));
	}
	{
	DescriptionAndStyles result =
	ParseSingleInput("hello <dim>dim <match>dimmed match</match></dim>");
	EXPECT_EQ(u"hello dim dimmed match", result.description);
	EXPECT_THAT(result.styles,
	testing::ElementsAre(GetStyleMatcher(kDim, 6, 16),
	GetStyleMatcher(kMatch, 10, 12)));
	}
	}

	// Tests parsing multiple entries passed to the suggestion parsing.
	TEST_F(SuggestionParserUnitTest, MultipleEntries) {
	{
	std::vector<DescriptionAndStyles> result = ParseInputs(
	{"first <match>match</match> entry", "second <url>url</url> entry",
	"final <dim>dim</dim> entry"});
	ASSERT_EQ(3u, result.size());
	EXPECT_EQ(u"first match entry", result[0].description);
	EXPECT_THAT(result[0].styles,
	testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
	EXPECT_EQ(u"second url entry", result[1].description);
	EXPECT_THAT(result[1].styles,
	testing::ElementsAre(GetStyleMatcher(kUrl, 7, 3)));
	EXPECT_EQ(u"final dim entry", result[2].description);
	EXPECT_THAT(result[2].styles,
	testing::ElementsAre(GetStyleMatcher(kDim, 6, 3)));
	}
	{
	// A fun "hack" that extensions can pull: When parsing multiple suggestions,
	// we join them together with each as an element with the
	// "internal-suggestion" tag. This means that, if an extension wanted to,
	// it could inject inner </internal-suggestion> tags to synthesize extra
	// suggestions. This isn't a security risk at all - it can't do anything
	// besides get extra suggestions, and we don't limit the number of
	// suggestions extensions can provide. There's no reason for extensions to
	// do this, but we add a test as documentation of this "quirk".
	constexpr char kJointSuggestion[] =
	"first <match>match</match></internal-suggestion><internal-suggestion>"
	"second <url>url</url>";
	std::vector<DescriptionAndStyles> result =
	ParseInputs({kJointSuggestion, "final <dim>dim</dim>"});
	ASSERT_EQ(3u, result.size());
	EXPECT_EQ(u"first match", result[0].description);
	EXPECT_THAT(result[0].styles,
	testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
	EXPECT_EQ(u"second url", result[1].description);
	EXPECT_THAT(result[1].styles,
	testing::ElementsAre(GetStyleMatcher(kUrl, 7, 3)));
	EXPECT_EQ(u"final dim", result[2].description);
	EXPECT_THAT(result[2].styles,
	testing::ElementsAre(GetStyleMatcher(kDim, 6, 3)));
	}
	}

	// Tests cases where XML parsing is expected to fail.
	TEST_F(SuggestionParserUnitTest, ParsingFails) {
	// Note: These aren't expected to be terribly robust tests, since XML parsing
	// is exercised significantly more in the XmlParser-related tests.
	EXPECT_THAT(GetParseError("<dim>no closing tag"),
	testing::HasSubstr("Opening and ending tag mismatch"));
	EXPECT_THAT(GetParseError("<dim>hello <url>foo</dim> world</url>"),
	testing::HasSubstr("Opening and ending tag mismatch"));
	// Test an error in one of three inputs.
	EXPECT_THAT(GetParseError({"first <match>match</match> entry",
	"second <url>url<url> entry",
	"final <dim>dim</dim> entry"}),
	testing::HasSubstr("Opening and ending tag mismatch"));

	// Test "injection" attacks. Because we synthesize XML documents for and don't
	// do any escaping for the element tags we use ("fragment" and
	// "internal-suggestion"), extensions can prematurely end our tags. This is
	// safe; it just results in invalid XML.
	EXPECT_THAT(GetParseError("first </fragment>DROP TABLE supersecret"),
	testing::HasSubstr("Extra content at the end of the document"));
	EXPECT_THAT(
	GetParseError(
	{"first "
	"</internal-suggestion></fragment>fetch('https://example.com');",
	"second entry"}),
	testing::HasSubstr("Extra content at the end of the document"));

	// Test a suggestion that would add a second "fragment" element to the
	// parsed XML. The XML that ends up being parsed is:
	// <fragment>first suggestion</fragment>
	// <fragment>second</fragment>
	EXPECT_THAT(
	GetParseError("first suggestion</fragment><fragment>second</fragment>"),
	testing::HasSubstr("Extra content at the end of the document"));

	// Test an injection that inserts unexpected children in our synthesized XML
	// document. The XML that ends up being parsed is:
	// <fragment>
	// <internal-suggestion>first</internal-suggestion>
	// <other-class>Foobar</other-class> <-- This was snuck in.
	// <internal-suggestion>second></internal-suggestion>
	// <internal-suggestion>final</internal-suggestion>
	// </fragment>
	// This is actually valid XML, and we reject it with our generic error in the
	// handling of the parsed value.
	{
	constexpr char kSneakyXML[] =
	"first</internal-suggestion><other-class>Foobar</other-class>"
	"<internal-suggestion>second";
	EXPECT_EQ("Invalid XML", GetParseError({kSneakyXML, "final suggestion"}));
	}
	}

	// Tests that XML strings are properly sanitized from any forbidden characters.
	TEST_F(SuggestionParserUnitTest, Sanitization) {
	{
	DescriptionAndStyles result =
	ParseSingleInput(" hello <match>match</match> world");
	EXPECT_EQ(u"hello match world", result.description);
	EXPECT_THAT(result.styles,
	testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
	}
	{
	DescriptionAndStyles result =
	ParseSingleInput("hell\ro <match>ma\ttch</match> wor\nld");
	EXPECT_EQ(u"hello match world", result.description);
	EXPECT_THAT(result.styles,
	testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
	}
	}

	// Tests that unknown tag types and attributes are properly ignored.
	TEST_F(SuggestionParserUnitTest, UnknownTagsAndAttributesAreIgnored) {
	{
	DescriptionAndStyles result =
	ParseSingleInput("hello <match some-attr=\"foo\">match</match> world");
	EXPECT_EQ(u"hello match world", result.description);
	EXPECT_THAT(result.styles,
	testing::ElementsAre(GetStyleMatcher(kMatch, 6, 5)));
	}
	{
	DescriptionAndStyles result =
	ParseSingleInput("hello <unknown>match</unknown> world");
	EXPECT_EQ(u"hello match world", result.description);
	EXPECT_THAT(result.styles, testing::IsEmpty());
	}
	}

	} // namespace extensions