diff --git a/crates/keyfork-shard/src/lib.rs b/crates/keyfork-shard/src/lib.rs index cd5bb30..d32bc7c 100644 --- a/crates/keyfork-shard/src/lib.rs +++ b/crates/keyfork-shard/src/lib.rs @@ -249,7 +249,7 @@ pub trait Format { // create our shared key let our_key = EphemeralSecret::random(); - let our_pubkey_mnemonic = Mnemonic::from_bytes(PublicKey::from(&our_key).as_bytes())?; + let our_pubkey_mnemonic = Mnemonic::try_from_slice(PublicKey::from(&our_key).as_bytes())?; let shared_secret = our_key.diffie_hellman(&PublicKey::from(their_pubkey)); assert!( shared_secret.was_contributory(), @@ -302,7 +302,7 @@ pub trait Format { let mut mnemonic_bytes = [0u8; ENCRYPTED_LENGTH as usize]; mnemonic_bytes.copy_from_slice(&encrypted_bytes); - let payload_mnemonic = Mnemonic::from_nonstandard_bytes(mnemonic_bytes); + let payload_mnemonic = Mnemonic::from_array(mnemonic_bytes); #[cfg(feature = "qrcode")] { @@ -439,7 +439,7 @@ pub fn remote_decrypt(w: &mut impl Write) -> Result<(), Box 0) { iter += 1; let our_key = EphemeralSecret::random(); - let key_mnemonic = Mnemonic::from_bytes(PublicKey::from(&our_key).as_bytes())?; + let key_mnemonic = Mnemonic::try_from_slice(PublicKey::from(&our_key).as_bytes())?; #[cfg(feature = "qrcode")] { diff --git a/crates/keyfork/src/cli/mnemonic.rs b/crates/keyfork/src/cli/mnemonic.rs index ef99948..c43f50b 100644 --- a/crates/keyfork/src/cli/mnemonic.rs +++ b/crates/keyfork/src/cli/mnemonic.rs @@ -109,7 +109,7 @@ impl MnemonicSeedSource { MnemonicSeedSource::Tarot => todo!(), MnemonicSeedSource::Dice => todo!(), }; - let mnemonic = keyfork_mnemonic_util::Mnemonic::from_bytes(&seed)?; + let mnemonic = keyfork_mnemonic_util::Mnemonic::try_from_slice(&seed)?; Ok(mnemonic.to_string()) } } diff --git a/crates/keyfork/src/cli/recover.rs b/crates/keyfork/src/cli/recover.rs index 6a9b655..8202782 100644 --- a/crates/keyfork/src/cli/recover.rs +++ b/crates/keyfork/src/cli/recover.rs @@ -85,7 +85,7 @@ pub struct Recover { impl Recover { pub fn handle(&self, _k: &Keyfork) -> Result<()> { let seed = self.command.handle()?; - let mnemonic = Mnemonic::from_bytes(&seed)?; + let mnemonic = Mnemonic::try_from_slice(&seed)?; tokio::runtime::Builder::new_multi_thread() .enable_all() .build() diff --git a/crates/keyfork/src/cli/wizard.rs b/crates/keyfork/src/cli/wizard.rs index d7fa553..58718a8 100644 --- a/crates/keyfork/src/cli/wizard.rs +++ b/crates/keyfork/src/cli/wizard.rs @@ -195,7 +195,7 @@ fn generate_shard_secret( fn bottoms_up(key_discovery: &Path, threshold: u8, output_shardfile: &Path, output_cert: &Path, user_id: &str,) -> Result<()> { let entropy = keyfork_entropy::generate_entropy_of_const_size::<{ 256 / 8 }>()?; - let mnemonic = Mnemonic::from_nonstandard_bytes(entropy); + let mnemonic = Mnemonic::from_array(entropy); let seed = mnemonic.generate_seed(None); // TODO: should this allow for customizing the account index from 0? Potential for key reuse diff --git a/crates/util/keyfork-mnemonic-util/src/lib.rs b/crates/util/keyfork-mnemonic-util/src/lib.rs index d456f64..69687d4 100644 --- a/crates/util/keyfork-mnemonic-util/src/lib.rs +++ b/crates/util/keyfork-mnemonic-util/src/lib.rs @@ -6,7 +6,7 @@ //! use keyfork_mnemonic_util::Mnemonic; //! let data = b"Hello, world! I am a mnemonic :)"; //! assert_eq!(data.len(), 32); -//! let mnemonic = Mnemonic::from_bytes(data).unwrap(); +//! let mnemonic = Mnemonic::try_from_slice(data).unwrap(); //! println!("Our mnemonic is: {mnemonic}"); //! ``` //! @@ -270,9 +270,9 @@ where /// ```rust /// use keyfork_mnemonic_util::Mnemonic; /// let data = b"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; - /// let mnemonic = Mnemonic::from_bytes(data.as_slice()).unwrap(); + /// let mnemonic = Mnemonic::try_from_slice(data.as_slice()).unwrap(); /// ``` - pub fn from_bytes(bytes: &[u8]) -> Result, MnemonicGenerationError> { + pub fn try_from_slice(bytes: &[u8]) -> Result, MnemonicGenerationError> { let bit_count = bytes.len() * 8; if bit_count % 32 != 0 { @@ -292,21 +292,21 @@ where /// ```rust /// use keyfork_mnemonic_util::Mnemonic; /// let data = b"hello world!"; - /// let mnemonic = Mnemonic::from_nonstandard_bytes(*data); + /// let mnemonic = Mnemonic::from_array(*data); /// ``` /// /// If an invalid size is requested, the code will fail to compile: /// /// ```rust,compile_fail /// use keyfork_mnemonic_util::Mnemonic; - /// let mnemonic = Mnemonic::from_nonstandard_bytes([0u8; 53]); + /// let mnemonic = Mnemonic::from_array([0u8; 53]); /// ``` /// /// ```rust,compile_fail /// use keyfork_mnemonic_util::Mnemonic; - /// let mnemonic = Mnemonic::from_nonstandard_bytes([0u8; 1024 + 4]); + /// let mnemonic = Mnemonic::from_array([0u8; 1024 + 4]); /// ``` - pub fn from_nonstandard_bytes(bytes: [u8; N]) -> MnemonicBase { + pub fn from_array(bytes: [u8; N]) -> MnemonicBase { #[allow(clippy::let_unit_value)] { let () = AssertValidMnemonicSize::::OK_CHUNKS; @@ -315,16 +315,6 @@ where Self::from_raw_bytes(&bytes) } - /// Generate a [`Mnemonic`] from the provided data and [`Wordlist`]. The data is expected to be - /// of 128, 192, or 256 bits, as per BIP-0039. - /// - /// # Errors - /// An error may be returned if the data is not within the expected lengths. - #[deprecated = "use Mnemonic::from_bytes"] - pub fn from_entropy(bytes: &[u8]) -> Result, MnemonicGenerationError> { - MnemonicBase::from_bytes(bytes) - } - /// Create a Mnemonic using an arbitrary length of given data. The length does not need to /// conform to BIP-0039 standards, but should be a multiple of 32 bits or 4 bytes. /// @@ -332,8 +322,8 @@ where /// This function can potentially produce mnemonics that are not BIP-0039 compliant or can't /// properly be encoded as a mnemonic. It is assumed the caller asserts the byte count is `% 4 /// == 0`. If the assumption is incorrect, code may panic. The - /// [`MnemonicBase::from_nonstandard_bytes`] function may be used to generate entropy if the - /// length of the data is known at compile-time. + /// [`MnemonicBase::from_array`] function may be used to generate entropy if the length of the + /// data is known at compile-time. /// /// # Examples /// ```rust @@ -461,6 +451,39 @@ where } } +impl MnemonicBase +where + W: Wordlist, +{ + /// Generate a [`Mnemonic`] from the provided data and [`Wordlist`]. The data is expected to be + /// of 128, 192, or 256 bits, as per BIP-0039. + /// + /// # Errors + /// An error may be returned if the data is not within the expected lengths. + #[deprecated = "use Mnemonic::try_from_slice"] + pub fn from_bytes(bytes: &[u8]) -> Result, MnemonicGenerationError> { + MnemonicBase::try_from_slice(bytes) + } + + /// Generate a [`Mnemonic`] from the provided data and [`Wordlist`]. The data is expected to be + /// of 128, 192, or 256 bits, as per BIP-0039. + /// + /// # Errors + /// An error may be returned if the data is not within the expected lengths. + #[deprecated = "use Mnemonic::try_from_slice"] + pub fn from_entropy(bytes: &[u8]) -> Result, MnemonicGenerationError> { + MnemonicBase::try_from_slice(bytes) + } + + /// Generate a [`Mnemonic`] from the provided data and [`Wordlist`]. The data may be of a size + /// of a factor of 4, up to 1024 bytes. + /// + #[deprecated = "Use Mnemonic::from_array"] + pub fn from_nonstandard_bytes(bytes: [u8; N]) -> MnemonicBase { + MnemonicBase::from_array(bytes) + } +} + #[cfg(test)] mod tests { use std::{collections::HashSet, fs::File, io::Read}; @@ -477,7 +500,7 @@ mod tests { let mut random_handle = File::open("/dev/random").unwrap(); let entropy = &mut [0u8; 256 / 8]; random_handle.read_exact(&mut entropy[..]).unwrap(); - let mnemonic = super::Mnemonic::from_bytes(&entropy[..256 / 8]).unwrap(); + let mnemonic = super::Mnemonic::try_from_slice(&entropy[..256 / 8]).unwrap(); let new_entropy = mnemonic.as_bytes(); assert_eq!(new_entropy, entropy); } @@ -493,7 +516,7 @@ mod tests { }; let hex = hex::decode(hex_.as_str().unwrap()).unwrap(); - let mnemonic = Mnemonic::from_bytes(&hex).unwrap(); + let mnemonic = Mnemonic::try_from_slice(&hex).unwrap(); assert_eq!(mnemonic.to_string(), seed.as_str().unwrap()); } @@ -504,7 +527,7 @@ mod tests { let mut random_handle = File::open("/dev/random").unwrap(); let entropy = &mut [0u8; 256 / 8]; random_handle.read_exact(&mut entropy[..]).unwrap(); - let my_mnemonic = Mnemonic::from_bytes(&entropy[..256 / 8]).unwrap(); + let my_mnemonic = Mnemonic::try_from_slice(&entropy[..256 / 8]).unwrap(); let their_mnemonic = bip39::Mnemonic::from_entropy(&entropy[..256 / 8]).unwrap(); assert_eq!(my_mnemonic.to_string(), their_mnemonic.to_string()); assert_eq!(my_mnemonic.generate_seed(None), their_mnemonic.to_seed("")); @@ -528,7 +551,7 @@ mod tests { for _ in 0..tests { random.read_exact(&mut entropy[..]).unwrap(); - let mnemonic = Mnemonic::from_bytes(&entropy[..256 / 8]).unwrap(); + let mnemonic = Mnemonic::try_from_slice(&entropy[..256 / 8]).unwrap(); let words = mnemonic.words(); hs.clear(); hs.extend(words); @@ -559,7 +582,7 @@ mod tests { let mut entropy = [0u8; 1024]; let mut random = std::fs::File::open("/dev/urandom").unwrap(); random.read_exact(&mut entropy[..]).unwrap(); - let mnemonic = Mnemonic::from_nonstandard_bytes(entropy); + let mnemonic = Mnemonic::from_array(entropy); let words = mnemonic.words(); assert_eq!(words.len(), 768); }