[webcrypto] Only allow crypto.subtle.* to be used from "secure origins".

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 42 matching lines @@
 TEST(SecurityOriginTest, ValidPortsCreateNonUniqueOrigins)
 {
     int ports[] = { 0, 80, 443, 5000, MaxAllowedPort };
 
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(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, CanAccessFeatureRequringSecureOrigin)
+{
+    struct TestCase {
+        bool accessGranted;
+        const char* url;
+    };
+
+    TestCase inputs[] = {
+        // Access is granted to webservers running on localhost.
+        { true, "http://localhost" },
+        { true, "http://localhost:100" },
+        { true, "http://127.0.0.1" },
+        { true, "http://[::1]" },
+        { true, "http://[::1]:21" },
+        { true, "http://127.0.0.1:8080" },
+        { true, "ftp://127.0.0.1" },
+        { true, "ftp://127.0.0.1:443" },
+        { true, "ws://127.0.0.1" },
+
+        // Access is granted to all secure transports.
+        { true, "https://foobar.com" },
+        { true, "wss://foobar.com" },
+
+        // Access is denied to insecure transports.
+        { false, "ftp://foobar.com" },
+        { false, "http://foobar.com" },
+        { false, "http://foobar.com:443" },
+        { false, "ws://foobar.com" },
+
+        // In practice it is not possible to initialize a SecurityOrigin with
+        // "data" protocol (it is treated as "unique").
+        { false, "data:text/html;charset=utf-8;base64,PHNjcmlwdD5hbGVydCgnaGkhJyk8L3NjcmlwdD4=" },
+        // Same thing for javascript:
+        { false, "javascript:alert('hi')" },

[abarth-chromium, 2014/06/06 20:36:34]

Please remove this case.  It's an error to construct a SecurityOrigin object
with a m_protocol of "javascript".  If you like, you can add an ASSERT to the
SecurityOrigin constructor instead.

[eroman, 2014/06/10 01:00:11]

Done.

+
+        // Access is granted to local files
+        { true, "file:///home/foobar/index.html" },
+
+        // blob: URLs must look to the inner URL's origin, and apply the same
+        // rules as above. Spot check some of them
+        { true, "blob:http://localhost:1000/578223a1-8c13-17b3-84d5-eca045ae384a" },
+        { true, "blob:https://foopy:99/578223a1-8c13-17b3-84d5-eca045ae384a" },
+        { false, "blob:http://baz:99/578223a1-8c13-17b3-84d5-eca045ae384a" },
+        { false, "blob:ftp://evil:99/578223a1-8c13-17b3-84d5-eca045ae384a" },
+
+        // filesystem: URLs work the same as blob: URLs, and look to the inner
+        // URL for security origin.
+        { true, "filesystem:http://localhost:1000/foo" },
+        { true, "filesystem:https://foopy:99/foo" },
+        { false, "filesystem:http://baz:99/foo" },
+        { false, "filesystem:ftp://evil:99/foo" },
+    };
+
+    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(inputs); ++i) {
+        SCOPED_TRACE(i);
+        RefPtr<SecurityOrigin> origin = SecurityOrigin::createFromString(inputs[i].url);
+        EXPECT_EQ(inputs[i].accessGranted, origin->canAccessFeatureRequiringSecureOrigin());
+    }
+
+    // Unique origins are not considered secure.
+    RefPtr<SecurityOrigin> uniqueOrigin = SecurityOrigin::createUnique();
+    EXPECT_FALSE(uniqueOrigin->canAccessFeatureRequiringSecureOrigin());
+}
+
 } // namespace