test(kyberlib): ✅ new tests for wasm.rs

Author: sebastienrousseau

Cargo.lock

@@ -32,21 +32,17 @@ version = "0.0.4"
 [dependencies]
 aes = { version = "0.8.4", optional = true }
 ctr = { version = "0.9.2", optional = true }
+rand = { version = "0.8.5", default-features = false, features = ["getrandom"] }
 rand_core = { version = "0.6.4",  default-features = false }
 rlg = "0.0.4"
 sha2 = { version = "0.10.8", optional = true }
 tokio = { version = "1.37.0", optional = true }
-wasm-bindgen = { version = "0.2.92", optional = true }
+wasm-bindgen = "0.2.92"
 
 [dev-dependencies]
 criterion = "0.5.1"
 rand = "0.8.5"
-
-[dependencies.rand]
-version = "0.8.5"
-default-features = false
-features = ["getrandom"]
-optional = true
+wasm-bindgen-test = "0.3.42"
 
 # benchmarking = ["criterion"]
 

Cargo.toml

@@ -174,6 +174,9 @@ pub mod rng;
 /// Symmetric key encapsulation module for the KyberLib library.
 pub mod symmetric;
 
+/// WebAssembly bindings for the KyberLib library.
+pub mod wasm;
+
 pub use api::*;
 pub use error::KyberLibError;
 pub use kex::*;

src/lib.rs

@@ -7,6 +7,7 @@ extern crate alloc;
 use super::*;
 use crate::params::*;
 use alloc::boxed::Box;
+use rand::rngs::OsRng;
 use wasm_bindgen::prelude::*;
 
 /// Generate a key pair for Kyber encryption.
@@ -16,7 +17,7 @@ use wasm_bindgen::prelude::*;
 /// Returns a `JsError` if an error occurs during key pair generation.
 #[wasm_bindgen]
 pub fn keypair() -> Result<Keys, JsError> {
-    let mut rng = rand::rngs::OsRng {};
+    let mut rng = OsRng {};
     match api::keypair(&mut rng) {
         Ok(keys) => Ok(Keys {
             pubkey: Box::new(keys.public),
@@ -44,7 +45,7 @@ pub fn encapsulate(pk: Box<[u8]>) -> Result<Kex, JsValue> {
         return Err(JsValue::null());
     }
 
-    let mut rng = rand::rngs::OsRng {};
+    let mut rng = OsRng {};
     match api::encapsulate(&pk, &mut rng) {
         Ok(kex) => Ok(Kex {
             ciphertext: Box::new(kex.0),

src/wasm.rs

@@ -0,0 +1,59 @@
+// Copyright © 2023 kyberlib. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+#[cfg(test)]
+mod tests {
+
+    use kyberlib::wasm::Kex;
+    use kyberlib::{decapsulate, encapsulate, keypair, params::*};
+    use wasm_bindgen_test::*;
+
+    wasm_bindgen_test_configure!(run_in_browser);
+
+    #[wasm_bindgen_test]
+    fn test_keypair() {
+        let mut rng = rand::rngs::OsRng {};
+        let result = keypair(&mut rng);
+        assert!(result.is_ok());
+    }
+
+    #[wasm_bindgen_test]
+    fn test_encapsulate() {
+        let mut rng = rand::rngs::OsRng {};
+        let pk = vec![0u8; KYBER_PUBLIC_KEY_BYTES].into_boxed_slice();
+        let result = encapsulate(&pk, &mut rng);
+        assert!(result.is_err()); // Invalid input sizes
+
+        let keypair_result = keypair(&mut rng);
+        assert!(keypair_result.is_ok());
+
+        let result = encapsulate(&pk, &mut rng);
+        assert!(result.is_ok());
+    }
+
+    #[wasm_bindgen_test]
+    fn test_decapsulate() {
+        let ct = vec![0u8; KYBER_CIPHERTEXT_BYTES].into_boxed_slice();
+        let sk = vec![0u8; KYBER_SECRET_KEY_BYTES].into_boxed_slice();
+        let result = decapsulate(&ct, &sk);
+        assert!(result.is_err()); // Invalid input sizes
+
+        let keypair_result = keypair(&mut rand::rngs::OsRng {});
+        assert!(keypair_result.is_ok());
+
+        let keys = keypair_result.unwrap();
+        let result = encapsulate(&keys.public, &mut rand::rngs::OsRng {});
+        assert!(result.is_ok());
+
+        let result = decapsulate(&ct, &keys.secret);
+        assert!(result.is_ok());
+    }
+
+    #[wasm_bindgen_test]
+    fn test_kex_new() {
+        let pk = vec![0u8; KYBER_PUBLIC_KEY_BYTES].into_boxed_slice();
+        let result = Kex::new(pk);
+        assert!(result.ciphertext().len() == KYBER_CIPHERTEXT_BYTES);
+        assert!(result.sharedSecret().len() == KYBER_SHARED_SECRET_BYTES);
+    }
+}