near_crypto/
test_utils.rs

1use crate::signature::{
2    KeyType, ML_DSA_65_SIGNATURE_LENGTH, MlDsa65Signature, PublicKey, SecretKey,
3};
4#[cfg(feature = "rand")]
5use crate::signature::{
6    ML_DSA_65_PUBLIC_KEY_LENGTH, ML_DSA_65_SEED_LENGTH, MlDsa65PublicKey, ml_dsa_65_from_seed,
7};
8use crate::{InMemorySigner, Signature};
9
10#[cfg(feature = "rand")]
11fn ed25519_key_pair_from_seed(seed: &str) -> ed25519_dalek::SigningKey {
12    let seed_bytes = seed.as_bytes();
13    let len = std::cmp::min(ed25519_dalek::SECRET_KEY_LENGTH, seed_bytes.len());
14    let mut seed: [u8; ed25519_dalek::SECRET_KEY_LENGTH] = [b' '; ed25519_dalek::SECRET_KEY_LENGTH];
15    seed[..len].copy_from_slice(&seed_bytes[..len]);
16    ed25519_dalek::SigningKey::from_bytes(&seed)
17}
18
19#[cfg(feature = "rand")]
20fn secp256k1_secret_key_from_seed(seed: &str) -> secp256k1::SecretKey {
21    use secp256k1::rand::SeedableRng;
22
23    let seed_bytes = seed.as_bytes();
24    let len = std::cmp::min(32, seed_bytes.len());
25    let mut seed: [u8; 32] = [b' '; 32];
26    seed[..len].copy_from_slice(&seed_bytes[..len]);
27    let mut rng = secp256k1::rand::rngs::StdRng::from_seed(seed);
28    secp256k1::SecretKey::new(&mut rng)
29}
30
31/// Derive a deterministic 32-byte seed from a free-form `&str` for
32/// ML-DSA-65 test key derivation. Mirrors the ed25519/secp256k1 zero-pad
33/// pattern used elsewhere in this file: take the first 32 bytes of the
34/// input and pad with spaces. Long inputs collide on the same seed; that
35/// is acceptable for test fixtures.
36#[cfg(feature = "rand")]
37fn ml_dsa_65_seed_bytes_from_str(seed: &str) -> [u8; ML_DSA_65_SEED_LENGTH] {
38    let seed_bytes = seed.as_bytes();
39    let len = std::cmp::min(ML_DSA_65_SEED_LENGTH, seed_bytes.len());
40    let mut out: [u8; ML_DSA_65_SEED_LENGTH] = [b' '; ML_DSA_65_SEED_LENGTH];
41    out[..len].copy_from_slice(&seed_bytes[..len]);
42    out
43}
44
45impl PublicKey {
46    #[cfg(feature = "rand")]
47    pub fn from_seed(key_type: KeyType, seed: &str) -> Self {
48        match key_type {
49            KeyType::ED25519 => {
50                let keypair = ed25519_key_pair_from_seed(seed);
51                PublicKey::ED25519(crate::signature::ED25519PublicKey(
52                    keypair.verifying_key().to_bytes(),
53                ))
54            }
55            KeyType::SECP256K1 => {
56                let secret_key = SecretKey::SECP256K1(secp256k1_secret_key_from_seed(seed));
57                PublicKey::SECP256K1(secret_key.public_key().unwrap_as_secp256k1().clone())
58            }
59            KeyType::MLDSA65 => {
60                let seed_bytes = ml_dsa_65_seed_bytes_from_str(seed);
61                let sk = ml_dsa_65_from_seed(&seed_bytes).expect("ML-DSA-65 from_seed failed");
62                sk.public_key()
63            }
64        }
65    }
66}
67
68impl SecretKey {
69    #[cfg(feature = "rand")]
70    pub fn from_seed(key_type: KeyType, seed: &str) -> Self {
71        match key_type {
72            KeyType::ED25519 => {
73                let keypair = ed25519_key_pair_from_seed(seed);
74                SecretKey::ED25519(crate::signature::ED25519SecretKey(keypair.to_keypair_bytes()))
75            }
76            KeyType::SECP256K1 => SecretKey::SECP256K1(secp256k1_secret_key_from_seed(seed)),
77            KeyType::MLDSA65 => {
78                let seed_bytes = ml_dsa_65_seed_bytes_from_str(seed);
79                ml_dsa_65_from_seed(&seed_bytes).expect("ML-DSA-65 from_seed failed")
80            }
81        }
82    }
83}
84
85const SIG: [u8; ed25519_dalek::SIGNATURE_LENGTH] = [0u8; ed25519_dalek::SIGNATURE_LENGTH];
86
87impl Signature {
88    /// Empty signature that doesn't correspond to anything.
89    pub fn empty(key_type: KeyType) -> Self {
90        match key_type {
91            KeyType::ED25519 => Signature::ED25519(ed25519_dalek::Signature::from_bytes(&SIG)),
92            KeyType::MLDSA65 => {
93                Signature::MLDSA65(MlDsa65Signature(Box::new([0u8; ML_DSA_65_SIGNATURE_LENGTH])))
94            }
95            _ => unimplemented!(),
96        }
97    }
98}
99
100#[cfg(feature = "rand")]
101impl PublicKey {
102    /// Construct an all-zero ML-DSA-65 pubkey for tests where the key data
103    /// doesn't matter (e.g. verifying that infrastructure plumbing handles a
104    /// large-payload variant). NOT a valid pubkey for verification.
105    pub fn ml_dsa_65_zero() -> Self {
106        PublicKey::MLDSA65(MlDsa65PublicKey(Box::new([0u8; ML_DSA_65_PUBLIC_KEY_LENGTH])))
107    }
108}
109
110impl InMemorySigner {
111    #[cfg(feature = "rand")]
112    pub fn from_random(account_id: near_account_id::AccountId, key_type: KeyType) -> Self {
113        let secret_key = SecretKey::from_random(key_type);
114        Self { account_id, public_key: secret_key.public_key(), secret_key }
115    }
116}
near_crypto/test_utils.rs

near_crypto/
test_utils.rs
