Fix HMAC JWK import length handling

lib/src/testing/regression/issue_302_hmac_jwk_length.dart

@@ -0,0 +1,65 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import 'package:webcrypto/webcrypto.dart';
+import '../utils/utils.dart';
+
+void main() => tests().runTests();
+
+List<({String name, Future<void> Function() test})> tests() {
+  final tests = <({String name, Future<void> Function() test})>[];
+  void test(String name, Future<void> Function() fn) =>
+      tests.add((name: name, test: fn));
+
+  test('Hmac: importJsonWebKey honors length', () async {
+    final keyData = [0xff, 0xe0];
+    final jwk = {'kty': 'oct', 'alg': 'HS256', 'k': '_-A'};
+
+    final rawKey = await HmacSecretKey.importRawKey(
+      keyData,
+      Hash.sha256,
+      length: 9,
+    );
+    final jwkKey = await HmacSecretKey.importJsonWebKey(
+      jwk,
+      Hash.sha256,
+      length: 9,
+    );
+
+    check(
+      equalBytes(await rawKey.exportRawKey(), await jwkKey.exportRawKey()),
+      'JWK import should zero unused bits the same way as raw import',
+    );
+
+    final data = [1, 2, 3, 4];
+    check(
+      equalBytes(await rawKey.signBytes(data), await jwkKey.signBytes(data)),
+      'JWK import should use the requested HMAC key length for signing',
+    );
+  });
+
+  test('Hmac: importJsonWebKey validates length', () async {
+    final jwk = {'kty': 'oct', 'alg': 'HS256', 'k': '_-A'};
+
+    bool threw = false;
+    try {
+      await HmacSecretKey.importJsonWebKey(jwk, Hash.sha256, length: 7);
+    } on ArgumentError {
+      threw = true;
+    }
+    check(threw, 'Should throw ArgumentError for invalid HMAC key length');
+  });
+
+  return tests;
+}

lib/src/testing/testing.dart

@@ -30,6 +30,7 @@ import 'webcrypto/rsassapkcs1v15.dart' as rsassapkcs1v15;
 // Other test files, that don't use TestRunner
 import 'webcrypto/random.dart' as random;
 import 'webcrypto/digest.dart' as digest;
+import 'regression/issue_302_hmac_jwk_length.dart' as issue_302_hmac_jwk_length;
 import 'regression/issue_60_trailing_bytes.dart' as issue_60_trailing_bytes;
 
 /// Test runners from all test files except `digest.dart` and
@@ -59,6 +60,7 @@ void runAllTests(
     for (final r in _testRunners) ...r.tests(),
     ...random.tests(),
     ...digest.tests(),
+    ...issue_302_hmac_jwk_length.tests(),
     ...issue_60_trailing_bytes.tests(),
   ];
 

lib/src/webcrypto/webcrypto.hmac.dart

@@ -53,6 +53,30 @@ final class HmacSecretKey {
 
   HmacSecretKey._(this._impl); // keep the constructor private.
 
+  static void _checkLength(int length, int keyDataLength) {
+    if (length > keyDataLength * 8) {
+      throw ArgumentError.value(
+        length,
+        'length',
+        'must be less than number of bits in keyData',
+      );
+    }
+    if (length <= (keyDataLength - 1) * 8) {
+      throw ArgumentError.value(
+        length,
+        'length',
+        'must be greater than number of bits in keyData - 8, you can attain '
+            'the same effect by removing bytes from keyData',
+      );
+    }
+  }
+
+  static List<int> _decodeBase64UrlNoPadding(String unpadded) {
+    final end = unpadded.length;
+    final pad = (4 - end % 4) % 4;
+    return base64Url.decode(unpadded.padRight(end + pad, '='));
+  }
+
   /// Import [HmacSecretKey] from raw [keyData].
   ///
   /// Creates an [HmacSecretKey] using [keyData] as secret key, and running
@@ -82,20 +106,8 @@ final class HmacSecretKey {
   }) async {
     // These limitations are given in Web Cryptography Spec:
     // https://www.w3.org/TR/WebCryptoAPI/#hmac-operations
-    if (length != null && length > keyData.length * 8) {
-      throw ArgumentError.value(
-        length,
-        'length',
-        'must be less than number of bits in keyData',
-      );
-    }
-    if (length != null && length <= (keyData.length - 1) * 8) {
-      throw ArgumentError.value(
-        length,
-        'length',
-        'must be greater than number of bits in keyData - 8, you can attain '
-            'the same effect by removing bytes from keyData',
-      );
+    if (length != null) {
+      _checkLength(length, keyData.length);
     }
 
     final impl = await webCryptImpl.hmacSecretKey.importRawKey(
@@ -162,26 +174,19 @@ final class HmacSecretKey {
     Hash hash, {
     int? length,
   }) async {
-    /*
-    TODO: Validate these in the native implememtation
     // These limitations are given in Web Cryptography Spec:
     // https://www.w3.org/TR/WebCryptoAPI/#hmac-operations
-    if (length != null && length > keyData.length * 8) {
-      throw ArgumentError.value(
-          length, 'length', 'must be less than number of bits in keyData');
-    }
-    if (length != null && length <= (keyData.length - 1) * 8) {
-      throw ArgumentError.value(
+    if (length != null && jwk['k'] is String) {
+      _checkLength(
         length,
-        'length',
-        'must be greater than number of bits in keyData - 8, you can attain '
-            'the same effect by removing bytes from keyData',
+        _decodeBase64UrlNoPadding(jwk['k'] as String).length,
       );
-    }*/
+    }
 
     final impl = await webCryptImpl.hmacSecretKey.importJsonWebKey(
       jwk,
       hash._impl,
+      length: length,
     );
 
     return HmacSecretKey._(impl);