darkpool-crypto 0.1.0

Pure cryptographic primitives for the DarkPool protocol (BJJ, Poseidon2, AES, KDF)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! Domain-separated key derivation for the Hisoka protocol.

use ethers_core::types::U256;

use crate::error::CryptoError;
use crate::field::{poseidon_hash, string_to_fr};

pub struct Kdf;

impl Kdf {
    /// Derive a child key: `Poseidon([master, stringToFr(purpose), nonce?])`.
    /// Nonce is only included if non-zero. `purpose` must be <= 32 bytes.
    pub fn derive(purpose: &str, master: U256, nonce: Option<U256>) -> Result<U256, CryptoError> {
        let purpose_fr = string_to_fr(purpose)?;

        Ok(match nonce {
            Some(n) if !n.is_zero() => poseidon_hash(&[master, purpose_fr, n]),
            _ => poseidon_hash(&[master, purpose_fr]),
        })
    }

    /// Convenience wrapper: derive with a u64 index as nonce.
    pub fn derive_indexed(purpose: &str, master: U256, index: u64) -> Result<U256, CryptoError> {
        Self::derive(purpose, master, Some(U256::from(index)))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_kdf_deterministic() {
        let master = U256::from(12345u64);
        let result1 = Kdf::derive("hisoka.spend", master, None).unwrap();
        let result2 = Kdf::derive("hisoka.spend", master, None).unwrap();

        assert_eq!(result1, result2);
        assert!(!result1.is_zero());
    }

    #[test]
    fn test_kdf_different_purposes() {
        let master = U256::from(12345u64);
        let spend = Kdf::derive("hisoka.spend", master, None).unwrap();
        let view = Kdf::derive("hisoka.view", master, None).unwrap();

        assert_ne!(spend, view);
    }

    #[test]
    fn test_kdf_with_nonce() {
        let master = U256::from(12345u64);
        let without_nonce = Kdf::derive("hisoka.eskTweak", master, None).unwrap();
        let with_zero_nonce = Kdf::derive("hisoka.eskTweak", master, Some(U256::zero())).unwrap();
        let with_nonce_1 = Kdf::derive("hisoka.eskTweak", master, Some(U256::from(1))).unwrap();
        let with_nonce_2 = Kdf::derive("hisoka.eskTweak", master, Some(U256::from(2))).unwrap();

        assert_eq!(without_nonce, with_zero_nonce);

        assert_ne!(with_nonce_1, with_nonce_2);
        assert_ne!(with_nonce_1, without_nonce);
    }

    #[test]
    fn test_kdf_derive_indexed() {
        let master = U256::from(12345u64);
        let key_0 = Kdf::derive_indexed("hisoka.eskTweak", master, 0).unwrap();
        let key_1 = Kdf::derive_indexed("hisoka.eskTweak", master, 1).unwrap();
        let key_2 = Kdf::derive_indexed("hisoka.eskTweak", master, 2).unwrap();

        let without_nonce = Kdf::derive("hisoka.eskTweak", master, None).unwrap();
        assert_eq!(key_0, without_nonce);

        assert_ne!(key_1, key_0);
        assert_ne!(key_2, key_1);
    }

    #[test]
    fn test_kdf_protocol_purposes() {
        let master = U256::from(999999u64);

        let purposes = [
            "hisoka.spend",
            "hisoka.view",
            "hisoka.ivkMaster",
            "hisoka.eskTweak",
            "hisoka.ivkTweak",
        ];

        let mut results = Vec::new();
        for purpose in purposes {
            let result = Kdf::derive(purpose, master, None).unwrap();
            assert!(!result.is_zero(), "{purpose} produced zero");
            results.push(result);
        }

        for i in 0..results.len() {
            for j in (i + 1)..results.len() {
                assert_ne!(
                    results[i], results[j],
                    "{} and {} collided",
                    purposes[i], purposes[j]
                );
            }
        }
    }

    #[test]
    fn test_kdf_rejects_oversized_purpose() {
        let master = U256::from(12345u64);
        let long_purpose = "a]".repeat(17);
        let result = Kdf::derive(&long_purpose, master, None);
        assert!(result.is_err());
    }
}