Basic experimental suborigin CSP directive and SecurityOrigin mods

Source/platform/weborigin/SecurityOriginTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 13 matching lines @@
  * 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 "config.h"
 #include "platform/weborigin/SecurityOrigin.h"
 
+#include "platform/RuntimeEnabledFeatures.h"
 #include "platform/weborigin/KURL.h"
+#include "wtf/text/StringBuilder.h"
+#include "wtf/text/WTFString.h"
 #include <gtest/gtest.h>
 
 using blink::SecurityOrigin;
 
-namespace {
+namespace blink {
 
 const int MaxAllowedPort = 65535;
 
-TEST(SecurityOriginTest, InvalidPortsCreateUniqueOrigins)
+class SecurityOriginTest : public ::testing::Test { };
+
+TEST_F(SecurityOriginTest, InvalidPortsCreateUniqueOrigins)
 {
     int ports[] = { -100, -1, MaxAllowedPort + 1, 1000000 };
 
     for (size_t i = 0; i < arraysize(ports); ++i) {
         RefPtr<SecurityOrigin> origin = SecurityOrigin::create("http", "example.com", ports[i]);
         EXPECT_TRUE(origin->isUnique()) << "Port " << ports[i] << " should have generated a unique origin.";
     }
 }
 
-TEST(SecurityOriginTest, ValidPortsCreateNonUniqueOrigins)
+TEST_F(SecurityOriginTest, ValidPortsCreateNonUniqueOrigins)
 {
     int ports[] = { 0, 80, 443, 5000, MaxAllowedPort };
 
     for (size_t i = 0; i < arraysize(ports); ++i) {
         RefPtr<SecurityOrigin> origin = SecurityOrigin::create("http", "example.com", ports[i]);
         EXPECT_FALSE(origin->isUnique()) << "Port " << ports[i] << " should not have generated a unique origin.";
     }
 }
 
-TEST(SecurityOriginTest, IsPotentiallyTrustworthy)
+TEST_F(SecurityOriginTest, IsPotentiallyTrustworthy)
 {
     struct TestCase {
         bool accessGranted;
         const char* url;
     };
 
     TestCase inputs[] = {
         // Access is granted to webservers running on localhost.
         { true, "http://localhost" },
         { true, "http://LOCALHOST" },
@@ skipping 58 matching lines @@
         EXPECT_EQ(inputs[i].accessGranted, errorMessage.isEmpty());
     }
 
     // Unique origins are not considered secure.
     RefPtr<SecurityOrigin> uniqueOrigin = SecurityOrigin::createUnique();
     String errorMessage;
     EXPECT_FALSE(uniqueOrigin->isPotentiallyTrustworthy(errorMessage));
     EXPECT_EQ("Only secure origins are allowed (see: https://goo.gl/Y0ZkNV).", errorMessage);
 }
 
-TEST(SecurityOriginTest, IsSecure)
+TEST_F(SecurityOriginTest, IsSecure)
 {
     struct TestCase {
         bool isSecure;
         const char* url;
     } inputs[] = {
         { false, "blob:ftp://evil:99/578223a1-8c13-17b3-84d5-eca045ae384a" },
         { false, "blob:http://example.com/578223a1-8c13-17b3-84d5-eca045ae384a" },
         { false, "file:///etc/passwd" },
         { false, "ftp://example.com/" },
         { false, "http://example.com/" },
         { false, "ws://example.com/" },
         { true, "blob:https://example.com/578223a1-8c13-17b3-84d5-eca045ae384a" },
         { true, "https://example.com/" },
         { true, "wss://example.com/" },
 
         { true, "about:blank" },
         { false, "" },
         { false, "\0" },
     };
 
     for (auto test : inputs)
         EXPECT_EQ(test.isSecure, SecurityOrigin::isSecure(blink::KURL(blink::ParsedURLString, test.url))) << "URL: '" << test.url << "'";
 
     EXPECT_FALSE(SecurityOrigin::isSecure(blink::KURL()));
 }
 
+TEST_F(SecurityOriginTest, Suborigins)
+{
+    blink::RuntimeEnabledFeatures::setSuboriginsEnabled(true);
+
+    RefPtr<SecurityOrigin> origin = SecurityOrigin::createFromString("https://test.com");
+    EXPECT_FALSE(origin->hasSuborigin());
+    origin->addSuborigin("foobar");
+    EXPECT_TRUE(origin->hasSuborigin());
+    EXPECT_EQ("foobar", origin->suboriginName());
+
+    origin = SecurityOrigin::createFromString("https://foobar_test.com");
+    EXPECT_EQ("https", origin->protocol());
+    EXPECT_EQ("test.com", origin->host());
+    EXPECT_EQ("foobar", origin->suboriginName());
+
+    origin = SecurityOrigin::createFromString("https://foobar_test.com");
+    EXPECT_TRUE(origin->hasSuborigin());
+    EXPECT_EQ("foobar", origin->suboriginName());
+
+    origin = SecurityOrigin::createFromString("https://foobar+test.com");
+    EXPECT_FALSE(origin->hasSuborigin());
+
+    origin = SecurityOrigin::createFromString("https://_test.com");
+    EXPECT_FALSE(origin->hasSuborigin());
+
+    origin = adoptRef<SecurityOrigin>(new SecurityOrigin);
+    EXPECT_FALSE(origin->hasSuborigin());
+
+    origin = SecurityOrigin::createFromString("https://foobar_test.com");
+    EXPECT_DEATH(origin->addSuborigin("shouldhitassert"), "");
+}
+
+TEST_F(SecurityOriginTest, SuboriginsParsing)
+{
+    blink::RuntimeEnabledFeatures::setSuboriginsEnabled(true);
+    String host, realHost, suborigin;
+    host = "test.com";
+    EXPECT_FALSE(SecurityOrigin::deserializeSuboriginAndHost(host, suborigin, realHost));
+
+    host = "foobar_test.com";
+    EXPECT_TRUE(SecurityOrigin::deserializeSuboriginAndHost(host, suborigin, realHost));
+    EXPECT_EQ("test.com", realHost);
+    EXPECT_EQ("foobar", suborigin);
+
+    RefPtr<SecurityOrigin> origin;
+    StringBuilder builder;
+
+    origin = SecurityOrigin::createFromString("https://foobar_test.com");
+    origin->buildRawString(builder);
+    EXPECT_EQ("https://foobar_test.com", builder.toString());
+
+    builder.clear();
+    origin = SecurityOrigin::createFromString("https://test.com");
+    origin->addSuborigin("foobar");
+    origin->buildRawString(builder);
+    EXPECT_EQ("https://foobar_test.com", builder.toString());
+}
+
 } // namespace