rgp-web 0.3.3

WebAssembly bindings for the RGP crate.
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

#![doc = include_str!("../README.md")]

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub struct FingerprintResult {
    fingerprint: Vec<u8>,
    verifier: Vec<u8>,
}

#[wasm_bindgen]
impl FingerprintResult {
    #[wasm_bindgen(getter)]
    pub fn fingerprint(&self) -> Vec<u8> {
        self.fingerprint.clone()
    }
    #[wasm_bindgen(getter)]
    pub fn verifier(&self) -> Vec<u8> {
        self.verifier.clone()
    }
}

#[wasm_bindgen]
pub fn generate_fingerprint() -> FingerprintResult {
    let (fingerprint, verifier) = rgp::generate_fingerprint();

    FingerprintResult {
        fingerprint: fingerprint.into(),
        verifier: verifier.into(),
    }
}

#[wasm_bindgen]
pub struct DhKeysResult {
    private: Vec<u8>,
    public: Vec<u8>,
}

#[wasm_bindgen]
impl DhKeysResult {
    #[wasm_bindgen(getter)]
    pub fn private(&self) -> Vec<u8> {
        self.private.clone()
    }
    #[wasm_bindgen(getter)]
    pub fn public(&self) -> Vec<u8> {
        self.public.clone()
    }
}

#[wasm_bindgen]
pub fn generate_dh_keys() -> DhKeysResult {
    let (private, public) = rgp::generate_dh_keys();

    DhKeysResult {
        private: private.into(),
        public: public.into(),
    }
}

#[wasm_bindgen]
pub fn encrypt_dh(
    fingerprint: Vec<u8>,
    content: Vec<u8>,
    private_key: Vec<u8>,
    public_keys: Vec<u8>,
) -> Result<Vec<u8>, String> {
    let fixed_fingerprint: [u8; 32] = match fingerprint.try_into() {
        Ok(f) => f,
        Err(_) => return Err("failed to convert fingerprint to 32 len array".into()),
    };

    let fixed_private_key: [u8; 32] = match private_key.try_into() {
        Ok(f) => f,
        Err(_) => return Err("failed to convert private_key to 32 len array".into()),
    };

    let mut fixed_public_keys = vec![];

    for public_key in public_keys.chunks_exact(32) {
        let fixed_public_key: [u8; 32] = match public_key.try_into() {
            Ok(f) => f,
            Err(_) => return Err("failed to convert public_key to 32 len array".into()),
        };

        fixed_public_keys.push(fixed_public_key);
    }

    let encrypted_content = match rgp::encrypt(
        fixed_fingerprint,
        content.clone(),
        rgp::Encrypt::Dh(fixed_private_key, &fixed_public_keys, None),
    ) {
        Ok((encrypted_content, _)) => encrypted_content,
        Err(err) => return Ok(err.into()),
    };

    Ok(encrypted_content)
}

#[wasm_bindgen]
pub fn decrypt_dh(
    position: usize,
    mut encrypted_content: Vec<u8>,
    verifier: Vec<u8>,
    public_key: Vec<u8>,
    private_key: Vec<u8>,
) -> Result<Vec<u8>, String> {
    let fixed_verifier: [u8; 32] = match verifier.try_into() {
        Ok(f) => f,
        Err(_) => return Err("failed to convert verifier to 32 len array".into()),
    };

    let fixed_public_key: [u8; 32] = match public_key.try_into() {
        Ok(f) => f,
        Err(_) => return Err("failed to convert public_key to 32 len array".into()),
    };

    let fixed_private_key: [u8; 32] = match private_key.try_into() {
        Ok(f) => f,
        Err(_) => return Err("failed to convert private_key to 32 len array".into()),
    };

    if let rgp::Components::Dh(encrypted_key, _) =
        rgp::extract_components_mut(position, &mut encrypted_content)
    {
        // decrypt message with encrypted content key
        let decrypted_content = match rgp::decrypt(
            Some(&fixed_verifier),
            &encrypted_content,
            rgp::Decrypt::Dh(encrypted_key, fixed_public_key, fixed_private_key, None),
        ) {
            Ok((decrypted_content, _)) => decrypted_content,
            Err(err) => return Err(err.into()),
        };

        return Ok(decrypted_content);
    }

    Err("not DH encryption type".into())
}

#[test]
fn test() -> Result<(), String> {
    let fp_res = generate_fingerprint();

    let rx_dh_keys = generate_dh_keys();
    let tx_dh_keys = generate_dh_keys();

    let content = vec![1, 2, 3, 4, 5];

    let encrypted = encrypt_dh(
        fp_res.fingerprint,
        content.clone(),
        tx_dh_keys.private,
        rx_dh_keys.public,
    )?;

    let decrypted = decrypt_dh(
        0,
        encrypted,
        fp_res.verifier,
        tx_dh_keys.public,
        rx_dh_keys.private,
    )?;

    assert_eq!(content, decrypted);

    Ok(())
}