Add tests

common-api/Cargo.toml

@@ -18,3 +18,8 @@ serde = { version = "1", default-features = false, features = ["derive"] }
 serde_json = "1"
 thiserror = "1"
 x25519-dalek = { version = "1", features = ["serde"] }
+
+[dev-dependencies]
+anyhow = "1"
+rand = "0.8.5"
+rand_chacha = "0.3"

common-api/src/crypto/mod.rs

@@ -148,3 +148,25 @@ fn split_encoded_str(encoded: &str) -> Result<(&str, &str)> {
         _ => Err(Error::UnknownKeyType(encoded.to_owned())),
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use super::{split_encoded_str, Error, ED25519, X25519};
+
+    #[test]
+    fn split_encoded() -> anyhow::Result<()> {
+        let bs58_str = bs58::encode(vec![0, 0, 0]).into_string();
+        assert!(matches!(
+                split_encoded_str(&format!("ed25519:{}", bs58_str)),
+                Ok((key_type, s)) if key_type == ED25519 && s == bs58_str));
+        assert!(matches!(
+                split_encoded_str(&format!("x25519:{}", bs58_str)),
+                Ok((key_type, s)) if key_type == X25519 && s == bs58_str));
+        assert!(matches!(
+            split_encoded_str(&bs58_str),
+            Err(Error::UnknownKeyType(..))
+        ));
+        Ok(())
+    }
+}

common-api/tests/crypto.rs

@@ -0,0 +1,291 @@
+use borsh::BorshDeserialize;
+use common_api::crypto::prelude::*;
+use ed25519_dalek::{ExpandedSecretKey, SecretKey};
+use rand::{RngCore, SeedableRng};
+use rand_chacha::ChaChaRng;
+
+#[test]
+fn try_from_bytes_ed25519() -> anyhow::Result<()> {
+    let sk = Ed25519SecretKey::try_from_bytes(&random_bits())?;
+    let pk = Ed25519PublicKey::from(&sk);
+    let _ = Ed25519PublicKey::try_from_bytes(pk.as_bytes())?;
+
+    assert!(matches!(
+        Ed25519PublicKey::try_from_bytes(&[0, 0, 0]),
+        Err(Error::ConvertFromBytes { .. })
+    ));
+
+    assert!(matches!(
+        Ed25519SecretKey::try_from_bytes(&[0, 0, 0]),
+        Err(Error::ConvertFromBytes { .. })
+    ));
+
+    Ok(())
+}
+
+#[test]
+fn to_string_ed25519() -> anyhow::Result<()> {
+    let sk = Ed25519SecretKey::try_from_bytes(&random_bits())?;
+    let pk = Ed25519PublicKey::from(&sk);
+
+    assert_eq!(
+        format!("ed25519:{}", bs58::encode(sk.as_bytes()).into_string()),
+        sk.string()
+    );
+    assert_eq!(
+        format!("ed25519:{}", bs58::encode(pk.as_bytes()).into_string()),
+        pk.string()
+    );
+
+    Ok(())
+}
+
+#[test]
+fn from_string_ed25519() -> anyhow::Result<()> {
+    let sk = Ed25519SecretKey::try_from_bytes(&random_bits())?;
+    let pk = Ed25519PublicKey::from(&sk);
+
+    let _ = Ed25519SecretKey::from_string(
+        format!("ed25519:{}", bs58::encode(sk.as_bytes()).into_string()).as_str(),
+    )?;
+
+    let _ = Ed25519PublicKey::from_string(
+        format!("ed25519:{}", bs58::encode(pk.as_bytes()).into_string()).as_str(),
+    )?;
+
+    assert!(matches!(
+        Ed25519PublicKey::from_string(
+            format!("x25519:{}", bs58::encode(vec![0, 0, 0]).into_string()).as_str()
+        ),
+        Err(Error::WrongKeyType { .. })
+    ));
+
+    assert!(matches!(
+        Ed25519SecretKey::from_string(
+            format!("x25519:{}", bs58::encode(vec![0, 0, 0]).into_string()).as_str(),
+        ),
+        Err(Error::WrongKeyType { .. })
+    ));
+
+    assert!(matches!(
+        Ed25519SecretKey::from_string(format!("ed25519:{}", "==1234%#").as_str(),),
+        Err(Error::ConvertFromString { .. })
+    ));
+
+    assert!(matches!(
+        Ed25519PublicKey::from_string(
+            format!("ed25519:{}", bs58::encode(vec![0, 0, 0]).into_string()).as_str(),
+        ),
+        Err(Error::ConvertFromBytes { .. })
+    ));
+
+    assert!(matches!(
+        Ed25519PublicKey::from_string(format!("ed25519:{}", "==1234%#").as_str(),),
+        Err(Error::ConvertFromString { .. })
+    ));
+
+    Ok(())
+}
+
+#[test]
+fn from_expanded() -> anyhow::Result<()> {
+    let dalek_sk = ExpandedSecretKey::from(&SecretKey::from_bytes(&random_bits())?);
+    let exp_str = format!(
+        "ed25519:{}",
+        bs58::encode(dalek_sk.to_bytes()).into_string()
+    );
+    let sk = Ed25519SecretKey::from_expanded(&exp_str)?;
+
+    assert_eq!(sk.as_bytes(), &dalek_sk.to_bytes()[..32]);
+    Ok(())
+}
+
+#[test]
+fn from_expanded_fail() -> anyhow::Result<()> {
+    let dalek_sk = ExpandedSecretKey::from(&SecretKey::from_bytes(&random_bits())?);
+
+    let exp_str = bs58::encode(dalek_sk.to_bytes()).into_string();
+    assert!(matches!(
+        Ed25519SecretKey::from_expanded(&exp_str),
+        Err(Error::UnknownKeyType { .. })
+    ));
+
+    let exp_str = format!("ed25519:{}", bs58::encode(vec![0, 0, 0]).into_string());
+    assert!(matches!(
+        Ed25519SecretKey::from_expanded(&exp_str),
+        Err(Error::ConvertFromBytes { .. })
+    ));
+
+    let exp_str = format!("ed25519:{}", "===%123@@#31");
+    assert!(matches!(
+        Ed25519SecretKey::from_expanded(&exp_str),
+        Err(Error::ConvertFromString { .. })
+    ));
+
+    Ok(())
+}
+
+#[test]
+fn try_from_bytes_x25519() -> anyhow::Result<()> {
+    let sk = Secret::try_from_bytes(&random_bits())?;
+    let pk = Public::from(&sk);
+    let _ = Public::try_from_bytes(&pk.to_bytes())?;
+
+    assert!(matches!(
+        Public::try_from_bytes(&[0, 0, 0]),
+        Err(Error::ConvertFromBytes { .. })
+    ));
+
+    assert!(matches!(
+        Secret::try_from_bytes(&[0, 0, 0]),
+        Err(Error::ConvertFromBytes { .. })
+    ));
+
+    Ok(())
+}
+
+#[test]
+fn to_string_x25519() -> anyhow::Result<()> {
+    let sk = Secret::try_from_bytes(&random_bits())?;
+    let pk = Public::from(&sk);
+
+    assert_eq!(
+        format!("x25519:{}", bs58::encode(&sk.to_bytes()).into_string()),
+        sk.string()
+    );
+    assert_eq!(
+        format!("x25519:{}", bs58::encode(&pk.to_bytes()).into_string()),
+        pk.string()
+    );
+
+    Ok(())
+}
+
+#[test]
+fn from_string_x25519() -> anyhow::Result<()> {
+    let sk = Secret::try_from_bytes(&random_bits())?;
+    let pk = Public::from(&sk);
+
+    let _ = Secret::from_string(
+        format!("x25519:{}", bs58::encode(&sk.to_bytes()).into_string()).as_str(),
+    )?;
+
+    let _ = Public::from_string(
+        format!("x25519:{}", bs58::encode(&pk.to_bytes()).into_string()).as_str(),
+    )?;
+
+    assert!(matches!(
+        Public::from_string(
+            format!("ed25519:{}", bs58::encode(vec![0, 0, 0]).into_string()).as_str()
+        ),
+        Err(Error::WrongKeyType { .. })
+    ));
+
+    assert!(matches!(
+        Secret::from_string(
+            format!("ed25519:{}", bs58::encode(vec![0, 0, 0]).into_string()).as_str(),
+        ),
+        Err(Error::WrongKeyType { .. })
+    ));
+
+    assert!(matches!(
+        Secret::from_string(
+            format!("x25519:{}", bs58::encode(vec![0, 0, 0]).into_string()).as_str(),
+        ),
+        Err(Error::ConvertFromBytes { .. })
+    ));
+
+    assert!(matches!(
+        Secret::from_string(format!("x25519:{}", "==1234%#").as_str(),),
+        Err(Error::ConvertFromString { .. })
+    ));
+
+    assert!(matches!(
+        Public::from_string(
+            format!("x25519:{}", bs58::encode(vec![0, 0, 0]).into_string()).as_str(),
+        ),
+        Err(Error::ConvertFromBytes { .. })
+    ));
+
+    assert!(matches!(
+        Public::from_string(format!("x25519:{}", "==1234%#").as_str(),),
+        Err(Error::ConvertFromString { .. })
+    ));
+
+    Ok(())
+}
+
+#[test]
+fn public_key_verify() -> anyhow::Result<()> {
+    let sk = Ed25519SecretKey::try_from_bytes(&random_bits())?;
+    let pk = Ed25519PublicKey::from(&sk);
+
+    let signature = sk.sign(b"message", &pk);
+    pk.verify(b"message", &signature)?;
+
+    Ok(())
+}
+
+#[test]
+fn keypair_verify() -> anyhow::Result<()> {
+    let keypair = Keypair::new(Ed25519SecretKey::try_from_bytes(&random_bits())?);
+    let signature = keypair.sign(b"message");
+    keypair.verify(b"message", &signature)?;
+
+    Ok(())
+}
+
+#[test]
+fn key_exchange() -> anyhow::Result<()> {
+    let alice_sk = Secret::try_from_bytes(&random_bits())?;
+    let alice_pk = Public::from(&alice_sk);
+
+    let bob_sk = Secret::try_from_bytes(&random_bits())?;
+    let bob_pk = Public::from(&bob_sk);
+
+    assert_eq!(alice_sk.exchange(&bob_pk), bob_sk.exchange(&alice_pk));
+    Ok(())
+}
+
+#[test]
+fn borsh_ed25519() -> anyhow::Result<()> {
+    let sk = Ed25519SecretKey::try_from_bytes(&random_bits())?;
+    let sk_bytes = borsh::to_vec(&sk)?;
+    let pk = Ed25519PublicKey::from(&sk);
+    let pk_bytes = borsh::to_vec(&pk)?;
+
+    assert_eq!(pk_bytes.len(), pk.as_bytes().len() + 1);
+    assert_eq!(pk_bytes[0], 0);
+    assert_eq!(sk_bytes.len(), sk.as_bytes().len());
+
+    let sk = Ed25519SecretKey::try_from_slice(&sk_bytes)?;
+    let pk = Ed25519PublicKey::try_from_slice(&pk_bytes)?;
+
+    let signature_bytes = borsh::to_vec(&sk.sign(b"message", &pk))?;
+    pk.verify(
+        b"message",
+        &Ed25519Signature::try_from_slice(&signature_bytes)?,
+    )?;
+
+    Ok(())
+}
+
+#[test]
+fn borsh_x25519() -> anyhow::Result<()> {
+    let sk = Secret::try_from_bytes(&random_bits())?;
+    let sk_bytes = borsh::to_vec(&sk)?;
+    let pk = Public::from(&sk);
+    let pk_bytes = borsh::to_vec(&pk)?;
+
+    let _ = Secret::try_from_slice(&sk_bytes)?;
+    let _ = Public::try_from_slice(&pk_bytes)?;
+
+    Ok(())
+}
+
+fn random_bits() -> [u8; 32] {
+    let mut chacha = ChaChaRng::from_entropy();
+    let mut secret_bytes = [0_u8; 32];
+    chacha.fill_bytes(&mut secret_bytes);
+    secret_bytes
+}