use wasm_bindgen(getter_with_clone)

Author: jbr

src/ciphertext.rs

@@ -1,47 +1,18 @@
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::prelude::*;
 
-cfg_if::cfg_if! {
-    if #[cfg(target_arch = "wasm32")] {
-        /**
-        a simple struct to return the combined encapsulated key
-        and ciphertext from seal
-        */
-        #[wasm_bindgen]
-        #[derive(Debug, Clone, PartialEq, Eq)]
-        pub struct EncappedKeyAndCiphertext {
-            pub(crate) encapped_key: Vec<u8>,
-            pub(crate) ciphertext: Vec<u8>
-        }
+/**
+a simple struct to return the combined encapsulated key
+and ciphertext from seal
+*/
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen(getter_with_clone))]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct EncappedKeyAndCiphertext {
+    /// the encapsulated encryption key
+    pub encapped_key: Vec<u8>,
 
-        #[wasm_bindgen]
-        impl EncappedKeyAndCiphertext {
-            /// getter for encapped_key
-            #[wasm_bindgen(getter)]
-            pub fn encapped_key(&self) -> Vec<u8> {
-                self.encapped_key.clone()
-            }
-
-            /// getter for ciphertext
-            #[wasm_bindgen(getter)]
-            pub fn ciphertext(&self) -> Vec<u8> {
-                self.ciphertext.clone()
-            }
-        }
-
-    } else {
-        /**
-        a simple open struct to return the combined encapsulated key
-        and ciphertext from seal
-        */
-        #[derive(Debug, Clone, PartialEq, Eq)]
-        pub struct EncappedKeyAndCiphertext {
-            /// the encapsulated encryption key
-            pub encapped_key: Vec<u8>,
-            /// the ciphertext, encrypted with the encapsulated key
-            pub ciphertext: Vec<u8>
-        }
-    }
+    /// the ciphertext, encrypted with the key
+    pub ciphertext: Vec<u8>,
 }
 
 impl EncappedKeyAndCiphertext {

src/keypair.rs

@@ -4,47 +4,25 @@ use wasm_bindgen::prelude::*;
 use crate::Kem;
 use hpke::Serializable;
 
-cfg_if::cfg_if! {
-    if #[cfg(target_arch = "wasm32")] {
-        /// An encoded keypair
-        #[derive(Debug, Clone, Eq, PartialEq)]
-        #[wasm_bindgen]
-        pub struct Keypair {
-            public_key: Vec<u8>,
-            private_key: Vec<u8>,
-        }
-    } else {
-        /// An encoded keypair
-        #[derive(Debug, Clone, Eq, PartialEq, zeroize::Zeroize)]
-        pub struct Keypair {
-            /// the public key for this keypair
-            pub public_key: Vec<u8>,
-            /// the private key for this keypair,
-            pub private_key: Vec<u8>,
-        }
-    }
+/// An encoded keypair
+#[derive(Debug, Clone, Eq, PartialEq, zeroize::Zeroize)]
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen(getter_with_clone))]
+pub struct Keypair {
+    /// the public key for this keypair
+    pub public_key: Vec<u8>,
+
+    /// the private key for this keypair,
+    pub private_key: Vec<u8>,
 }
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
 impl Keypair {
     /// generate a keypair from a [`Kem`]
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen(constructor))]
     #[must_use]
-    pub fn generate(kem: Kem) -> Keypair {
+    pub fn new(kem: Kem) -> Keypair {
         gen_keypair(kem)
     }
-
-    /// getter for `public_key`
-    #[cfg_attr(target_arch = "wasm32", wasm_bindgen(getter))]
-    pub fn public_key(&self) -> Vec<u8> {
-        self.public_key.clone()
-    }
-
-    /// getter for `private_key`
-    #[cfg_attr(target_arch = "wasm32", wasm_bindgen(getter))]
-    pub fn private_key(&self) -> Vec<u8> {
-        self.private_key.clone()
-    }
 }
 
 impl Keypair {
@@ -58,16 +36,6 @@ impl Keypair {
 /// generate a Keypair for the provided asymmetric key encapsulation mechanism ([`Kem`])
 #[must_use]
 pub fn gen_keypair(kem: Kem) -> Keypair {
-    fn gen_kp<KemT: hpke::kem::Kem>() -> Keypair {
-        let (private_key, public_key) = KemT::gen_keypair(&mut rand::thread_rng());
-        let public_key = public_key.to_bytes().to_vec();
-        let private_key = private_key.to_bytes().to_vec();
-        Keypair {
-            public_key,
-            private_key,
-        }
-    }
-
     match kem {
         #[cfg(feature = "kem-dh-p256-hkdf-sha256")]
         Kem::DhP256HkdfSha256 => gen_kp::<hpke::kem::DhP256HkdfSha256>(),
@@ -76,3 +44,14 @@ pub fn gen_keypair(kem: Kem) -> Keypair {
         Kem::X25519HkdfSha256 => gen_kp::<hpke::kem::X25519HkdfSha256>(),
     }
 }
+
+fn gen_kp<KemT: hpke::kem::Kem>() -> Keypair {
+    let (private_key, public_key) = KemT::gen_keypair(&mut rand::thread_rng());
+    let public_key = public_key.to_bytes().to_vec();
+    let private_key = private_key.to_bytes().to_vec();
+
+    Keypair {
+        public_key,
+        private_key,
+    }
+}