libslug 0.9.1

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

//! # BIP32: Key Derivation
//! 
//! This module includes Key Derivation from Bitcoin's Improvement Proposals's 32th proposal.

use bip32::{XPrv, Seed};
use bip32::PrivateKey;
use bip32::PublicKey;
use bip32::Error;
use serde::{Serialize,Deserialize};
use zeroize::{Zeroize,ZeroizeOnDrop};
use std::str::FromStr;

use fixedstr::str32;

use rand::rngs::OsRng;

use crate::errors::SlugErrors;

/// BIP32 Traits
pub mod traits;

/// # Key-Deriviation (BIP32)
/// 
/// ## Seed
/// 
/// - [ ] Generate from OSCSPRNG
/// - [ ] Generate from Mnemonic
pub struct KeyDeriviationAPI;

#[derive(Clone,Copy,PartialEq,PartialOrd,Hash,Serialize,Deserialize)]
pub struct MasterKey {
    pub mnemonic: MnemonicKeys,
}

impl MasterKey {
    pub fn from_str_whitespace<T: AsRef<str>>(s: T) -> Self {
        Self {
            mnemonic: MnemonicKeys::from_str_whitespace(s).unwrap()
        }
    }
}

/// # Mnemonic Keys (BIP32)
/// 
/// **Warning:** No Zeroize-Support
/// 
/// Uses a fixedstr of 32 bytes per word.
/// 
/// ## Word Lengths
/// 
/// - [X] 12 words
/// - [X] 16 words
/// - [X] 18 words
/// - [X] 24 words
#[derive(Clone,Copy,PartialEq,PartialOrd,Hash,Debug,Serialize,Deserialize)]
pub enum MnemonicKeys {
    _12words([str32;12]),
    _16words([str32;16]),
    _18words([str32;18]),
    _24words([str32;24]),
}

impl MnemonicKeys {
    pub fn new() {

    }
    pub fn from_str_whitespace<T: AsRef<str>>(s: T) -> Result<Self,SlugErrors> {
        let x: Vec<&str> = s.as_ref().split(" ").collect();

        match x.len() {
            12usize => {
                let mut output: [str32;12] = [str32::new();12];
                let mut i: usize = 0;

                for piece in x {
                    let value = str32::from_str(piece).unwrap();
                    output[i] = value;
                    i = i + 1;
                }
                return Ok(MnemonicKeys::_12words(output))
            }
            16usize => {
                let mut output: [str32;16] = [str32::new();16];
                let mut i: usize = 0;

                for piece in x {
                    let value = str32::from_str(piece).unwrap();
                    output[i] = value;
                    i = i + 1;
                }
                return Ok(MnemonicKeys::_16words(output))
            }
            18usize => {
                let mut output: [str32;18] = [str32::new();18];
                let mut i: usize = 0;

                for piece in x {
                    let value = str32::from_str(piece).unwrap();
                    output[i] = value;
                    i = i + 1;
                }
                return Ok(MnemonicKeys::_18words(output))
            }
            24usize => {
                let mut output: [str32;24] = [str32::new();24];
                let mut i: usize = 0;

                for piece in x {
                    let value = str32::from_str(piece).unwrap();
                    output[i] = value;
                    i = i + 1;
                }
                return Ok(MnemonicKeys::_24words(output))
            }
            _ => {
                return Err(SlugErrors::Other(String::from("Cannot convert BIP32 from string")))
            }

        }
    }
}