no_std support (#225)

* No std implementation

* Run tests with std

* Adding wasm32-unknown-unknown target

Co-authored-by: Kevin Lewi <[email protected]>

src/keypair.rs

@@ -9,17 +9,19 @@
 
 use crate::errors::{InternalPakeError, ProtocolError};
 use crate::group::Group;
+use alloc::borrow::ToOwned;
+use alloc::vec::Vec;
+use core::fmt::Debug;
+use core::ops::Deref;
 #[cfg(test)]
 use generic_array::typenum::Unsigned;
 use generic_array::{ArrayLength, GenericArray};
 use generic_bytes::{SizedBytes, TryFromSizedBytesError};
-#[cfg(test)]
+#[cfg(all(test, feature = "std"))]
 use proptest::prelude::*;
-#[cfg(test)]
+#[cfg(all(test, feature = "std"))]
 use rand::{rngs::StdRng, SeedableRng};
 use rand::{CryptoRng, RngCore};
-use std::fmt::Debug;
-use std::ops::Deref;
 use zeroize::Zeroize;
 
 /// Convenience extension trait of SizedBytes
@@ -57,7 +59,7 @@ impl<G: Group, S: SecretKey<G>> Clone for KeyPair<G, S> {
 }
 
 impl<G: Group, S: SecretKey<G> + Debug> Debug for KeyPair<G, S> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("KeyPair")
             .field("pk", &self.pk)
             .field("sk", &self.sk)
@@ -73,8 +75,8 @@ impl<G: Group, S: SecretKey<G> + PartialEq> PartialEq for KeyPair<G, S> {
 
 impl<G: Group, S: SecretKey<G> + Eq> Eq for KeyPair<G, S> {}
 
-impl<G: Group, S: SecretKey<G> + std::hash::Hash> std::hash::Hash for KeyPair<G, S> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+impl<G: Group, S: SecretKey<G> + core::hash::Hash> core::hash::Hash for KeyPair<G, S> {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.pk.hash(state);
         self.sk.hash(state);
     }
@@ -139,14 +141,14 @@ impl<G: Group> KeyPair<G> {
 
     #[cfg(test)]
     pub fn as_byte_ptrs(&self) -> Vec<(*const u8, usize)> {
-        vec![
+        alloc::vec![
             (self.pk.as_ptr(), G::ElemLen::to_usize()),
             (self.sk.as_ptr(), G::ScalarLen::to_usize()),
         ]
     }
 }
 
-#[cfg(test)]
+#[cfg(all(test, feature = "std"))]
 impl<G: Group + Debug> KeyPair<G> {
     /// Test-only strategy returning a proptest Strategy based on
     /// generate_random
@@ -179,7 +181,7 @@ impl<L: ArrayLength<u8>> Clone for Key<L> {
 }
 
 impl<L: ArrayLength<u8>> Debug for Key<L> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_tuple("Key").field(&self.0).finish()
     }
 }
@@ -192,8 +194,8 @@ impl<L: ArrayLength<u8>> PartialEq for Key<L> {
     }
 }
 
-impl<L: ArrayLength<u8>> std::hash::Hash for Key<L> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+impl<L: ArrayLength<u8>> core::hash::Hash for Key<L> {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.0.hash(state);
     }
 }
@@ -297,7 +299,7 @@ pub trait SecretKey<G: Group>: Clone + Sized + Zeroize {
 }
 
 impl<G: Group> SecretKey<G> for PrivateKey<G> {
-    type Error = std::convert::Infallible;
+    type Error = core::convert::Infallible;
 
     fn diffie_hellman(&self, pk: PublicKey<G>) -> Result<Vec<u8>, InternalPakeError> {
         let pk_data = GenericArray::<u8, G::ElemLen>::from_slice(&pk.0[..]);
@@ -373,19 +375,20 @@ impl<G: Group> SizedBytes for PublicKey<G> {
 mod tests {
     use super::*;
     use crate::errors::*;
+    use core::slice::from_raw_parts;
     use curve25519_dalek::ristretto::RistrettoPoint;
     use generic_array::typenum::Unsigned;
     use rand::rngs::OsRng;
-    use std::slice::from_raw_parts;
 
     #[test]
     fn test_zeroize_key() -> Result<(), ProtocolError> {
         let key_len = <RistrettoPoint as Group>::ElemLen::to_usize();
-        let mut key =
-            Key::<<RistrettoPoint as Group>::ElemLen>(GenericArray::clone_from_slice(&vec![
+        let mut key = Key::<<RistrettoPoint as Group>::ElemLen>(GenericArray::clone_from_slice(
+            &alloc::vec![
                 1u8;
                 key_len
-            ]));
+            ],
+        ));
         let ptr = key.as_ptr();
 
         key.zeroize();
@@ -412,6 +415,7 @@ mod tests {
         Ok(())
     }
 
+    #[cfg(feature = "std")]
     proptest! {
         #[test]
         fn test_ristretto_check(kp in KeyPair::<RistrettoPoint>::uniform_keypair_strategy()) {
@@ -448,7 +452,7 @@ mod tests {
     }
 
     #[test]
-    fn remote_key() -> anyhow::Result<()> {
+    fn remote_key() {
         use crate::{
             CipherSuite, ClientLogin, ClientLoginFinishParameters, ClientLoginFinishResult,
             ClientLoginStartResult, ClientRegistration, ClientRegistrationFinishParameters,
@@ -473,7 +477,7 @@ mod tests {
         struct RemoteKey(PrivateKey<RistrettoPoint>);
 
         impl SecretKey<RistrettoPoint> for RemoteKey {
-            type Error = std::convert::Infallible;
+            type Error = core::convert::Infallible;
 
             fn diffie_hellman(
                 &self,
@@ -502,27 +506,29 @@ mod tests {
         let sk = RistrettoPoint::random_nonzero_scalar(&mut OsRng);
         let sk_bytes = RistrettoPoint::scalar_as_bytes(sk);
         let sk = RemoteKey(PrivateKey::from_arr(&sk_bytes).unwrap());
-        let keypair = KeyPair::from_private_key(sk)?;
+        let keypair = KeyPair::from_private_key(sk).unwrap();
 
         let server_setup = ServerSetup::<Default, RemoteKey>::new_with_key(&mut OsRng, keypair);
 
         let ClientRegistrationStartResult {
             message,
             state: client,
-        } = ClientRegistration::<Default>::start(&mut OsRng, PASSWORD.as_bytes())?;
+        } = ClientRegistration::<Default>::start(&mut OsRng, PASSWORD.as_bytes()).unwrap();
         let ServerRegistrationStartResult { message, .. } =
-            ServerRegistration::start(&server_setup, message, &[])?;
-        let ClientRegistrationFinishResult { message, .. } = client.finish(
-            &mut OsRng,
-            message,
-            ClientRegistrationFinishParameters::Default,
-        )?;
+            ServerRegistration::start(&server_setup, message, &[]).unwrap();
+        let ClientRegistrationFinishResult { message, .. } = client
+            .finish(
+                &mut OsRng,
+                message,
+                ClientRegistrationFinishParameters::Default,
+            )
+            .unwrap();
         let file = ServerRegistration::finish(message);
 
         let ClientLoginStartResult {
             message,
             state: client,
-        } = ClientLogin::<Default>::start(&mut OsRng, PASSWORD.as_bytes())?;
+        } = ClientLogin::<Default>::start(&mut OsRng, PASSWORD.as_bytes()).unwrap();
         let ServerLoginStartResult {
             message,
             state: server,
@@ -534,11 +540,11 @@ mod tests {
             message,
             &[],
             ServerLoginStartParameters::default(),
-        )?;
-        let ClientLoginFinishResult { message, .. } =
-            client.finish(message, ClientLoginFinishParameters::Default)?;
-        server.finish(message)?;
-
-        Ok(())
+        )
+        .unwrap();
+        let ClientLoginFinishResult { message, .. } = client
+            .finish(message, ClientLoginFinishParameters::Default)
+            .unwrap();
+        server.finish(message).unwrap();
     }
 }