ursa 0.3.7

This is the shared crypto library for Hyperledger components.
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

use aead::{generic_array::typenum::Unsigned, NewAead};
use encryption::random_vec;
use encryption::symm::prelude::*;
use serde::{Deserialize, Serialize};
use std::str::FromStr;
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
#[derive(Debug, Serialize, Deserialize)]
pub struct WasmCipherKey {
    cipher: EncryptorType,
    key: String,
}

macro_rules! operation_impl {
    ($name:ident) => {
        fn $name(cipher_key: WasmCipherKey, aad: &[u8], input: &[u8]) -> Result<Vec<u8>, JsValue> {
            let symmkey = maperr!(hex::decode(cipher_key.key));
            if !cipher_key.cipher.is_valid_keysize(symmkey.len()) {
                return Err(JsValue::from_str("Invalid key length"));
            }
            let encryptor = cipher_key.cipher.gen_encryptor(symmkey.as_slice());
            Ok(maperr!(encryptor.$name(aad, input)))
        }
    };
}

#[wasm_bindgen]
pub struct UrsaEncryptor {}

#[wasm_bindgen]
impl UrsaEncryptor {
    pub fn new(cipher: &str) -> Result<WasmCipherKey, JsValue> {
        let cipher = maperr!(EncryptorType::from_str(cipher));
        let key_size = get_keysize(cipher);

        Ok(WasmCipherKey {
            cipher,
            key: hex::encode(&maperr!(random_vec(key_size))),
        })
    }

    pub fn with_key(cipher: &str, key: &str) -> Result<WasmCipherKey, JsValue> {
        let cipher = maperr!(EncryptorType::from_str(cipher));
        let key_size = get_keysize(cipher);
        if key_size == maperr!(hex::decode(key)).len() {
            Ok(WasmCipherKey {
                cipher,
                key: key.to_string(),
            })
        } else {
            Err(JsValue::from_str("Invalid key length for given cipher"))
        }
    }

    pub fn encrypt(
        &self,
        cipher_key: WasmCipherKey,
        aad: &[u8],
        input: &[u8],
    ) -> Result<Vec<u8>, JsValue> {
        encrypt_easy(cipher_key, aad, input)
    }

    pub fn decrypt(
        &self,
        cipher_key: WasmCipherKey,
        aad: &[u8],
        input: &[u8],
    ) -> Result<Vec<u8>, JsValue> {
        decrypt_easy(cipher_key, aad, input)
    }
}

fn get_keysize(cipher: EncryptorType) -> usize {
    match cipher {
        EncryptorType::Aes128CbcHmac256 => {
            <<Aes128CbcHmac256 as NewAead>::KeySize as Unsigned>::to_usize()
        }
        EncryptorType::Aes256CbcHmac512 => {
            <<Aes256CbcHmac512 as NewAead>::KeySize as Unsigned>::to_usize()
        }
        EncryptorType::Aes128Gcm => <<Aes128Gcm as NewAead>::KeySize as Unsigned>::to_usize(),
        EncryptorType::Aes256Gcm => <<Aes256Gcm as NewAead>::KeySize as Unsigned>::to_usize(),
        EncryptorType::XChaCha20Poly1305 => {
            <<XChaCha20Poly1305 as NewAead>::KeySize as Unsigned>::to_usize()
        }
    }
}

operation_impl!(encrypt_easy);
operation_impl!(decrypt_easy);