Support subdomain matching in trial tokens

content/common/origin_trials/trial_token_unittest.cc

 // Copyright 2015 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 "content/common/origin_trials/trial_token.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/strings/string_piece.h"
@@ skipping 49 matching lines @@
 // Generate this token with the command (in tools/origin_trials):
 // generate_token.py valid.example.com Frobulate --expire-timestamp=1458766277
 const char* kSampleToken =
     "Ap+Q/Qm0ELadZql+dlEGSwnAVsFZKgCEtUZg8idQC3uekkIeSZIY1tftoYdrwhqj"
     "7FO5L22sNvkZZnacLvmfNwsAAABZeyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5l"
     "eGFtcGxlLmNvbTo0NDMiLCAiZmVhdHVyZSI6ICJGcm9idWxhdGUiLCAiZXhwaXJ5"
     "IjogMTQ1ODc2NjI3N30=";
 
 const char* kExpectedFeatureName = "Frobulate";
 const char* kExpectedOrigin = "https://valid.example.com";
+const char* kExpectedWildcardOrigin = "https://example.com";
+const char* kExpectedMultipleSubdomainOrigin =
+    "https://part1.part2.part3.example.com";
 const uint64_t kExpectedExpiry = 1458766277;
 
 // The token should not be valid for this origin, or for this feature.
 const char* kInvalidOrigin = "https://invalid.example.com";
 const char* kInsecureOrigin = "http://valid.example.com";
+const char* kIncorrectPortOrigin = "https://valid.example.com:444";
+const char* kIncorrectDomainOrigin = "https://valid.example2.com";

[iclelland, 2016/10/12 04:18:16]

Can you add one more bad domain for wildcard testing? I'd like to see the
wildcard token tested against "https://com", just to ensure that
Origin::DomainIs is filtering the domains in the right direction.

 const char* kInvalidFeatureName = "Grokalyze";
 
 // The token should be valid if the current time is kValidTimestamp or earlier.
 double kValidTimestamp = 1458766276.0;
 
 // The token should be invalid if the current time is kInvalidTimestamp or
 // later.
 double kInvalidTimestamp = 1458766278.0;
 
 // Well-formed trial token with an invalid signature.
@@ skipping 20 matching lines @@
 const char kIncorrectVersionToken[] =
     "KlH8wVLT5o59uDvlJESorMDjzgWnvG1hmIn/GiT9Ng3f45ratVeiXCNTeaJheOaG"
     "A6kX4ir4Amv8aHVC+OJHZQkAAABZeyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5l"
     "eGFtcGxlLmNvbTo0NDMiLCAiZmVhdHVyZSI6ICJGcm9idWxhdGUiLCAiZXhwaXJ5"
     "IjogMTQ1ODc2NjI3N30=";
 
 const char kSampleTokenJSON[] =
     "{\"origin\": \"https://valid.example.com:443\", \"feature\": "
     "\"Frobulate\", \"expiry\": 1458766277}";
 
+const char kSampleNonWildcardTokenJSON[] =
+    "{\"origin\": \"https://valid.example.com:443\", \"isWildcard\": false, "
+    "\"feature\": \"Frobulate\", \"expiry\": 1458766277}";
+
+const char kSampleWildcardTokenJSON[] =
+    "{\"origin\": \"https://example.com:443\", \"isWildcard\": true, "
+    "\"feature\": \"Frobulate\", \"expiry\": 1458766277}";
+
 // Various ill-formed trial tokens. These should all fail to parse.
 const char* kInvalidTokens[] = {
     // Invalid - Not JSON at all
     "abcde",
     // Invalid JSON
     "{",
     // Not an object
     "\"abcde\"",
     "123.4",
     "[0, 1, 2]",
     // Missing keys
     "{}",
     "{\"something\": 1}",
     "{\"origin\": \"https://a.a\"}",
-    "{\"origin\": \"https://a.a\", \"feature\": \"a\"}"
+    "{\"origin\": \"https://a.a\", \"feature\": \"a\"}",

[iclelland, 2016/10/12 04:18:16]

Good catch

     "{\"origin\": \"https://a.a\", \"expiry\": 1458766277}",
     "{\"feature\": \"FeatureName\", \"expiry\": 1458766277}",
     // Incorrect types
     "{\"origin\": 1, \"feature\": \"a\", \"expiry\": 1458766277}",
     "{\"origin\": \"https://a.a\", \"feature\": 1, \"expiry\": 1458766277}",
     "{\"origin\": \"https://a.a\", \"feature\": \"a\", \"expiry\": \"1\"}",
+    "{\"origin\": \"https://a.a\", \"isWildcard\": \"true\", \"feature\": "
+    "\"a\", \"expiry\": 1458766277}",
+    "{\"origin\": \"https://a.a\", \"isWildcard\": 1, \"feature\": \"a\", "
+    "\"expiry\": 1458766277}",
     // Negative expiry timestamp
     "{\"origin\": \"https://a.a\", \"feature\": \"a\", \"expiry\": -1}",
     // Origin not a proper origin URL
     "{\"origin\": \"abcdef\", \"feature\": \"a\", \"expiry\": 1458766277}",
     "{\"origin\": \"data:text/plain,abcdef\", \"feature\": \"a\", \"expiry\": "
     "1458766277}",
     "{\"origin\": \"javascript:alert(1)\", \"feature\": \"a\", \"expiry\": "
-    "1458766277}"};
+    "1458766277}",
+};
 
 }  // namespace
 
 class TrialTokenTest : public testing::TestWithParam<const char*> {
  public:
   TrialTokenTest()
       : expected_origin_(GURL(kExpectedOrigin)),
+        expected_wildcard_origin_(GURL(kExpectedWildcardOrigin)),
+        expected_multiple_subdomain_origin_(
+            GURL(kExpectedMultipleSubdomainOrigin)),
         invalid_origin_(GURL(kInvalidOrigin)),
         insecure_origin_(GURL(kInsecureOrigin)),
+        incorrect_port_origin_(GURL(kIncorrectPortOrigin)),
+        incorrect_domain_origin_(GURL(kIncorrectDomainOrigin)),
         expected_expiry_(base::Time::FromDoubleT(kExpectedExpiry)),
         valid_timestamp_(base::Time::FromDoubleT(kValidTimestamp)),
         invalid_timestamp_(base::Time::FromDoubleT(kInvalidTimestamp)),
         correct_public_key_(
             base::StringPiece(reinterpret_cast<const char*>(kTestPublicKey),
                               arraysize(kTestPublicKey))),
         incorrect_public_key_(
             base::StringPiece(reinterpret_cast<const char*>(kTestPublicKey2),
                               arraysize(kTestPublicKey2))) {}
 
@@ skipping 24 matching lines @@
   }
 
   bool ValidateDate(TrialToken* token, const base::Time& now) {
     return token->ValidateDate(now);
   }
 
   base::StringPiece correct_public_key() { return correct_public_key_; }
   base::StringPiece incorrect_public_key() { return incorrect_public_key_; }
 
   const url::Origin expected_origin_;
+  const url::Origin expected_wildcard_origin_;
+  const url::Origin expected_multiple_subdomain_origin_;
   const url::Origin invalid_origin_;
   const url::Origin insecure_origin_;
+  const url::Origin incorrect_port_origin_;
+  const url::Origin incorrect_domain_origin_;
 
   const base::Time expected_expiry_;
   const base::Time valid_timestamp_;
   const base::Time invalid_timestamp_;
 
  private:
   base::StringPiece correct_public_key_;
   base::StringPiece incorrect_public_key_;
 };
 
@@ skipping 58 matching lines @@
   std::unique_ptr<TrialToken> empty_token = Parse(GetParam());
   EXPECT_FALSE(empty_token) << "Invalid trial token should not parse.";
 }
 
 INSTANTIATE_TEST_CASE_P(, TrialTokenTest, ::testing::ValuesIn(kInvalidTokens));
 
 TEST_F(TrialTokenTest, ParseValidToken) {
   std::unique_ptr<TrialToken> token = Parse(kSampleTokenJSON);
   ASSERT_TRUE(token);
   EXPECT_EQ(kExpectedFeatureName, token->feature_name());
+  EXPECT_FALSE(token->is_wildcard_origin());
   EXPECT_EQ(expected_origin_, token->origin());
   EXPECT_EQ(expected_expiry_, token->expiry_time());
 }
 
+TEST_F(TrialTokenTest, ParseValidNonWildcardToken) {
+  std::unique_ptr<TrialToken> token = Parse(kSampleNonWildcardTokenJSON);
+  ASSERT_TRUE(token);
+  EXPECT_EQ(kExpectedFeatureName, token->feature_name());
+  EXPECT_FALSE(token->is_wildcard_origin());
+  EXPECT_EQ(expected_origin_, token->origin());
+  EXPECT_EQ(expected_expiry_, token->expiry_time());
+}
+
+TEST_F(TrialTokenTest, ParseValidWildcardToken) {
+  std::unique_ptr<TrialToken> token = Parse(kSampleWildcardTokenJSON);
+  ASSERT_TRUE(token);
+  EXPECT_EQ(kExpectedFeatureName, token->feature_name());
+  EXPECT_TRUE(token->is_wildcard_origin());
+  EXPECT_EQ(kExpectedWildcardOrigin, token->origin().Serialize());
+  EXPECT_EQ(expected_wildcard_origin_, token->origin());
+  EXPECT_EQ(expected_expiry_, token->expiry_time());
+}
+
 TEST_F(TrialTokenTest, ValidateValidToken) {
   std::unique_ptr<TrialToken> token = Parse(kSampleTokenJSON);
   ASSERT_TRUE(token);
   EXPECT_TRUE(ValidateOrigin(token.get(), expected_origin_));
   EXPECT_FALSE(ValidateOrigin(token.get(), invalid_origin_));
   EXPECT_FALSE(ValidateOrigin(token.get(), insecure_origin_));
+  EXPECT_FALSE(ValidateOrigin(token.get(), incorrect_port_origin_));
+  EXPECT_FALSE(ValidateOrigin(token.get(), incorrect_domain_origin_));
   EXPECT_TRUE(ValidateFeatureName(token.get(), kExpectedFeatureName));
   EXPECT_FALSE(ValidateFeatureName(token.get(), kInvalidFeatureName));
   EXPECT_FALSE(ValidateFeatureName(
       token.get(), base::ToUpperASCII(kExpectedFeatureName).c_str()));
   EXPECT_FALSE(ValidateFeatureName(
       token.get(), base::ToLowerASCII(kExpectedFeatureName).c_str()));
   EXPECT_TRUE(ValidateDate(token.get(), valid_timestamp_));
   EXPECT_FALSE(ValidateDate(token.get(), invalid_timestamp_));
 }
 
+TEST_F(TrialTokenTest, ValidateValidWildcardToken) {
+  std::unique_ptr<TrialToken> token = Parse(kSampleWildcardTokenJSON);
+  ASSERT_TRUE(token);
+  EXPECT_TRUE(ValidateOrigin(token.get(), expected_origin_));
+  EXPECT_TRUE(ValidateOrigin(token.get(), expected_wildcard_origin_));
+  EXPECT_TRUE(ValidateOrigin(token.get(), expected_multiple_subdomain_origin_));
+  EXPECT_FALSE(ValidateOrigin(token.get(), insecure_origin_));
+  EXPECT_FALSE(ValidateOrigin(token.get(), incorrect_port_origin_));
+  EXPECT_FALSE(ValidateOrigin(token.get(), incorrect_domain_origin_));
+}
+
 TEST_F(TrialTokenTest, TokenIsValid) {
   std::unique_ptr<TrialToken> token = Parse(kSampleTokenJSON);
   ASSERT_TRUE(token);
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::Success,
             token->IsValid(expected_origin_, valid_timestamp_));
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongOrigin,
             token->IsValid(invalid_origin_, valid_timestamp_));
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongOrigin,
             token->IsValid(insecure_origin_, valid_timestamp_));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongOrigin,
+            token->IsValid(incorrect_port_origin_, valid_timestamp_));
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::Expired,
             token->IsValid(expected_origin_, invalid_timestamp_));
 }
+
+TEST_F(TrialTokenTest, WildcardTokenIsValid) {
+  std::unique_ptr<TrialToken> token = Parse(kSampleWildcardTokenJSON);
+  ASSERT_TRUE(token);
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::Success,
+            token->IsValid(expected_origin_, valid_timestamp_));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::Success,
+            token->IsValid(expected_wildcard_origin_, valid_timestamp_));
+  EXPECT_EQ(
+      blink::WebOriginTrialTokenStatus::Success,
+      token->IsValid(expected_multiple_subdomain_origin_, valid_timestamp_));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongOrigin,
+            token->IsValid(incorrect_domain_origin_, valid_timestamp_));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongOrigin,
+            token->IsValid(insecure_origin_, valid_timestamp_));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongOrigin,
+            token->IsValid(incorrect_port_origin_, valid_timestamp_));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::Expired,
+            token->IsValid(expected_origin_, invalid_timestamp_));
+}
 
 // Test overall extraction, to ensure output status matches returned token
 TEST_F(TrialTokenTest, ExtractValidToken) {
   blink::WebOriginTrialTokenStatus status;
   std::unique_ptr<TrialToken> token =
       TrialToken::From(kSampleToken, correct_public_key(), &status);
   EXPECT_TRUE(token);
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::Success, status);
 }
 
 TEST_F(TrialTokenTest, ExtractInvalidSignature) {
   blink::WebOriginTrialTokenStatus status;
   std::unique_ptr<TrialToken> token =
       TrialToken::From(kSampleToken, incorrect_public_key(), &status);
   EXPECT_FALSE(token);
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::InvalidSignature, status);
 }
 
 TEST_F(TrialTokenTest, ExtractMalformedToken) {
   blink::WebOriginTrialTokenStatus status;
   std::unique_ptr<TrialToken> token =
       TrialToken::From(kIncorrectLengthToken, correct_public_key(), &status);
   EXPECT_FALSE(token);
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::Malformed, status);
 }
 
 }  // namespace content