libslug 0.12.0

A Rust Library For Cryptography Intended For Slug20 That Supports X59 Certificate Format and Post-Quantum Cryptography
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! # BIP39
//! 
//! This module contains all required operations and functionality to use **BIP39**, a word generator that uses a seed to produce the secret key of certain algorithms.
//! 
//! ## Features
//! 
//! - [X] `SlugMnemonic``
//!     - [X] `fn New()`: Generates a new Mnemonic
//!     - [X] `fn from_phrase()`: Constructs SlugMnemonic struct from phrase and wordlist
//!     - [X] `fn to_mnemonic()`: Converts to bip39::Mnemonic
//!     - [X] `fn to_seed()`: Takes a password and wordlist then converts to seed (Vec<u8>)
//! 
//! ## TODO
//! 
//! - [ ] Number of Words
//! - [ ] Parsing

use bip39::{Mnemonic, MnemonicType, Language, Seed,ErrorKind};
use serde::{Serialize,Deserialize};
use rand_core::CryptoRng;
use rand_core::TryRng;

use zeroize::{Zeroize,ZeroizeOnDrop};

/// BIP39 Mnemonic Phrases: Traits
pub mod traits;

/// # SlugMnemonic
/// 
/// The default SlugMnemonic using `BIP39`.
/// 
/// ## Features
/// 
/// - [X] Number of Words
///     - [X] 12
///     - [X] 15
///     - [X] 18
///     - [X] 21
///     - [X] 24
/// - [X] Language
///     - [X] English
///     - [X] ChineseSimplified
///     - [X] ChineseTraditional
///     - [X] French
///     - [X] Italian
///     - [X] Japanese
///     - [X] Korean
///     - [X] Spanish
#[derive(Serialize,Deserialize,Zeroize,ZeroizeOnDrop,Clone, PartialEq, PartialOrd)]
pub struct SlugMnemonic {
    pub phrase: String,
    pub language: SlugBIP39Languages,
}

#[derive(Serialize,Deserialize,Zeroize,ZeroizeOnDrop,Clone,PartialEq,PartialOrd)]
pub enum SlugBIP39Languages {
    English,
    ChineseSimplified,
    ChineseTraditional,
    French,
    Italian,
    Japanese,
    Korean,
    Spanish,
}

#[derive(Serialize,Deserialize,Zeroize,ZeroizeOnDrop,Clone,PartialEq,PartialOrd)]
pub enum SlugBIP39Words {
    Words12,
    Words15,
    Words18,
    Words21,
    Words24,
}

impl SlugBIP39Languages {
    /// # Get Language
    /// 
    /// Returns Expected Language
    pub fn get_language(&self) -> Language {
        match self {
            SlugBIP39Languages::English => return Language::English,
            SlugBIP39Languages::ChineseSimplified => return Language::ChineseSimplified,
            SlugBIP39Languages::ChineseTraditional => return Language::ChineseTraditional,
            SlugBIP39Languages::French => return Language::French,
            SlugBIP39Languages::Italian => return Language::Italian,
            SlugBIP39Languages::Japanese => return Language::Japanese,
            SlugBIP39Languages::Korean => return Language::Korean,
            SlugBIP39Languages::Spanish => return Language::Spanish,
        }
    }
}

impl SlugBIP39Words {
    pub fn get_words(&self) -> MnemonicType {
        match &self {
            Self::Words12 => return MnemonicType::Words12,
            Self::Words15 => return MnemonicType::Words15,
            Self::Words18 => return MnemonicType::Words18,
            Self::Words21 => return MnemonicType::Words21,
            Self::Words24 => return MnemonicType::Words24,
        }
    }
}

impl SlugMnemonic {
    /// # New Mnemonic Phrase
    /// 
    /// Generate a new Mnemonic using a certain language and length.
    pub fn new(mnemonic_type: SlugBIP39Words, language: SlugBIP39Languages) -> Self {
        let phrase = Mnemonic::new(mnemonic_type.get_words(), language.get_language()).into_phrase();

        return Self {
            phrase: phrase,
            language: language,
        }
    }
    /// # From Phrase
    pub fn from_phrase<T: AsRef<str>>(phrase: T, language: SlugBIP39Languages) -> Result<Self,ErrorKind> {
        let phrase = Mnemonic::from_phrase(phrase.as_ref(), language.get_language())?.into_phrase();

        return Ok(Self {
            phrase: phrase,
            language: language,
        })
    }
    /// To Mnemonic
    pub fn to_mnemonic(&self) -> Result<Mnemonic,ErrorKind> {
        let mnemonic = Mnemonic::from_phrase(&self.phrase, self.language.get_language())?;

        return Ok(mnemonic)
    }
    /// # BIP39 Into Seed
    /// 
    /// Converts To Seed Using a Password
    pub fn to_seed<T: AsRef<str>>(&self, pass: T) -> Result<Vec<u8>,ErrorKind> {
        let mnemonic = self.to_mnemonic()?;
        let seed = Seed::new(&mnemonic, pass.as_ref());
        return Ok(seed.as_bytes().to_vec())
    }
    pub fn entropy(&self) -> Result<Vec<u8>,ErrorKind> {
        let x = &self.to_mnemonic()?;
        let entropy = x.entropy();
        Ok(entropy.to_vec())
    }
}