hkd32: Factor tiny-bip39 code into hkd32

Merges the `tiny-bip39` code `hkd32` properly, testing it against the
24-word BIP39 test vectors.

Author: tony-iqlusion

Cargo.lock

@@ -23,8 +23,9 @@ travis-ci = { repository = "iqlusioninc/crates", branch = "develop" }
 [dependencies]
 getrandom = { version = "0.1", optional = true }
 hmac = { version = "0.7", default-features = false }
+lazy_static = { version = "1", optional = true, default-features = false }
 sha2 = { version = "0.8", default-features = false }
-tiny-bip39 = { version = "0.6", default-features = false, optional = true }
+pbkdf2 = { version = "0.3", optional = true, default-features = false }
 
 [dependencies.subtle-encoding]
 version = "0.4"
@@ -41,7 +42,7 @@ path = "../zeroize"
 default = ["alloc", "bech32", "getrandom"]
 alloc = ["zeroize/alloc"]
 bech32 = ["alloc", "subtle-encoding/bech32-preview"]
-mnemonic = ["alloc", "tiny-bip39"]
+mnemonic = ["alloc", "getrandom", "lazy_static", "pbkdf2"]
 
 [package.metadata.docs.rs]
 all-features = true

hkd32/Cargo.toml

@@ -127,12 +127,6 @@ impl KeyMaterial {
         let b32 = Bech32::default().encode(hrp, self.as_bytes());
         Zeroizing::new(b32)
     }
-
-    /// Serialize this `KeyMaterial` as a BIP39 mnemonic phrase
-    #[cfg(feature = "mnemonic")]
-    pub fn to_mnemonic(&self, language: mnemonic::Language) -> mnemonic::Phrase {
-        mnemonic::Phrase::from_key_material(self, language)
-    }
 }
 
 impl From<[u8; KEY_SIZE]> for KeyMaterial {

hkd32/src/key_material.rs

@@ -41,7 +41,7 @@
 #![doc(html_root_url = "https://docs.rs/hkd32/0.1.2")]
 
 #[cfg(feature = "alloc")]
-#[cfg_attr(test, macro_use)]
+#[cfg_attr(any(feature = "mnemonic", test), macro_use)]
 extern crate alloc;
 
 mod key_material;

hkd32/src/lib.rs

@@ -1,107 +1,13 @@
-//! Support for BIP39 mnemonics.
+//! Support for BIP39 mnemonic phrases.
 //!
 //! These enable deriving `hkd32::KeyMaterial` from a 24-word BIP39 phrase.
+//!
+//! Adapted from the `bip39` crate.
+//! Copyright © 2017-2018 Stephen Oliver with contributions by Maciej Hirsz.
 
-use crate::{Error, KeyMaterial};
-use alloc::string::String;
-use zeroize::Zeroize;
-
-/// Number of words required for an HKD32-compatible mnemonic phrase
-pub const WORD_COUNT: usize = 24;
-
-/// Supported languages.
-///
-/// Presently only English is specified by the BIP39 standard
-#[derive(Copy, Clone, Debug)]
-pub enum Language {
-    /// English is presently the only supported language
-    English,
-}
-
-impl Default for Language {
-    fn default() -> Language {
-        Language::English
-    }
-}
-
-impl From<Language> for bip39::Language {
-    fn from(language: Language) -> bip39::Language {
-        match language {
-            Language::English => bip39::Language::English,
-        }
-    }
-}
-
-/// 24-word BIP39 Mnemonic phrase
-pub struct Phrase {
-    /// String value containing the phrase
-    string: String,
-
-    /// Associated language for this phrase
-    language: Language,
-}
-
-impl Phrase {
-    /// Create a random BIP39 mnemonic phrase.
-    pub fn random(language: Language) -> Self {
-        Self::from_key_material(&KeyMaterial::random(), language)
-    }
-
-    /// Create a new BIP39 mnemonic phrase from the given string.
-    ///
-    /// Must be a valid 24-word BIP39 mnemonic.
-    pub fn new<S>(phrase: S, language: Language) -> Result<Phrase, Error>
-    where
-        S: AsRef<str>,
-    {
-        let phrase = phrase.as_ref();
-
-        if bip39::Mnemonic::validate(phrase, language.into()).is_err() {
-            return Err(Error);
-        }
-
-        if phrase.split(' ').count() != WORD_COUNT {
-            return Err(Error);
-        }
-
-        Ok(Phrase {
-            string: phrase.into(),
-            language,
-        })
-    }
-
-    /// Create a new BIP39 mnemonic phrase from the given `KeyMaterial`
-    pub(crate) fn from_key_material(key_material: &KeyMaterial, language: Language) -> Self {
-        let mnemonic =
-            bip39::Mnemonic::from_entropy(key_material.as_bytes(), language.into()).unwrap();
-
-        Phrase {
-            string: mnemonic.into_phrase(),
-            language,
-        }
-    }
-
-    /// Borrow this mnemonic phrase as a string.
-    pub fn as_str(&self) -> &str {
-        self.string.as_ref()
-    }
-
-    /// Language this phrase's wordlist is for
-    pub fn language(&self) -> Language {
-        self.language
-    }
-}
-
-impl Drop for Phrase {
-    fn drop(&mut self) {
-        self.string.zeroize();
-    }
-}
+mod bits;
+mod language;
+mod phrase;
+mod seed;
 
-impl From<Phrase> for KeyMaterial {
-    fn from(phrase: Phrase) -> KeyMaterial {
-        let mnemonic =
-            bip39::Mnemonic::from_phrase(&phrase.string, phrase.language.into()).unwrap();
-        Self::from_bytes(mnemonic.entropy()).unwrap()
-    }
-}
+pub use self::{language::Language, phrase::Phrase, seed::Seed};

hkd32/src/mnemonic.rs

@@ -1,3 +1,10 @@
+//! Bit manipulation for BIP39 derivation
+//!
+//! Adapted from the `bip39` crate
+
+use alloc::{string::String, vec::Vec};
+use core::marker::PhantomData;
+
 pub(crate) trait IterExt: Iterator {
     fn join<R>(&mut self, glue: &str) -> R
     where
@@ -114,10 +121,6 @@ impl BitWriter {
         }
     }
 
-    pub fn len(&self) -> usize {
-        self.inner.len() * 8 + self.offset
-    }
-
     pub fn into_bytes(mut self) -> Vec<u8> {
         if self.offset != 0 {
             self.inner.push((self.remainder >> 24) as u8);
@@ -128,7 +131,7 @@ impl BitWriter {
 }
 
 pub(crate) struct BitIter<In: Bits, Out: Bits, I: Iterator<Item = In> + Sized> {
-    _phantom: ::std::marker::PhantomData<Out>,
+    _phantom: PhantomData<Out>,
     source: I,
     read: usize,
     buffer: u64,
@@ -144,7 +147,7 @@ where
         let source = source.into_iter();
 
         BitIter {
-            _phantom: ::std::marker::PhantomData,
+            _phantom: PhantomData,
             source,
             read: 0,
             buffer: 0,
@@ -169,7 +172,6 @@ where
         }
 
         let result = (self.buffer >> (64 - Out::SIZE)) as u16;
-
         self.buffer <<= Out::SIZE;
         self.read -= Out::SIZE;
 
@@ -185,10 +187,3 @@ where
         )
     }
 }
-
-/// Extract the first `bits` from the `source` byte
-pub(crate) fn checksum(source: u8, bits: u8) -> u8 {
-    debug_assert!(bits <= 8, "Can operate on 8-bit integers only");
-
-    source >> (8 - bits)
-}