8 ay önce · 6d68d6ddb2
--- a/Tests/LibWeb/Text/expected/subtle-crypto-hkdf-salt-empty-or-none.txt
+++ b/Tests/LibWeb/Text/expected/subtle-crypto-hkdf-salt-empty-or-none.txt
@@ -0,0 +1,2 @@
 
				+136,95,192,41,179,34,75,137,110,9,224,187,229,235,52,126,197,158,104,39,200,232,87,179,148,245,79,244,155,136,168,246,83,68,116,156,52,46,53,108,71,252
			
 
				+Absent salt rejected! TypeError: Not an object of type BufferSource
			
--- a/Tests/LibWeb/Text/input/subtle-crypto-hkdf-salt-empty-or-none.html
+++ b/Tests/LibWeb/Text/input/subtle-crypto-hkdf-salt-empty-or-none.html
@@ -0,0 +1,38 @@
 
				+<!DOCTYPE html>
			
 
				+<script src="include.js"></script>
			
 
				+<script>
			
 
				+    asyncTest(async done => {
			
 
				+        var subtle = self.crypto.subtle;
			
 
				+        var key = await subtle.importKey("raw", new Uint8Array([]), { name: "HKDF" }, false, [
			
 
				+            "deriveKey",
			
 
				+            "deriveBits",
			
 
				+        ]);
			
 
				+        // Test the subtle difference between an empty salt (0 bytes) and an absent salt (which defaults to hashLen many bytes, each of value 0).
			
 
				+        // Inspired by https://datatracker.ietf.org/doc/html/rfc5869/#appendix-A.6 and A.7
			
 
				+        var algorithmEmptySalt = {
			
 
				+            name: "HKDF",
			
 
				+            salt: new Uint8Array([]),
			
 
				+            info: new Uint8Array([]),
			
 
				+            hash: "SHA-1",
			
 
				+        };
			
 
				+        var bitsEmptySalt = await subtle.deriveBits(algorithmEmptySalt, key, 42 * 8);
			
 
				+        console.log(new Uint8Array(bitsEmptySalt));
			
 
				+        println(new Uint8Array(bitsEmptySalt));
			
 
				+        var algorithmAbsentSalt = {
			
 
				+            name: "HKDF",
			
 
				+            salt: null,
			
 
				+            info: new Uint8Array([]),
			
 
				+            hash: "SHA-1",
			
 
				+        };
			
 
				+        subtle.deriveBits(algorithmAbsentSalt, key, 42 * 8).then(
			
 
				+            async bitsAbsentSalt => {
			
 
				+                println(new Uint8Array(bitsAbsentSalt));
			
 
				+                done();
			
 
				+            },
			
 
				+            async err => {
			
 
				+                println("Absent salt rejected! " + err);
			
 
				+                done();
			
 
				+            }
			
 
				+        );
			
 
				+    });
			
 
				+</script>
			
--- a/Userland/Libraries/LibWeb/Crypto/CryptoAlgorithms.cpp
+++ b/Userland/Libraries/LibWeb/Crypto/CryptoAlgorithms.cpp
@@ -1467,7 +1467,10 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> HKDF::derive_bits(Algorit
 
				     //    * the contents of the salt member of normalizedAlgorithm as salt,
			
 
				     //    * the contents of the info member of normalizedAlgorithm as info,
			
 
				     //    * length divided by 8 as the value of L,
			
 
				-    // FIXME: salt null versus salt empty?!
			
 
				+    // Note: Although HKDF technically supports absent salt (treating it as hashLen many NUL bytes),
			
 
				+    // all major browsers instead raise a TypeError, for example:
			
 
				+    //     "Failed to execute 'deriveBits' on 'SubtleCrypto': HkdfParams: salt: Not a BufferSource"
			
 
				+    // Because we are forced by neither peer pressure nor the spec, we don't support it either.
			
 
				     auto const& hash_algorithm = TRY(normalized_algorithm.hash.visit(
			
 
				         [](String const& name) -> JS::ThrowCompletionOr<String> { return name; },
			
 
				         [&](JS::Handle<JS::Object> const& obj) -> JS::ThrowCompletionOr<String> {