Implement hash function prioritization for SRI.

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"
@@ skipping 168 matching lines @@
 
     KURL secureURL;
     KURL insecureURL;
     RefPtr<SecurityOrigin> secureOrigin;
     RefPtr<SecurityOrigin> insecureOrigin;
 
     RefPtrWillBePersistent<Document> document;
     RefPtrWillBePersistent<HTMLScriptElement> scriptElement;
 };
 
+TEST_F(SubresourceIntegrityTest, Prioritization)
+{
+    EXPECT_EQ(HashAlgorithmSha256, SubresourceIntegrity::getPrioritizedHashFunction(HashAlgorithmSha256, HashAlgorithmSha256));
+    EXPECT_EQ(HashAlgorithmSha384, SubresourceIntegrity::getPrioritizedHashFunction(HashAlgorithmSha384, HashAlgorithmSha384));
+    EXPECT_EQ(HashAlgorithmSha512, SubresourceIntegrity::getPrioritizedHashFunction(HashAlgorithmSha512, HashAlgorithmSha512));
+
+    EXPECT_EQ(HashAlgorithmSha384, SubresourceIntegrity::getPrioritizedHashFunction(HashAlgorithmSha384, HashAlgorithmSha256));
+    EXPECT_EQ(HashAlgorithmSha512, SubresourceIntegrity::getPrioritizedHashFunction(HashAlgorithmSha512, HashAlgorithmSha256));
+    EXPECT_EQ(HashAlgorithmSha512, SubresourceIntegrity::getPrioritizedHashFunction(HashAlgorithmSha512, HashAlgorithmSha384));
+
+    EXPECT_EQ(HashAlgorithmSha384, SubresourceIntegrity::getPrioritizedHashFunction(HashAlgorithmSha256, HashAlgorithmSha384));
+    EXPECT_EQ(HashAlgorithmSha512, SubresourceIntegrity::getPrioritizedHashFunction(HashAlgorithmSha256, HashAlgorithmSha512));
+    EXPECT_EQ(HashAlgorithmSha512, SubresourceIntegrity::getPrioritizedHashFunction(HashAlgorithmSha384, HashAlgorithmSha512));
+}
+
 TEST_F(SubresourceIntegrityTest, ParseAlgorithm)
 {
     expectAlgorithm("sha256-", HashAlgorithmSha256);
     expectAlgorithm("sha384-", HashAlgorithmSha384);
     expectAlgorithm("sha512-", HashAlgorithmSha512);
     expectAlgorithm("sha-256-", HashAlgorithmSha256);
     expectAlgorithm("sha-384-", HashAlgorithmSha384);
     expectAlgorithm("sha-512-", HashAlgorithmSha512);
 
     expectAlgorithmFailure("sha1-", SubresourceIntegrity::AlgorithmUnknown);
@@ skipping 166 matching lines @@
     expectParse(
         "sha384-XVVXBGoYw6AJOh9J+Z8pBDMVVPfkBpngexkA7JqZu8d5GENND6TEIup/tA1v5GPr",
         "XVVXBGoYw6AJOh9J+Z8pBDMVVPfkBpngexkA7JqZu8d5GENND6TEIup/tA1v5GPr",
         HashAlgorithmSha384);
 }
 
 //
 // End-to-end tests of ::CheckSubresourceIntegrity.
 //
 
-TEST_F(SubresourceIntegrityTest, DISABLED_CheckSubresourceIntegrityInSecureOrigin)
+TEST_F(SubresourceIntegrityTest, CheckSubresourceIntegrityInSecureOrigin)
 {
     document->updateSecurityOrigin(secureOrigin->isolatedCopy());
 
     // Verify basic sha256, sha384, and sha512 integrity checks.
     expectIntegrity(kSha256Integrity, kBasicScript, secureURL, secureURL);
     expectIntegrity(kSha256IntegrityLenientSyntax, kBasicScript, secureURL, secureURL);
     expectIntegrity(kSha384Integrity, kBasicScript, secureURL, secureURL);
     expectIntegrity(kSha512Integrity, kBasicScript, secureURL, secureURL);
 
     // Verify multiple hashes in an attribute.
     expectIntegrity(kSha256AndSha384Integrities, kBasicScript, secureURL, secureURL);
     expectIntegrity(kBadSha256AndGoodSha384Integrities, kBasicScript, secureURL, secureURL);
-    expectIntegrity(kGoodSha256AndBadSha384Integrities, kBasicScript, secureURL, secureURL);
 
     // The hash label must match the hash value.
     expectIntegrityFailure(kSha384IntegrityLabeledAs256, kBasicScript, secureURL, secureURL);
 
-    // With multiple values, at least one must match.
+    // With multiple values, at least one must match, and it must be the
+    // strongest hash algorithm.
+    expectIntegrityFailure(kGoodSha256AndBadSha384Integrities, kBasicScript, secureURL, secureURL);
     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, NoCors);
 
     // Options should be ignored
     expectIntegrity(kSha256IntegrityWithEmptyOption, kBasicScript, secureURL, secureURL, NoCors);
     expectIntegrity(kSha256IntegrityWithOption, kBasicScript, secureURL, secureURL, NoCors);
     expectIntegrity(kSha256IntegrityWithOptions, kBasicScript, secureURL, secureURL, NoCors);
     expectIntegrity(kSha256IntegrityWithMimeOption, kBasicScript, secureURL, secureURL, NoCors);
 }
 
-TEST_F(SubresourceIntegrityTest, DISABLED_CheckSubresourceIntegrityInInsecureOrigin)
+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);
+
+    expectIntegrityFailure(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, NoCors);
 }
 
 } // namespace blink