add new bitbox-core-utils workspace crate

diff --git a/src/rust/Cargo.lock b/src/rust/Cargo.lock
index 13b15ec..96b9681 100644
--- a/src/rust/Cargo.lock
+++ b/src/rust/Cargo.lock
@@ -122,6 +122,18 @@ dependencies = [
 name = "bitbox-bytequeue"
 version = "0.1.0"
 
+[[package]]
+name = "bitbox-core-utils"
+version = "0.1.0"
+dependencies = [
+ "bitbox-hal",
+ "bitbox-platform-host",
+ "digest",
+ "hex_lit",
+ "sha2",
+ "zeroize",
+]
+
 [[package]]
 name = "bitbox-da14531"
 version = "0.1.0"
@@ -264,6 +276,7 @@ dependencies = [
  "bip39",
  "bitbox-aes",
  "bitbox-bytequeue",
+ "bitbox-core-utils",
  "bitbox-da14531",
  "bitbox-executor",
  "bitbox-hal",
@@ -306,6 +319,7 @@ dependencies = [
  "bip39",
  "bitbox-aes",
  "bitbox-bytequeue",
+ "bitbox-core-utils",
  "bitbox-da14531",
  "bitbox-framed-serial-link",
  "bitbox-hal",
diff --git a/src/rust/Cargo.toml b/src/rust/Cargo.toml
index ad538c0..dbac1c8 100644
--- a/src/rust/Cargo.toml
+++ b/src/rust/Cargo.toml
@@ -12,6 +12,7 @@ members = [
     "bitbox-da14531",
     "bitbox-platform-host",
     "bitbox-hal",
+    "bitbox-core-utils",
     "bitbox-framed-serial-link",
     "util",
     "bitbox02-noise",
diff --git a/src/rust/bitbox-core-utils/Cargo.toml b/src/rust/bitbox-core-utils/Cargo.toml
new file mode 100644
index 0000000..26ab3f9
--- /dev/null
+++ b/src/rust/bitbox-core-utils/Cargo.toml
@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+name = "bitbox-core-utils"
+version = "0.1.0"
+authors = ["Shift Crypto AG <support@bitbox.swiss>"]
+edition = "2024"
+license = "Apache-2.0"
+
+[dependencies]
+bitbox-hal = { path = "../bitbox-hal" }
+digest = { workspace = true }
+sha2 = { workspace = true }
+zeroize = { workspace = true }
+
+[dev-dependencies]
+bitbox-platform-host = { path = "../bitbox-platform-host" }
+hex_lit = { workspace = true }
diff --git a/src/rust/bitbox-core-utils/src/lib.rs b/src/rust/bitbox-core-utils/src/lib.rs
new file mode 100644
index 0000000..77a75e9
--- /dev/null
+++ b/src/rust/bitbox-core-utils/src/lib.rs
@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#![no_std]
+
+extern crate alloc;
+
+pub mod random;
+pub mod salt;
diff --git a/src/rust/bitbox-core-utils/src/random.rs b/src/rust/bitbox-core-utils/src/random.rs
new file mode 100644
index 0000000..1cdb5f3
--- /dev/null
+++ b/src/rust/bitbox-core-utils/src/random.rs
@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: Apache-2.0
+
+use alloc::boxed::Box;
+
+use bitbox_hal::{Hal, Random, SecureChip, securechip};
+use digest::FixedOutput;
+use sha2::Digest;
+
+pub fn random_32_bytes(
+    hal_random: &mut impl Random,
+    hal_securechip: &mut impl SecureChip,
+) -> Result<Box<zeroize::Zeroizing<[u8; 32]>>, securechip::Error> {
+    let mut mixed = zeroize::Zeroizing::new([0u8; 32]);
+    hal_random.mcu_32_bytes(&mut mixed);
+
+    let securechip_random = hal_securechip.random()?;
+    for (byte, securechip_byte) in mixed.iter_mut().zip(securechip_random.iter()) {
+        *byte ^= *securechip_byte;
+    }
+
+    let factory_randomness = hal_random.factory_randomness();
+    for (byte, factory_randomness_byte) in mixed.iter_mut().zip(factory_randomness.iter()) {
+        *byte ^= *factory_randomness_byte;
+    }
+
+    let mut result = Box::new(zeroize::Zeroizing::new([0u8; 32]));
+    let mut hasher = sha2::Sha256::new();
+    hasher.update(mixed.as_slice());
+    FixedOutput::finalize_into(hasher, result.as_mut_slice().into());
+    Ok(result)
+}
+
+pub fn random_32_bytes_from_hal(
+    hal: &mut impl Hal,
+) -> Result<Box<zeroize::Zeroizing<[u8; 32]>>, securechip::Error> {
+    let bitbox_hal::HalSubsystems {
+        random, securechip, ..
+    } = hal.as_mut();
+    random_32_bytes(random, securechip)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bitbox_platform_host::random::TestingRandom;
+    use bitbox_platform_host::securechip::FakeSecureChip;
+    use hex_lit::hex;
+
+    #[test]
+    fn test_random_32_bytes() {
+        let mut hal_random = TestingRandom::new();
+        let mut hal_securechip = FakeSecureChip::new();
+        let mcu_random = hex!("00112233445566778899aabbccddeefffedcba98765432100123456789abcdef");
+        let securechip_random =
+            hex!("102030405060708090a0b0c0d0e0f0000f1e2d3c4b5a69788796a5b4c3d2e1f0");
+        let factory_randomness = TestingRandom::FACTORY_RANDOMNESS;
+
+        hal_random.mock_next(mcu_random);
+        hal_securechip.mock_random(securechip_random);
+        assert_eq!(hal_random.factory_randomness(), &factory_randomness);
+
+        let result = random_32_bytes(&mut hal_random, &mut hal_securechip).unwrap();
+
+        /* Reproduce expected with Python:
+        import hashlib
+        mcu_random = bytes.fromhex(
+            "00112233445566778899aabbccddeefffedcba98765432100123456789abcdef"
+        )
+        securechip_random = bytes.fromhex(
+            "102030405060708090a0b0c0d0e0f0000f1e2d3c4b5a69788796a5b4c3d2e1f0"
+        )
+        factory_randomness = bytes.fromhex(
+            "f71df5932e61dbaab9b9eca90e59c4b45ec91fadf803db15578c260c608eb46b"
+        )
+        mixed = bytes(
+            m ^ s ^ f
+            for m, s, f in zip(mcu_random, securechip_random, factory_randomness)
+        )
+        print(hashlib.sha256(mixed).hexdigest())
+        */
+        let expected = hex!("843595519af3ac2a92cbe2be42a77d5297f64a1c98c1edbc27e1fc661f1d4ac8");
+        assert_eq!(result.as_slice(), &expected);
+    }
+}
diff --git a/src/rust/bitbox-core-utils/src/salt.rs b/src/rust/bitbox-core-utils/src/salt.rs
new file mode 100644
index 0000000..76e48fb
--- /dev/null
+++ b/src/rust/bitbox-core-utils/src/salt.rs
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+
+use alloc::vec::Vec;
+
+use bitbox_hal::Memory;
+use sha2::Digest;
+use zeroize::Zeroizing;
+
+/// Creates `SHA256(salt_root || purpose || data)`, where `salt_root` is a persisted value that
+/// remains unchanged until the device is reset. The `purpose` string namespaces individual uses of
+/// the salt, and the provided `data` slice is hashed alongside it.
+///
+/// Returns `Err(())` if the salt root cannot be retrieved from persistent storage.
+pub fn hash_data(
+    memory: &mut impl Memory,
+    data: &[u8],
+    purpose: &str,
+) -> Result<Zeroizing<Vec<u8>>, ()> {
+    let salt_root = memory.get_salt_root()?;
+
+    let mut hasher = sha2::Sha256::new();
+    hasher.update(salt_root.as_slice());
+    hasher.update(purpose.as_bytes());
+    hasher.update(data);
+
+    Ok(Zeroizing::new(hasher.finalize().to_vec()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bitbox_platform_host::memory::FakeMemory;
+    use hex_lit::hex;
+
+    const MOCK_SALT_ROOT: [u8; 32] =
+        hex!("0000000000000000111111111111111122222222222222223333333333333333");
+
+    #[test]
+    fn test_hash_data() {
+        let mut memory = FakeMemory::new();
+        memory.set_salt_root(&MOCK_SALT_ROOT);
+
+        let data = hex!("001122334455667788");
+        let expected = hex!("62db8dcd47ddf8e81809c377ed96643855d3052bb73237100ca81f0f5a7611e6");
+
+        let hash = hash_data(&mut memory, &data, "test purpose").unwrap();
+        assert_eq!(hash.as_slice(), &expected);
+    }
+
+    #[test]
+    fn test_hash_data_empty_inputs() {
+        let mut memory = FakeMemory::new();
+        memory.set_salt_root(&MOCK_SALT_ROOT);
+
+        let expected = hex!("2dbb05dd73d94edba6946611aaca367f76c809e96f20499ad674e596050f9833");
+
+        let hash = hash_data(&mut memory, &[], "").unwrap();
+        assert_eq!(hash.as_slice(), &expected);
+    }
+}
diff --git a/src/rust/bitbox02-rust-c/Cargo.toml b/src/rust/bitbox02-rust-c/Cargo.toml
index 677eb19..393369b 100644
--- a/src/rust/bitbox02-rust-c/Cargo.toml
+++ b/src/rust/bitbox02-rust-c/Cargo.toml
@@ -8,6 +8,7 @@ edition = "2024"
 license = "Apache-2.0"
 
 [dependencies]
+bitbox-core-utils = { path = "../bitbox-core-utils" }
 bitbox02-rust = { path = "../bitbox02-rust", optional = true }
 bitbox-usb-report-queue = { path = "../bitbox-usb-report-queue" }
 bitbox-bytequeue = { path = "../bitbox-bytequeue" }
diff --git a/src/rust/bitbox02-rust-c/src/firmware_c_api.rs b/src/rust/bitbox02-rust-c/src/firmware_c_api.rs
index 7cfd6fe..e77e2b6 100644
--- a/src/rust/bitbox02-rust-c/src/firmware_c_api.rs
+++ b/src/rust/bitbox02-rust-c/src/firmware_c_api.rs
@@ -36,7 +36,7 @@ pub unsafe extern "C" fn rust_salt_hash_data(
         Err(()) => return false,
     };
     let mut hal = crate::HalImpl::new();
-    match bitbox02_rust::salt::hash_data(hal.memory(), data.as_ref(), purpose_str) {
+    match bitbox_core_utils::salt::hash_data(hal.memory(), data.as_ref(), purpose_str) {
         Ok(hash) => {
             hash_out.as_mut()[..32].copy_from_slice(&hash);
             true
diff --git a/src/rust/bitbox02-rust/Cargo.toml b/src/rust/bitbox02-rust/Cargo.toml
index 4b9f0d6..80acf13 100644
--- a/src/rust/bitbox02-rust/Cargo.toml
+++ b/src/rust/bitbox02-rust/Cargo.toml
@@ -15,6 +15,7 @@ doctest = false
 
 [dependencies]
 bitbox-hal = { path = "../bitbox-hal" }
+bitbox-core-utils = { path = "../bitbox-core-utils" }
 bitbox-da14531 = { path = "../bitbox-da14531" }
 bitbox02 = { path = "../bitbox02" }
 bitbox-platform-host = { path = "../bitbox-platform-host", optional = true }
diff --git a/src/rust/bitbox02-rust/src/keystore.rs b/src/rust/bitbox02-rust/src/keystore.rs
index 046c6f6..b4bad8d 100644
--- a/src/rust/bitbox02-rust/src/keystore.rs
+++ b/src/rust/bitbox02-rust/src/keystore.rs
@@ -135,7 +135,7 @@ impl core::convert::From<securechip::Error> for Error {
 
 fn random_32_bytes(hal: &mut impl KeystoreHal) -> Result<Box<zeroize::Zeroizing<[u8; 32]>>, Error> {
     let (random, securechip) = hal.random_and_securechip();
-    crate::random::random_32_bytes(random, securechip).map_err(Into::into)
+    bitbox_core_utils::random::random_32_bytes(random, securechip).map_err(Into::into)
 }
 
 #[derive(Copy, Clone)]
@@ -256,8 +256,9 @@ fn verify_seed(
 }
 
 fn hash_seed(hal: &mut impl KeystoreHal, seed: &[u8]) -> Result<[u8; 32], Error> {
-    let salted_key = crate::salt::hash_data(hal.memory(), &[], "keystore_retain_seed_hash")
-        .map_err(|_| Error::Salt)?;
+    let salted_key =
+        bitbox_core_utils::salt::hash_data(hal.memory(), &[], "keystore_retain_seed_hash")
+            .map_err(|_| Error::Salt)?;
 
     let mut engine = HmacEngine::<sha256::Hash>::new(salted_key.as_slice());
     engine.input(seed);
@@ -319,7 +320,7 @@ fn encrypt_and_store_seed_internal(
         .securechip()
         .init_new_password(password, password_stretch_algo)?;
 
-    let iv_rand = crate::random::random_32_bytes_from_hal(hal)?;
+    let iv_rand = bitbox_core_utils::random::random_32_bytes_from_hal(hal)?;
     let iv: &[u8; 16] = iv_rand.first_chunk::<16>().unwrap();
     let encrypted = bitbox_aes::encrypt_with_hmac(iv, &secret, seed);
 
@@ -544,7 +545,7 @@ pub fn create_and_store_seed(
         return Err(Error::SeedSize);
     }
 
-    let mut seed_vec = crate::random::random_32_bytes_from_hal(hal)?;
+    let mut seed_vec = bitbox_core_utils::random::random_32_bytes_from_hal(hal)?;
     let seed = &mut seed_vec[..seed_len];
 
     // Mix in host entropy.
@@ -553,7 +554,7 @@ pub fn create_and_store_seed(
     }
 
     // Mix in entropy derived from the user password.
-    let password_salted_hashed = crate::salt::hash_data(
+    let password_salted_hashed = bitbox_core_utils::salt::hash_data(
         hal.memory(),
         password.as_bytes(),
         "keystore_seed_generation",
@@ -693,12 +694,12 @@ pub fn stretch_retained_seed_encryption_key(
     purpose_in: &str,
     purpose_out: &str,
 ) -> Result<zeroize::Zeroizing<Vec<u8>>, Error> {
-    let salted_in = crate::salt::hash_data(hal.memory(), encryption_key, purpose_in)
+    let salted_in = bitbox_core_utils::salt::hash_data(hal.memory(), encryption_key, purpose_in)
         .map_err(|_| Error::Salt)?;
 
     let kdf = hal.securechip().kdf(salted_in.as_slice())?;
 
-    let salted_out = crate::salt::hash_data(hal.memory(), encryption_key, purpose_out)
+    let salted_out = bitbox_core_utils::salt::hash_data(hal.memory(), encryption_key, purpose_out)
         .map_err(|_| Error::Salt)?;
 
     let mut engine = HmacEngine::<sha256::Hash>::new(salted_out.as_slice());
@@ -811,7 +812,7 @@ pub fn secp256k1_schnorr_sign(
             .map_err(|_| ())?;
     }
 
-    let aux_rand = crate::random::random_32_bytes_from_hal(hal).map_err(|_| ())?;
+    let aux_rand = bitbox_core_utils::random::random_32_bytes_from_hal(hal).map_err(|_| ())?;
     let sig = SECP256K1.sign_schnorr_with_aux_rand(
         &bitcoin::secp256k1::Message::from_digest(*msg),
         &keypair,
diff --git a/src/rust/bitbox02-rust/src/lib.rs b/src/rust/bitbox02-rust/src/lib.rs
index 15b99e9..655d8be 100644
--- a/src/rust/bitbox02-rust/src/lib.rs
+++ b/src/rust/bitbox02-rust/src/lib.rs
@@ -28,9 +28,7 @@ pub mod keystore;
     not(any(feature = "c-unit-testing", feature = "simulator-graphical"))
 ))]
 pub mod main_loop;
-pub mod random;
 pub mod reset;
-pub mod salt;
 pub mod secp256k1;
 #[cfg(feature = "app-u2f")]
 mod u2f;
diff --git a/src/rust/bitbox02-rust/src/random.rs b/src/rust/bitbox02-rust/src/random.rs
deleted file mode 100644
index 75b8eb6..0000000
--- a/src/rust/bitbox02-rust/src/random.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-use alloc::boxed::Box;
-
-use crate::hal::{Hal, Random, SecureChip, securechip};
-use digest::FixedOutput;
-use sha2::Digest;
-
-pub fn random_32_bytes(
-    hal_random: &mut impl Random,
-    hal_securechip: &mut impl SecureChip,
-) -> Result<Box<zeroize::Zeroizing<[u8; 32]>>, securechip::Error> {
-    let mut mixed = zeroize::Zeroizing::new([0u8; 32]);
-    hal_random.mcu_32_bytes(&mut mixed);
-
-    let securechip_random = hal_securechip.random()?;
-    for (byte, securechip_byte) in mixed.iter_mut().zip(securechip_random.iter()) {
-        *byte ^= *securechip_byte;
-    }
-
-    let factory_randomness = hal_random.factory_randomness();
-    for (byte, factory_randomness_byte) in mixed.iter_mut().zip(factory_randomness.iter()) {
-        *byte ^= *factory_randomness_byte;
-    }
-
-    let mut result = Box::new(zeroize::Zeroizing::new([0u8; 32]));
-    let mut hasher = sha2::Sha256::new();
-    hasher.update(mixed.as_slice());
-    FixedOutput::finalize_into(hasher, result.as_mut_slice().into());
-    Ok(result)
-}
-
-pub fn random_32_bytes_from_hal(
-    hal: &mut impl Hal,
-) -> Result<Box<zeroize::Zeroizing<[u8; 32]>>, securechip::Error> {
-    let crate::hal::HalSubsystems {
-        random, securechip, ..
-    } = hal.as_mut();
-    random_32_bytes(random, securechip)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::hal::testing::{TestingHal, TestingRandom};
-    use hex_lit::hex;
-
-    #[test]
-    fn test_random_32_bytes() {
-        let mut mock_hal = TestingHal::new();
-        let mcu_random = hex!("00112233445566778899aabbccddeefffedcba98765432100123456789abcdef");
-        let securechip_random =
-            hex!("102030405060708090a0b0c0d0e0f0000f1e2d3c4b5a69788796a5b4c3d2e1f0");
-        let factory_randomness = TestingRandom::FACTORY_RANDOMNESS;
-
-        mock_hal.random.mock_next(mcu_random);
-        mock_hal.securechip.mock_random(securechip_random);
-        assert_eq!(mock_hal.random.factory_randomness(), &factory_randomness);
-
-        let (hal_random, hal_securechip) = (&mut mock_hal.random, &mut mock_hal.securechip);
-        let result = random_32_bytes(hal_random, hal_securechip).unwrap();
-
-        /* Reproduce expected with Python:
-        import hashlib
-        mcu_random = bytes.fromhex(
-            "00112233445566778899aabbccddeefffedcba98765432100123456789abcdef"
-        )
-        securechip_random = bytes.fromhex(
-            "102030405060708090a0b0c0d0e0f0000f1e2d3c4b5a69788796a5b4c3d2e1f0"
-        )
-        factory_randomness = bytes.fromhex(
-            "f71df5932e61dbaab9b9eca90e59c4b45ec91fadf803db15578c260c608eb46b"
-        )
-        mixed = bytes(
-            m ^ s ^ f
-            for m, s, f in zip(mcu_random, securechip_random, factory_randomness)
-        )
-        print(hashlib.sha256(mixed).hexdigest())
-        */
-        let expected = hex!("843595519af3ac2a92cbe2be42a77d5297f64a1c98c1edbc27e1fc661f1d4ac8");
-        assert_eq!(result.as_slice(), &expected);
-    }
-}
diff --git a/src/rust/bitbox02-rust/src/salt.rs b/src/rust/bitbox02-rust/src/salt.rs
deleted file mode 100644
index 9889ea1..0000000
--- a/src/rust/bitbox02-rust/src/salt.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-use alloc::vec::Vec;
-
-use crate::hal::Memory;
-use sha2::Digest;
-use zeroize::Zeroizing;
-
-/// Creates `SHA256(salt_root || purpose || data)`, where `salt_root` is a persisted value that
-/// remains unchanged until the device is reset. The `purpose` string namespaces individual uses of
-/// the salt, and the provided `data` slice is hashed alongside it.
-///
-/// Returns `Err(())` if the salt root cannot be retrieved from persistent storage.
-pub fn hash_data(
-    memory: &mut impl Memory,
-    data: &[u8],
-    purpose: &str,
-) -> Result<Zeroizing<Vec<u8>>, ()> {
-    let salt_root = memory.get_salt_root()?;
-
-    let mut hasher = sha2::Sha256::new();
-    hasher.update(salt_root.as_slice());
-    hasher.update(purpose.as_bytes());
-    hasher.update(data);
-
-    Ok(Zeroizing::new(hasher.finalize().to_vec()))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::hal::testing::TestingMemory;
-    use core::convert::TryInto;
-    use hex_lit::hex;
-
-    const MOCK_SALT_ROOT: [u8; 32] =
-        hex!("0000000000000000111111111111111122222222222222223333333333333333");
-
-    #[test]
-    fn test_hash_data() {
-        let mut memory = TestingMemory::new();
-        memory.set_salt_root(&MOCK_SALT_ROOT);
-
-        let data = hex!("001122334455667788");
-        let expected = hex!("62db8dcd47ddf8e81809c377ed96643855d3052bb73237100ca81f0f5a7611e6");
-
-        let hash = hash_data(&mut memory, &data, "test purpose").unwrap();
-        assert_eq!(hash.as_slice(), &expected);
-    }
-
-    #[test]
-    fn test_hash_data_empty_inputs() {
-        let mut memory = TestingMemory::new();
-        memory.set_salt_root(&MOCK_SALT_ROOT);
-
-        let expected = hex!("2dbb05dd73d94edba6946611aaca367f76c809e96f20499ad674e596050f9833");
-
-        let hash = hash_data(&mut memory, &[], "").unwrap();
-        assert_eq!(hash.as_slice(), &expected);
-    }
-}
diff --git a/test/simulator-graphical-bb03/Cargo.lock b/test/simulator-graphical-bb03/Cargo.lock
index 803b641..d6e2523 100644
--- a/test/simulator-graphical-bb03/Cargo.lock
+++ b/test/simulator-graphical-bb03/Cargo.lock
@@ -333,6 +333,16 @@ dependencies = [
 name = "bitbox-bytequeue"
 version = "0.1.0"
 
+[[package]]
+name = "bitbox-core-utils"
+version = "0.1.0"
+dependencies = [
+ "bitbox-hal",
+ "digest",
+ "sha2",
+ "zeroize",
+]
+
 [[package]]
 name = "bitbox-da14531"
 version = "0.1.0"
@@ -468,6 +478,7 @@ dependencies = [
  "bip39",
  "bitbox-aes",
  "bitbox-bytequeue",
+ "bitbox-core-utils",
  "bitbox-da14531",
  "bitbox-executor",
  "bitbox-hal",
diff --git a/test/simulator-graphical/Cargo.lock b/test/simulator-graphical/Cargo.lock
index 9c3f983..9a1a49e 100644
--- a/test/simulator-graphical/Cargo.lock
+++ b/test/simulator-graphical/Cargo.lock
@@ -295,6 +295,16 @@ dependencies = [
 name = "bitbox-bytequeue"
 version = "0.1.0"
 
+[[package]]
+name = "bitbox-core-utils"
+version = "0.1.0"
+dependencies = [
+ "bitbox-hal",
+ "digest",
+ "sha2",
+ "zeroize",
+]
+
 [[package]]
 name = "bitbox-da14531"
 version = "0.1.0"
@@ -412,6 +422,7 @@ dependencies = [
  "bip39",
  "bitbox-aes",
  "bitbox-bytequeue",
+ "bitbox-core-utils",
  "bitbox-da14531",
  "bitbox-executor",
  "bitbox-hal",
@@ -452,6 +463,7 @@ dependencies = [
  "bip39",
  "bitbox-aes",
  "bitbox-bytequeue",
+ "bitbox-core-utils",
  "bitbox-da14531",
  "bitbox-framed-serial-link",
  "bitbox-hal",