wasi-crypto 0.1.10

Experimental implementation of the WASI cryptography APIs
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

mod dh;
mod kem;
mod keypair;
mod publickey;
mod secretkey;

use std::any::Any;
use std::convert::TryFrom;
use std::sync::{Arc, Mutex};

pub use keypair::*;
pub use publickey::*;
pub use secretkey::*;

use self::dh::*;
use self::kem::*;
use crate::array_output::*;
use crate::error::*;
use crate::handles::*;
use crate::options::*;

#[derive(Debug, Default)]
pub struct KxOptionsInner {
    context: Option<Vec<u8>>,
}

#[derive(Clone, Debug, Default)]
pub struct KxOptions {
    inner: Arc<Mutex<KxOptionsInner>>,
}

impl OptionsLike for KxOptions {
    fn as_any(&self) -> &dyn Any {
        self
    }

    fn set(&mut self, _name: &str, _value: &[u8]) -> Result<(), CryptoError> {
        bail!(CryptoError::UnsupportedOption)
    }

    fn set_u64(&mut self, _name: &str, _value: u64) -> Result<(), CryptoError> {
        bail!(CryptoError::UnsupportedOption)
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum KxAlgorithm {
    X25519,
    Kyber768,
    Kyber1024,
}

impl TryFrom<&str> for KxAlgorithm {
    type Error = CryptoError;

    fn try_from(alg_str: &str) -> Result<Self, CryptoError> {
        match alg_str.to_uppercase().as_str() {
            "X25519" => Ok(KxAlgorithm::X25519),
            "KYBER-768" => Ok(KxAlgorithm::Kyber768),
            "KYBER-1024" => Ok(KxAlgorithm::Kyber1024),
            _ => bail!(CryptoError::UnsupportedAlgorithm),
        }
    }
}

#[test]
fn test_key_exchange() {
    use crate::{AlgorithmType, CryptoCtx, KeyPairEncoding};

    let ctx = CryptoCtx::new();

    let kx_kp_handle1 = ctx
        .keypair_generate(AlgorithmType::KeyExchange, "X25519", None)
        .unwrap();
    let kx_kp_raw_bytes_handle = ctx
        .keypair_export(kx_kp_handle1, KeyPairEncoding::Raw)
        .unwrap();
    let mut kx_kp_raw_bytes = vec![0u8; ctx.array_output_len(kx_kp_raw_bytes_handle).unwrap()];
    ctx.array_output_pull(kx_kp_raw_bytes_handle, &mut kx_kp_raw_bytes)
        .unwrap();

    let pk1 = ctx.keypair_publickey(kx_kp_handle1).unwrap();
    let sk1 = ctx.keypair_secretkey(kx_kp_handle1).unwrap();

    let kx_kp_handle2 = ctx
        .keypair_generate(AlgorithmType::KeyExchange, "X25519", None)
        .unwrap();
    let pk2 = ctx.keypair_publickey(kx_kp_handle2).unwrap();
    let sk2 = ctx.keypair_secretkey(kx_kp_handle2).unwrap();

    let shared_key1_handle = ctx.kx_dh(pk1, sk2).unwrap();
    let mut shared_key1_raw_bytes = vec![0u8; ctx.array_output_len(shared_key1_handle).unwrap()];
    ctx.array_output_pull(shared_key1_handle, &mut shared_key1_raw_bytes)
        .unwrap();

    let shared_key2_handle = ctx.kx_dh(pk2, sk1).unwrap();
    let mut shared_key2_raw_bytes = vec![0u8; ctx.array_output_len(shared_key2_handle).unwrap()];
    ctx.array_output_pull(shared_key2_handle, &mut shared_key2_raw_bytes)
        .unwrap();

    assert_eq!(shared_key1_raw_bytes, shared_key2_raw_bytes);

    ctx.keypair_close(kx_kp_handle1).unwrap();
    ctx.keypair_close(kx_kp_handle2).unwrap();
}

#[cfg(feature = "pqcrypto")]
#[test]
fn test_key_encapsulation() {
    use crate::{AlgorithmType, CryptoCtx, KeyPairEncoding};

    let ctx = CryptoCtx::new();

    let kx_kp_handle = ctx
        .keypair_generate(AlgorithmType::KeyExchange, "Kyber-1024", None)
        .unwrap();
    let pk = ctx.keypair_publickey(kx_kp_handle).unwrap();
    let sk = ctx.keypair_secretkey(kx_kp_handle).unwrap();

    let (secret_handle, encapsulated_secret_handle) = ctx.kx_encapsulate(pk).unwrap();
    let mut secret_raw_bytes = vec![0u8; ctx.array_output_len(secret_handle).unwrap()];
    ctx.array_output_pull(secret_handle, &mut secret_raw_bytes)
        .unwrap();
    let mut encapsulated_secret_raw_bytes =
        vec![0u8; ctx.array_output_len(encapsulated_secret_handle).unwrap()];
    ctx.array_output_pull(
        encapsulated_secret_handle,
        &mut encapsulated_secret_raw_bytes,
    )
    .unwrap();

    let decapsulated_secret_handle = ctx
        .kx_decapsulate(sk, &encapsulated_secret_raw_bytes)
        .unwrap();
    let mut decapsulated_secret_raw_bytes =
        vec![0u8; ctx.array_output_len(decapsulated_secret_handle).unwrap()];
    ctx.array_output_pull(
        decapsulated_secret_handle,
        &mut decapsulated_secret_raw_bytes,
    )
    .unwrap();

    assert_eq!(secret_raw_bytes, decapsulated_secret_raw_bytes);
}