fix(hash): fix base64 digest and hash salt (#13977)

intellild · web-flow · commit fa01589641d2 · 2026-05-11T14:13:57.000+08:00
* base64 encoding with base64 crate

Use the base64 crate for standard and URL-safe base64 encoding instead of custom implementations. This improves maintainability and reduces potential bugs in the encoding logic.

* fix(hash): fix hash salt not working

* test(hash): add base64 hash tests

* fix: use base64-simd for hash digests

* test(hash): move hash tests to integration target
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/rspack_hash/Cargo.toml b/crates/rspack_hash/Cargo.toml
@@ -7,6 +7,7 @@ repository        = "https://github.com/web-infra-dev/rspack"
 version.workspace = true
 
 [dependencies]
+base64-simd      = { workspace = true }
 md4              = { workspace = true }
 rspack_cacheable = { workspace = true }
 sha2             = { workspace = true }
diff --git a/crates/rspack_hash/src/lib.rs b/crates/rspack_hash/src/lib.rs
@@ -3,6 +3,7 @@ use std::{
   hash::{Hash, Hasher},
 };
 
+use base64_simd::{STANDARD, URL_SAFE_NO_PAD};
 use md4::Digest;
 use rspack_cacheable::{cacheable, with::AsPreset};
 use smol_str::SmolStr;
@@ -103,8 +104,8 @@ impl RspackHash {
 
   pub fn with_salt(function: &HashFunction, salt: &HashSalt) -> Self {
     let mut this = Self::new(function);
-    if !matches!(salt, HashSalt::None) {
-      salt.hash(&mut this);
+    if let HashSalt::Salt(salt) = salt {
+      this.write(salt.as_bytes());
     }
     this
   }
@@ -201,8 +202,8 @@ impl RspackHashDigest {
         let s = hex(inner, &mut buf);
         s.into()
       }
-      HashDigest::Base64 => encode_base_n(inner, BASE64_CHARSET).into(),
-      HashDigest::Base64Url => encode_base_n(inner, BASE64URL_CHARSET).into(),
+      HashDigest::Base64 => STANDARD.encode_to_string(inner).into(),
+      HashDigest::Base64Url => URL_SAFE_NO_PAD.encode_to_string(inner).into(),
       HashDigest::Base62 => encode_base_n(inner, BASE62_CHARSET).into(),
       HashDigest::Base58 => encode_base_n(inner, BASE58_CHARSET).into(),
       HashDigest::Base52 => encode_base_n(inner, BASE52_CHARSET).into(),
@@ -267,9 +268,6 @@ const BASE49_CHARSET: &[u8] = b"abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXY
 const BASE52_CHARSET: &[u8] = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 const BASE58_CHARSET: &[u8] = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 const BASE62_CHARSET: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-const BASE64_CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-const BASE64URL_CHARSET: &[u8] =
-  b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 
 /// Encodes raw hash bytes into a base-N string using the given charset.
 /// Matches webpack's `encode` in `hash-digest.js`: interprets the buffer as a
diff --git a/crates/rspack_hash/tests/hash.rs b/crates/rspack_hash/tests/hash.rs
@@ -0,0 +1,40 @@
+use std::hash::Hasher;
+
+use rspack_hash::{HashDigest, HashFunction, HashSalt, RspackHash, RspackHashDigest};
+
+#[test]
+fn encodes_base64_with_standard_padding() {
+  let digest = RspackHashDigest::new(b"\xfb\xef\xff", &HashDigest::Base64);
+
+  assert_eq!(digest.encoded(), "++//");
+
+  let digest = RspackHashDigest::new(b"hello", &HashDigest::Base64);
+
+  assert_eq!(digest.encoded(), "aGVsbG8=");
+}
+
+#[test]
+fn encodes_base64url_without_padding() {
+  let digest = RspackHashDigest::new(b"\xfb\xef\xff", &HashDigest::Base64Url);
+
+  assert_eq!(digest.encoded(), "--__");
+
+  let digest = RspackHashDigest::new(b"hello", &HashDigest::Base64Url);
+
+  assert_eq!(digest.encoded(), "aGVsbG8");
+}
+
+#[test]
+fn hash_salt_is_written_as_raw_bytes() {
+  let salt = HashSalt::Salt("salt".to_string());
+  let salted = RspackHash::with_salt(&HashFunction::Xxhash64, &salt)
+    .digest(&HashDigest::Hex)
+    .encoded()
+    .to_string();
+
+  let mut expected = RspackHash::new(&HashFunction::Xxhash64);
+  expected.write(b"salt");
+  let expected = expected.digest(&HashDigest::Hex).encoded().to_string();
+
+  assert_eq!(salted, expected);
+}
