crates/daemon/keyforkd/src/lib.rs

@@ -57,7 +57,7 @@ pub async fn start_and_run_server_on(
     let service = ServiceBuilder::new()
         .layer(middleware::BincodeLayer::new())
         // TODO: passphrase support and/or store passphrase with mnemonic
-        .service(Keyforkd::new(mnemonic.generate_seed(None).to_vec()));
+        .service(Keyforkd::new(mnemonic.generate_seed(None)));
 
     let mut server = match UnixServer::bind(socket_path) {
         Ok(s) => s,

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::try_from_slice(PublicKey::from(&our_key).as_bytes())?;
+        let our_pubkey_mnemonic = Mnemonic::from_bytes(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_array(mnemonic_bytes);
+        let payload_mnemonic = Mnemonic::from_nonstandard_bytes(mnemonic_bytes);
 
         #[cfg(feature = "qrcode")]
         {
@@ -439,7 +439,7 @@ pub fn remote_decrypt(w: &mut impl Write) -> Result<(), Box<dyn std::error::Erro
     while iter_count.is_none() || iter_count.is_some_and(|i| i > 0) {
         iter += 1;
         let our_key = EphemeralSecret::random();
-        let key_mnemonic = Mnemonic::try_from_slice(PublicKey::from(&our_key).as_bytes())?;
+        let key_mnemonic = Mnemonic::from_bytes(PublicKey::from(&our_key).as_bytes())?;
 
         #[cfg(feature = "qrcode")]
         {

crates/keyfork/src/cli/mnemonic.rs

@@ -109,7 +109,7 @@ impl MnemonicSeedSource {
             MnemonicSeedSource::Tarot => todo!(),
             MnemonicSeedSource::Dice => todo!(),
         };
-        let mnemonic = keyfork_mnemonic_util::Mnemonic::try_from_slice(&seed)?;
+        let mnemonic = keyfork_mnemonic_util::Mnemonic::from_bytes(&seed)?;
         Ok(mnemonic.to_string())
     }
 }

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::try_from_slice(&seed)?;
+        let mnemonic = Mnemonic::from_bytes(&seed)?;
         tokio::runtime::Builder::new_multi_thread()
             .enable_all()
             .build()

crates/keyfork/src/cli/wizard.rs

@@ -14,7 +14,7 @@ use keyfork_derive_openpgp::{
     openpgp::{self, packet::UserID, types::KeyFlags, Cert, serialize::Marshal, armor::{Writer, Kind}},
     XPrv,
 };
-use keyfork_derive_util::{DerivationIndex, DerivationPath};
+use keyfork_derive_util::{DerivationIndex, DerivationPath, VariableLengthSeed};
 use keyfork_prompt::{
     default_terminal,
     validators::{SecurePinValidator, Validator},
@@ -195,7 +195,8 @@ 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_array(entropy);
+    let mnemonic = Mnemonic::from_nonstandard_bytes(entropy);
+    // TODO: make this return const size, since is hash based
     let seed = mnemonic.generate_seed(None);
 
     // TODO: should this allow for customizing the account index from 0? Potential for key reuse
@@ -212,7 +213,7 @@ fn bottoms_up(key_discovery: &Path, threshold: u8, output_shardfile: &Path, outp
             .set_storage_encryption(),
         KeyFlags::empty().set_authentication(),
     ];
-    let xprv = XPrv::new(seed)
+    let xprv = XPrv::new(VariableLengthSeed::new(&seed))
         .expect("could not construct master key from seed")
         .derive_path(&path)?;
     let userid = UserID::from(user_id);

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::try_from_slice(data).unwrap();
+//! let mnemonic = Mnemonic::from_bytes(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::try_from_slice(data.as_slice()).unwrap();
+    /// let mnemonic = Mnemonic::from_bytes(data.as_slice()).unwrap();
     /// ```
-    pub fn try_from_slice(bytes: &[u8]) -> Result<MnemonicBase<W>, MnemonicGenerationError> {
+    pub fn from_bytes(bytes: &[u8]) -> Result<MnemonicBase<W>, 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_array(*data);
+    /// let mnemonic = Mnemonic::from_nonstandard_bytes(*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_array([0u8; 53]);
+    /// let mnemonic = Mnemonic::from_nonstandard_bytes([0u8; 53]);
     /// ```
     ///
     /// ```rust,compile_fail
     /// use keyfork_mnemonic_util::Mnemonic;
-    /// let mnemonic = Mnemonic::from_array([0u8; 1024 + 4]);
+    /// let mnemonic = Mnemonic::from_nonstandard_bytes([0u8; 1024 + 4]);
     /// ```
-    pub fn from_array<const N: usize>(bytes: [u8; N]) -> MnemonicBase<W> {
+    pub fn from_nonstandard_bytes<const N: usize>(bytes: [u8; N]) -> MnemonicBase<W> {
         #[allow(clippy::let_unit_value)]
         {
             let () = AssertValidMnemonicSize::<N>::OK_CHUNKS;
@@ -315,6 +315,16 @@ 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<MnemonicBase<W>, 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.
     ///
@@ -322,8 +332,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_array`] function may be used to generate entropy if the length of the
-    /// data is known at compile-time.
+    /// [`MnemonicBase::from_nonstandard_bytes`] function may be used to generate entropy if the
+    /// length of the data is known at compile-time.
     ///
     /// # Examples
     /// ```rust
@@ -398,7 +408,7 @@ where
         &self,
         passphrase: impl Into<Option<&'a str>>,
     ) -> Result<Vec<u8>, MnemonicGenerationError> {
-        Ok(self.generate_seed(passphrase).to_vec())
+        Ok(self.generate_seed(passphrase))
     }
 
     /// Create a BIP-0032 seed from the provided data and an optional passphrase.
@@ -406,7 +416,8 @@ where
     /// # Panics
     /// The function may panic if the HmacSha512 function returns an error. The only error the
     /// HmacSha512 function should return is an invalid length, which should not be possible.
-    pub fn generate_seed<'a>(&self, passphrase: impl Into<Option<&'a str>>) -> [u8; 64] {
+    ///
+    pub fn generate_seed<'a>(&self, passphrase: impl Into<Option<&'a str>>) -> Vec<u8> {
         let passphrase = passphrase.into();
 
         let mut seed = [0u8; 64];
@@ -414,7 +425,7 @@ where
         let salt = ["mnemonic", passphrase.unwrap_or("")].join("");
         pbkdf2::<Hmac<Sha512>>(mnemonic.as_bytes(), salt.as_bytes(), 2048, &mut seed)
             .expect(bug!("HmacSha512 InvalidLength should be infallible"));
-        seed
+        seed.to_vec()
     }
 
     /// Encode the mnemonic into a list of integers 11 bits in length, matching the length of a
@@ -451,39 +462,6 @@ where
     }
 }
 
-impl<W> MnemonicBase<W>
-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<MnemonicBase<W>, 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<MnemonicBase<W>, 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<const N: usize>(bytes: [u8; N]) -> MnemonicBase<W> {
-        MnemonicBase::from_array(bytes)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::{collections::HashSet, fs::File, io::Read};
@@ -500,7 +478,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::try_from_slice(&entropy[..256 / 8]).unwrap();
+        let mnemonic = super::Mnemonic::from_bytes(&entropy[..256 / 8]).unwrap();
         let new_entropy = mnemonic.as_bytes();
         assert_eq!(new_entropy, entropy);
     }
@@ -516,7 +494,7 @@ mod tests {
             };
             let hex = hex::decode(hex_.as_str().unwrap()).unwrap();
 
-            let mnemonic = Mnemonic::try_from_slice(&hex).unwrap();
+            let mnemonic = Mnemonic::from_bytes(&hex).unwrap();
 
             assert_eq!(mnemonic.to_string(), seed.as_str().unwrap());
         }
@@ -527,7 +505,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::try_from_slice(&entropy[..256 / 8]).unwrap();
+        let my_mnemonic = Mnemonic::from_bytes(&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(""));
@@ -551,7 +529,7 @@ mod tests {
 
         for _ in 0..tests {
             random.read_exact(&mut entropy[..]).unwrap();
-            let mnemonic = Mnemonic::try_from_slice(&entropy[..256 / 8]).unwrap();
+            let mnemonic = Mnemonic::from_bytes(&entropy[..256 / 8]).unwrap();
             let words = mnemonic.words();
             hs.clear();
             hs.extend(words);
@@ -582,7 +560,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_array(entropy);
+        let mnemonic = Mnemonic::from_nonstandard_bytes(entropy);
         let words = mnemonic.words();
         assert_eq!(words.len(), 768);
     }