kec/common-api/tests/crypto.rs

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
}