rsa_keygen 0.1.0

A library for generating rsa keys with a 12 word seedphrase
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

use arrayref::array_ref;
use bip39::{Language, Mnemonic, MnemonicType, Seed};
use rand::SeedableRng;
use rand_chacha::ChaCha20Rng;
use rsa::{
    pkcs1::{EncodeRsaPrivateKey, EncodeRsaPublicKey},
    RsaPrivateKey, RsaPublicKey,
};
use std::fs;

/// Keypair is a structure that holds a privatekey and a public key.
pub struct KeyPair {
    pub priv_key: RsaPrivateKey,
    pub pub_key: RsaPublicKey,
}

/// Keygen is used to generate a seedphrase and an RSA keypair
pub struct Keygen {}

impl Keygen {
    /// generates a 12 word seedphrase
    ///
    /// # Examples
    /// ```
    /// let seedphrase = Keygen::generate_seedphrase();
    /// ```
    pub fn generate_seedphrase() -> String {
        // create a new randomly generated mnemonic phrase
        let mnemonic = Mnemonic::new(MnemonicType::Words12, Language::English);
        let phrase = mnemonic.phrase().to_owned();
        phrase
    }

    /// generates an RSA keypair (private key, public key) with an already known seedphrase
    ///
    /// # Examples
    /// ```
    /// let seedphrase = Keygen::generate_seedphrase();
    /// let keypair = Keygen::generate_rsa_keypair(seedphrase);
    /// ```
    pub fn generate_rsa_keypair(seedphrase: &String) -> Result<KeyPair, String> {
        let mnemonic = Mnemonic::from_phrase(seedphrase.as_str(), Language::English).unwrap();
        let seed = Seed::new(&mnemonic, "");
        let seed_array = array_ref!(seed.as_bytes(), 0, 32);
        let mut rng = ChaCha20Rng::from_seed(*seed_array);

        let priv_key = match RsaPrivateKey::new(&mut rng, 2048) {
            Ok(x) => x,
            Err(e) => return Err(e.to_string()),
        };
        let pub_key = RsaPublicKey::from(&priv_key);

        Ok(KeyPair { priv_key, pub_key })
    }

    /// generate a seed phrase and a RSA keypair,
    /// seedphrase is stored in seedphrase.txt
    /// public key is stored in pubkey.txt
    ///
    /// # Examples
    /// ```
    /// let (seedphrase, keypair) = Keygen::generate_seedphrase_and rsa_keypair();
    /// ```
    pub fn generate_seedphrase_and_rsa_keypair() -> Result<(String, KeyPair), String> {
        let seedphrase = Keygen::generate_seedphrase();

        let keypair = match Keygen::generate_rsa_keypair(&seedphrase) {
            Ok(x) => x,
            Err(e) => return Err(e),
        };

        Ok((seedphrase, keypair))
    }

    /// exports private key to PEM (Privacy Enhanced Mail) format
    ///
    /// # Examples
    /// ```
    /// let (seedphrase, keypair) = Keygen::generate_seedphrase_and rsa_keypair();
    /// Keygen::export_privatekey_to_pem(keypair.priv_key);
    /// ```
    pub fn export_private_key_to_pem(priv_key: &RsaPrivateKey) -> Result<String, String> {
        match priv_key.to_pkcs1_pem(Default::default()) {
            Ok(x) => Ok((*x).clone()),
            Err(e) => Err(e.to_string()),
        }
    }

    /// exports public key to PEM (Privacy Enhanced Mail) format
    ///  
    /// # Examples
    /// ```
    /// let (seedphrase, keypair) = Keygen::generate_seedphrase_and rsa_keypair();
    /// Keygen::export_privatekey_to_pem(keypair.priv_key);
    /// ```
    pub fn export_public_key_to_pem(pub_key: &RsaPublicKey) -> Result<String, String> {
        match pub_key.to_pkcs1_pem(Default::default()) {
            Ok(x) => Ok(x),
            Err(e) => Err(e.to_string()),
        }
    }

    /// stores a seedphrase and keypair in a file with name filename.txt
    ///
    /// #Example
    /// ```
    /// let (seedphrase, keypair) = Keygen::generate_seedphrase_and_rsa_keypair().unwrap();
    /// Keygen::store_in_file(keypair, &seedphrase, "id")
    /// ```
    pub fn store_in_file(keypair: KeyPair, seedphrase: &String, filename: &str) {
        let priv_key_pem = Keygen::export_private_key_to_pem(&keypair.priv_key).unwrap();
        let pub_key_pem = Keygen::export_public_key_to_pem(&keypair.pub_key).unwrap();

        let data = format!(
            "Seedphrase: {}\nPrivate Key: {}\nPublic Key: {}",
            seedphrase, priv_key_pem, pub_key_pem
        );

        fs::write(filename, data).expect("failed to write to file");
    }
}

#[test]
fn generate_seedphrase_has_12_words() {
    let seedphrase = Keygen::generate_seedphrase();
    let words: Vec<&str> = seedphrase.split(" ").collect();

    assert_eq!(words.len(), 12);
}

#[test]
fn generate_keypair_returns_same_pub_key() {
    let seedphrase = Keygen::generate_seedphrase();
    let keypair = Keygen::generate_rsa_keypair(&seedphrase).unwrap();
    let keypair2 = Keygen::generate_rsa_keypair(&seedphrase).unwrap();

    assert_eq!(keypair.pub_key, keypair2.pub_key);
}