Ignore unknown options to subresource integrity

Source/core/frame/SubresourceIntegrityTest.cpp

 // Copyright 2014 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 "config.h"
 #include "core/frame/SubresourceIntegrity.h"
 
 #include "core/HTMLNames.h"
 #include "core/dom/Document.h"
 #include "core/fetch/Resource.h"
 #include "core/fetch/ResourcePtr.h"
 #include "core/html/HTMLScriptElement.h"
 #include "platform/Crypto.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 #include "wtf/dtoa/utils.h"
 #include "wtf/text/WTFString.h"
 #include <gtest/gtest.h>
 
 namespace blink {
 
 static const char kBasicScript[] = "alert('test');";
 static const char kSha256Integrity[] = "sha256-GAF48QOoxRvu0gZAmQivUdJPyBacqznBAXwnkfpmQX4=";
 static const char kSha256IntegrityLenientSyntax[] = "sha256-GAF48QOoxRvu0gZAmQivUdJPyBacqznBAXwnkfpmQX4=";
+static const char kSha256IntegrityWithUnknownOptions[] = "sha256-GAF48QOoxRvu0gZAmQivUdJPyBacqznBAXwnkfpmQX4=?foo=bar?baz=foz";

[Mike West, 2015/05/11 03:25:28]

Nit: Add a test for a single unknown option as well, please. :)

 static const char kSha384Integrity[] = "sha384-nep3XpvhUxpCMOVXIFPecThAqdY_uVeiD4kXSqXpx0YJUWU4fTTaFgciTuZk7fmE";
 static const char kSha512Integrity[] = "sha512-TXkJw18PqlVlEUXXjeXbGetop1TKB3wYQIp1_ihxCOFGUfG9TYOaA1MlkpTAqSV6yaevLO8Tj5pgH1JmZ--ItA==";
 static const char kSha384IntegrityLabeledAs256[] = "sha256-nep3XpvhUxpCMOVXIFPecThAqdY_uVeiD4kXSqXpx0YJUWU4fTTaFgciTuZk7fmE";
 static const char kSha256AndSha384Integrities[] = "sha256-GAF48QOoxRvu0gZAmQivUdJPyBacqznBAXwnkfpmQX4= sha384-nep3XpvhUxpCMOVXIFPecThAqdY_uVeiD4kXSqXpx0YJUWU4fTTaFgciTuZk7fmE";
 static const char kBadSha256AndGoodSha384Integrities[] = "sha256-deadbeef sha384-nep3XpvhUxpCMOVXIFPecThAqdY_uVeiD4kXSqXpx0YJUWU4fTTaFgciTuZk7fmE";
 static const char kGoodSha256AndBadSha384Integrities[] = "sha256-GAF48QOoxRvu0gZAmQivUdJPyBacqznBAXwnkfpmQX4= sha384-deadbeef";
 static const char kBadSha256AndBadSha384Integrities[] = "sha256-deadbeef sha384-deadbeef";
 static const char kUnsupportedHashFunctionIntegrity[] = "sha1-JfLW308qMPKfb4DaHpUBEESwuPc=";
 
 class SubresourceIntegrityTest : public ::testing::Test {
@@ skipping 56 matching lines @@
         Vector<UChar> characters;
         text.appendTo(characters);
         const UChar* position = characters.data();
         const UChar* end = characters.end();
         String digest;
 
         EXPECT_FALSE(SubresourceIntegrity::parseDigest(position, end, digest));
         EXPECT_TRUE(digest.isEmpty());
     }
 
-    void expectMimeType(const String& text, const char* expectedType)
+    void expectValidMimeType(const String& text)
+    {
+        EXPECT_TRUE(SubresourceIntegrity::isValidMimeTypeValue(text));
+    }
+
+    void expectInvalidMimeType(const String& text)
+    {
+        EXPECT_FALSE(SubresourceIntegrity::isValidMimeTypeValue(text));
+    }
+
+    void expectOption(const String& text, const char* expectedKey, const char* expectedValue)
     {
         Vector<UChar> characters;
         text.appendTo(characters);
         const UChar* position = characters.data();
         const UChar* end = characters.end();
-        String type;
+        String key, value;
 
-        EXPECT_TRUE(SubresourceIntegrity::parseMimeType(position, end, type));
-        EXPECT_EQ(expectedType, type);
+        EXPECT_TRUE(SubresourceIntegrity::parseOption(position, end, key, value));
+        EXPECT_EQ(expectedKey, key);
+        EXPECT_EQ(expectedValue, value);
     }
 
-    void expectMimeTypeFailure(const String& text)
+    void expectOptionFailure(const String& text)
     {
         Vector<UChar> characters;
         text.appendTo(characters);
         const UChar* position = characters.data();
         const UChar* end = characters.end();
-        String type;
+        String key, value;
 
-        EXPECT_FALSE(SubresourceIntegrity::parseMimeType(position, end, type));
-        EXPECT_TRUE(type.isEmpty());
+        EXPECT_FALSE(SubresourceIntegrity::parseOption(position, end, key, value));

[Mike West, 2015/05/11 03:25:28]

Please also EXPECT that `key` and `value` are the empty string.

     }
 
+
     void expectParse(const char* integrityAttribute, const char* expectedDigest, HashAlgorithm expectedAlgorithm, const char* expectedType)
     {
         Vector<SubresourceIntegrity::IntegrityMetadata> metadataList;
 
         EXPECT_EQ(SubresourceIntegrity::IntegrityParseValidResult, SubresourceIntegrity::parseIntegrityAttribute(integrityAttribute, metadataList, *document));
         EXPECT_EQ(1u, metadataList.size());
         if (metadataList.size() > 0) {
             EXPECT_EQ(expectedDigest, metadataList[0].digest);
             EXPECT_EQ(expectedAlgorithm, metadataList[0].algorithm);
             EXPECT_EQ(expectedType, metadataList[0].type);
         }
     }
 
-    void expectParseMultipleHashes(const char* integrityAttribute, const SubresourceIntegrity::IntegrityMetadata expectedMetadatArray[], size_t expectedMetadataArraySize)
+    void expectParseMultipleHashes(const char* integrityAttribute, const SubresourceIntegrity::IntegrityMetadata expectedMetadataArray[], size_t expectedMetadataArraySize)
     {
         Vector<SubresourceIntegrity::IntegrityMetadata> expectedMetadataList;
-        expectedMetadataList.append(expectedMetadatArray, expectedMetadataArraySize);
+        expectedMetadataList.append(expectedMetadataArray, expectedMetadataArraySize);
         Vector<SubresourceIntegrity::IntegrityMetadata> metadataList;
         EXPECT_EQ(SubresourceIntegrity::IntegrityParseValidResult, SubresourceIntegrity::parseIntegrityAttribute(integrityAttribute, metadataList, *document));
         EXPECT_EQ(expectedMetadataList.size(), metadataList.size());
         if (expectedMetadataList.size() == metadataList.size()) {
             for (size_t i = 0; i < metadataList.size(); i++) {
                 EXPECT_EQ(expectedMetadataList[i].digest, metadataList[i].digest);
                 EXPECT_EQ(expectedMetadataList[i].algorithm, metadataList[i].algorithm);
                 EXPECT_EQ(expectedMetadataList[i].type, metadataList[i].type);
             }
         }
@@ skipping 78 matching lines @@
     expectDigest("abcdefg", "abcdefg");
     expectDigest("abcdefg?", "abcdefg");
     expectDigest("ab+de/g", "ab+de/g");
     expectDigest("ab-de_g", "ab+de/g");
 
     expectDigestFailure("?");
     expectDigestFailure("&&&foobar&&&");
     expectDigestFailure("\x01\x02\x03\x04");
 }
 
-TEST_F(SubresourceIntegrityTest, ParseMimeType)
+TEST_F(SubresourceIntegrityTest, ValidMimeType)
 {
-    expectMimeType("?ct=application/javascript", "application/javascript");
-    expectMimeType("?ct=application/xhtml+xml", "application/xhtml+xml");
-    expectMimeType("?ct=text/vnd.abc", "text/vnd.abc");
-    expectMimeType("?ct=video/x-ms-wmv", "video/x-ms-wmv");
+    expectValidMimeType("application/javascript");
+    expectValidMimeType("application/xhtml+xml");
+    expectValidMimeType("text/vnd.abc");
+    expectValidMimeType("video/x-ms-wmv");
 
-    expectMimeTypeFailure("application/javascript");
-    expectMimeTypeFailure("?application/javascript");
-    expectMimeTypeFailure("?not-ct=application/javascript");
-    expectMimeTypeFailure("?ct==application/javascript");
-    expectMimeTypeFailure("?yay=boo&ct=application/javascript");
-    expectMimeTypeFailure("?ct=application/javascript&yay=boo");
-    expectMimeTypeFailure("?ct=video%2Fx-ms-wmv");
+    expectInvalidMimeType("1application/javascript");
+    expectInvalidMimeType("app-lication/javascript");
+    expectInvalidMimeType("video%2Fx-ms-wmv");
+}
+
+TEST_F(SubresourceIntegrityTest, ParseOption)
+{
+    expectOption("?ct=application/javascript", "ct", "application/javascript");
+    expectOption("?ct=application/xhtml+xml", "ct", "application/xhtml+xml");
+    expectOption("?ct=text/vnd.abc", "ct", "text/vnd.abc");
+    expectOption("?ct=video/x-ms-wmv", "ct", "video/x-ms-wmv");
+    expectOption("?foo=bar", "foo", "bar");
+    expectOption("?foo=bar?baz", "foo", "bar");
+    expectOption("?foo=bar?baz=boo", "foo", "bar");
+
+    expectOptionFailure("application/javascript");
+    expectOptionFailure("?application/javascript");
+    expectOptionFailure("?ct==application/javascript");
+    expectOptionFailure("?yay=boo&ct=application/javascript");
+    expectOptionFailure("?ct=application/javascript&yay=boo");
+    expectOptionFailure("?foo=baz bar");
 }
 
 //
 // End-to-end parsing tests.
 //
 
 TEST_F(SubresourceIntegrityTest, Parsing)
 {
     expectParseFailure("not_really_a_valid_anything");
     expectParseFailure("sha256-&&&foobar&&&");
     expectParseFailure("sha256-\x01\x02\x03\x04");
     expectParseFailure("sha256-!!! sha256-!!!");
 
     expectEmptyParseResult("foobar:///sha256-abcdefg");
     expectEmptyParseResult("ni://sha256-abcdefg");
     expectEmptyParseResult("ni:///sha256-abcdefg");
     expectEmptyParseResult("notsha256atall-abcdefg");
 
     expectParse(
         "sha256-BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=",
         "BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=",
         HashAlgorithmSha256,
-        "");
+        0);
 
     expectParse(
         "sha-256-BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=",
         "BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=",
         HashAlgorithmSha256,
-        "");
+        0);
 
     expectParse(
         "     sha256-BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=     ",
         "BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=",
         HashAlgorithmSha256,
-        "");
+        0);
 
     expectParse(
         "sha384-XVVXBGoYw6AJOh9J-Z8pBDMVVPfkBpngexkA7JqZu8d5GENND6TEIup_tA1v5GPr",
         "XVVXBGoYw6AJOh9J+Z8pBDMVVPfkBpngexkA7JqZu8d5GENND6TEIup/tA1v5GPr",
         HashAlgorithmSha384,
-        "");
+        0);
 
     expectParse(
         "sha-384-XVVXBGoYw6AJOh9J_Z8pBDMVVPfkBpngexkA7JqZu8d5GENND6TEIup_tA1v5GPr",
         "XVVXBGoYw6AJOh9J/Z8pBDMVVPfkBpngexkA7JqZu8d5GENND6TEIup/tA1v5GPr",
         HashAlgorithmSha384,
-        "");
+        0);
 
     expectParse(
         "sha512-tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ-07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==",
         "tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ+07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==",
         HashAlgorithmSha512,
-        "");
+        0);
 
     expectParse(
         "sha-512-tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ-07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==",
         "tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ+07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==",
         HashAlgorithmSha512,
-        "");
+        0);
 
     expectParse(
         "sha-512-tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ-07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==?ct=application/javascript",
         "tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ+07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==",
         HashAlgorithmSha512,
         "application/javascript");
 
+    expectParse(
+        "sha-512-tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ-07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==?ct=application/xhtml+xml",
+        "tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ+07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==",
+        HashAlgorithmSha512,
+        "application/xhtml+xml");
+
+    expectParse(
+        "sha-512-tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ-07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==?foo=bar?ct=application/xhtml+xml",
+        "tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ+07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==",
+        HashAlgorithmSha512,
+        "application/xhtml+xml");
+
+    expectParse(
+        "sha-512-tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ-07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==?ct=application/xhtml+xml?foo=bar",
+        "tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ+07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==",
+        HashAlgorithmSha512,
+        "application/xhtml+xml");
+
+    expectParse(
+        "sha-512-tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ-07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==?baz=foz?ct=application/xhtml+xml?foo=bar",
+        "tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ+07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==",
+        HashAlgorithmSha512,
+        "application/xhtml+xml");
+
     expectParseMultipleHashes("", 0, 0);
     expectParseMultipleHashes("    ", 0, 0);
 
     const SubresourceIntegrity::IntegrityMetadata kValidSha384AndSha512[] = {
-        {"XVVXBGoYw6AJOh9J+Z8pBDMVVPfkBpngexkA7JqZu8d5GENND6TEIup/tA1v5GPr", HashAlgorithmSha384, ""},
-        {"tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ+07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==", HashAlgorithmSha512, ""}
+        {"XVVXBGoYw6AJOh9J+Z8pBDMVVPfkBpngexkA7JqZu8d5GENND6TEIup/tA1v5GPr", HashAlgorithmSha384, WTF::String()},
+        {"tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ+07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==", HashAlgorithmSha512, WTF::String()}
     };
     expectParseMultipleHashes(
         "sha384-XVVXBGoYw6AJOh9J+Z8pBDMVVPfkBpngexkA7JqZu8d5GENND6TEIup/tA1v5GPr sha512-tbUPioKbVBplr0b1ucnWB57SJWt4x9dOE0Vy2mzCXvH3FepqDZ+07yMK81ytlg0MPaIrPAjcHqba5csorDWtKg==",
         kValidSha384AndSha512,
         ARRAY_SIZE(kValidSha384AndSha512));
 
     const SubresourceIntegrity::IntegrityMetadata kValidSha256AndSha256[] = {
-        {"BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=", HashAlgorithmSha256, ""},
-        {"deadbeef", HashAlgorithmSha256, ""}
+        {"BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=", HashAlgorithmSha256, WTF::String()},
+        {"deadbeef", HashAlgorithmSha256, WTF::String()}
     };
     expectParseMultipleHashes(
         "sha256-BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE= sha256-deadbeef",
         kValidSha256AndSha256,
         ARRAY_SIZE(kValidSha256AndSha256));
 
     const SubresourceIntegrity::IntegrityMetadata kValidSha256AndInvalidSha256[] = {
-        {"BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=", HashAlgorithmSha256, ""}
+        {"BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=", HashAlgorithmSha256, WTF::String()}
     };
     expectParseMultipleHashes(
         "sha256-BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE= sha256-!!!!",
         kValidSha256AndInvalidSha256,
         ARRAY_SIZE(kValidSha256AndInvalidSha256));
 
     const SubresourceIntegrity::IntegrityMetadata kInvalidSha256AndValidSha256[] = {
-        {"BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=", HashAlgorithmSha256, ""}
+        {"BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=", HashAlgorithmSha256, WTF::String()}
     };
     expectParseMultipleHashes(
         "sha256-!!! sha256-BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=",
         kInvalidSha256AndValidSha256,
         ARRAY_SIZE(kInvalidSha256AndValidSha256));
+
+    expectParse(
+        "sha256-BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=?foo=bar",
+        "BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=",
+        HashAlgorithmSha256,
+        0);
+
+    expectParse(
+        "sha256-BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=?foo=bar?baz=foz",
+        "BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=",
+        HashAlgorithmSha256,
+        0);
+
+    expectParseFailure("sha256-BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=?foo=bar?");
+    expectParseFailure("sha256-BpfBw7ivV8q2jLiT13fxDYAe2tJllusRSZ273h2nFSE=?foo:bar");
 }
 
 TEST_F(SubresourceIntegrityTest, ParsingBase64)
 {
     expectParse(
         "sha384-XVVXBGoYw6AJOh9J+Z8pBDMVVPfkBpngexkA7JqZu8d5GENND6TEIup/tA1v5GPr",
         "XVVXBGoYw6AJOh9J+Z8pBDMVVPfkBpngexkA7JqZu8d5GENND6TEIup/tA1v5GPr",
         HashAlgorithmSha384,
-        "");
+        0);
 }
 
 //
 // End-to-end tests of ::CheckSubresourceIntegrity.
 //
 
 TEST_F(SubresourceIntegrityTest, CheckSubresourceIntegrityInSecureOrigin)
 {
     document->updateSecurityOrigin(secureOrigin->isolatedCopy());
 
@@ skipping 13 matching lines @@
 
     // With multiple values, at least one must match.
     expectIntegrityFailure(kBadSha256AndBadSha384Integrities, kBasicScript, secureURL, secureURL);
 
     // Unsupported hash functions should succeed.
     expectIntegrity(kUnsupportedHashFunctionIntegrity, kBasicScript, secureURL, secureURL);
 
     // All parameters are fine, and because this is not cross origin, CORS is
     // not needed.
     expectIntegrity(kSha256Integrity, kBasicScript, secureURL, secureURL, String(), NoCors);
+
+    // Unknown options should be ignored
+    expectIntegrity(kSha256IntegrityWithUnknownOptions, kBasicScript, secureURL, secureURL, String(), NoCors);
 }
 
 TEST_F(SubresourceIntegrityTest, CheckSubresourceIntegrityInInsecureOrigin)
 {
     // The same checks as CheckSubresourceIntegrityInSecureOrigin should pass
     // here, with the expection of the NoCors check at the end.
     document->updateSecurityOrigin(insecureOrigin->isolatedCopy());
 
     expectIntegrity(kSha256Integrity, kBasicScript, secureURL, insecureURL);
     expectIntegrity(kSha256IntegrityLenientSyntax, kBasicScript, secureURL, insecureURL);
     expectIntegrity(kSha384Integrity, kBasicScript, secureURL, insecureURL);
     expectIntegrity(kSha512Integrity, kBasicScript, secureURL, insecureURL);
     expectIntegrityFailure(kSha384IntegrityLabeledAs256, kBasicScript, secureURL, insecureURL);
     expectIntegrity(kUnsupportedHashFunctionIntegrity, kBasicScript, secureURL, insecureURL);
 
     expectIntegrity(kSha256AndSha384Integrities, kBasicScript, secureURL, insecureURL);
     expectIntegrity(kBadSha256AndGoodSha384Integrities, kBasicScript, secureURL, insecureURL);
     expectIntegrity(kGoodSha256AndBadSha384Integrities, kBasicScript, secureURL, insecureURL);
 
     // This check should fail because, unlike in the
     // CheckSubresourceIntegrityInSecureOrigin case, this is cross origin
     // (secure origin requesting a resource on an insecure origin)
     expectIntegrityFailure(kSha256Integrity, kBasicScript, secureURL, insecureURL, String(), NoCors);
 }
 
 } // namespace blink