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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

#[macro_use]
mod macros;
#[cfg(feature = "bls_bn254")]
pub mod bls;

#[cfg(feature = "ed25519")]
pub mod ed25519;
#[cfg(feature = "encryption")]
pub mod encryption;
#[cfg(feature = "ecdsa_secp256k1")]
pub mod secp256k1;
#[cfg(feature = "x25519")]
pub mod x25519;

use keys::{PrivateKey, PublicKey, SessionKey};

use errors::{UrsaCryptoError, UrsaCryptoErrorKind};
use serde::{Deserialize, Serialize};
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
#[derive(Debug, Serialize, Deserialize)]
pub struct WasmPrivateKey(String);
#[wasm_bindgen]
#[derive(Debug, Serialize, Deserialize)]
pub struct WasmPublicKey(String);

#[wasm_bindgen]
#[derive(Debug, Serialize, Deserialize)]
pub struct WasmSessionKey(String);

#[wasm_bindgen]
#[derive(Debug, Serialize, Deserialize)]
pub struct KeyPair {
    pk: WasmPublicKey,
    sk: WasmPrivateKey,
}

impl From<&PublicKey> for WasmPublicKey {
    fn from(pk: &PublicKey) -> WasmPublicKey {
        WasmPublicKey(hex::encode(&pk[..]))
    }
}

impl From<PublicKey> for WasmPublicKey {
    fn from(pk: PublicKey) -> WasmPublicKey {
        WasmPublicKey(hex::encode(&pk[..]))
    }
}

impl From<Vec<u8>> for WasmPublicKey {
    fn from(value: Vec<u8>) -> WasmPublicKey {
        WasmPublicKey(hex::encode(value.as_slice()))
    }
}

impl From<&WasmPublicKey> for PublicKey {
    fn from(pk: &WasmPublicKey) -> PublicKey {
        PublicKey(hex::decode(&pk.0).unwrap().to_vec())
    }
}
impl From<WasmPublicKey> for PublicKey {
    fn from(pk: WasmPublicKey) -> PublicKey {
        PublicKey(hex::decode(&pk.0).unwrap().to_vec())
    }
}

impl From<&PrivateKey> for WasmPrivateKey {
    fn from(sk: &PrivateKey) -> WasmPrivateKey {
        WasmPrivateKey(hex::encode(&sk[..]))
    }
}

impl From<PrivateKey> for WasmPrivateKey {
    fn from(sk: PrivateKey) -> WasmPrivateKey {
        WasmPrivateKey(hex::encode(&sk[..]))
    }
}

impl From<&WasmPrivateKey> for PrivateKey {
    fn from(pk: &WasmPrivateKey) -> PrivateKey {
        PrivateKey(hex::decode(&pk.0).unwrap().to_vec())
    }
}

impl From<WasmPrivateKey> for PrivateKey {
    fn from(pk: WasmPrivateKey) -> PrivateKey {
        PrivateKey(hex::decode(&pk.0).unwrap().to_vec())
    }
}

impl From<SessionKey> for WasmSessionKey {
    fn from(secret: SessionKey) -> WasmSessionKey {
        WasmSessionKey(hex::encode(&secret[..]))
    }
}

impl From<UrsaCryptoError> for JsValue {
    fn from(err: UrsaCryptoError) -> JsValue {
        let error = format!("{:?}", err);
        JsValue::from_serde(&error).unwrap()
    }
}

fn convert_from_js<T>(val: &JsValue) -> Result<T, UrsaCryptoError>
where
    for<'a> T: serde::Deserialize<'a>,
{
    match val.into_serde() {
        Ok(unwrapped) => Ok(unwrapped),
        Err(_) => Err(UrsaCryptoError::from_msg(
            UrsaCryptoErrorKind::InvalidStructure,
            "Invalid argument".to_string(),
        )),
    }
}