chore: add back tests with poseidon #17

0xKarl98 · 2025-11-27T10:51:18Z

This one resolves issue #3 , cc @tcoratger @b-wagn

tcoratger · 2025-11-27T10:57:29Z

src/inc_encoding/basic_winternitz.rs

I think that we removed this here ea9fc1d so I don't think this is a good idea to put this back

tcoratger

I think that the goal of this was just to reactivate

leanSig/src/signature/generalized_xmss.rs

Lines 669 to 705 in 3f1117f

    
               /*#[test] 
        
               pub fn test_large_base_sha() { 
        
                   // Note: do not use these parameters, they are just for testing 
        
                   type PRF = ShaPRF<24, 8>; 
        
                   type TH = ShaTweak192192; 
        
                   // use chunk size 8 
        
                   type MH = ShaMessageHash<24, 8, 32, 8>; 
        
                   const TARGET_SUM: usize = 1 << 12; 
        
                   type IE = TargetSumEncoding<MH, TARGET_SUM>; 
        
                   const LOG_LIFETIME: usize = 10; 
        
                   type Sig = GeneralizedXMSSSignatureScheme<PRF, IE, TH, LOG_LIFETIME>; 
        
                   Sig::internal_consistency_check(); 
        
                   test_signature_scheme_correctness::<Sig>(0, 0, Sig::LIFETIME as usize); 
        
                   test_signature_scheme_correctness::<Sig>(11, 0, Sig::LIFETIME as usize); 
        
               } 
        
               #[test] 
        
               pub fn test_large_dimension_sha() { 
        
                   // Note: do not use these parameters, they are just for testing 
        
                   type PRF = ShaPRF<24, 8>; 
        
                   type TH = ShaTweak192192; 
        
                   // use 256 chunks 
        
                   type MH = ShaMessageHash<24, 8, 256, 1>; 
        
                   const TARGET_SUM: usize = 128; 
        
                   type IE = TargetSumEncoding<MH, TARGET_SUM>; 
        
                   const LOG_LIFETIME: usize = 10; 
        
                   type Sig = GeneralizedXMSSSignatureScheme<PRF, IE, TH, LOG_LIFETIME>; 
        
                   Sig::internal_consistency_check(); 
        
                   test_signature_scheme_correctness::<Sig>(2, 0, Sig::LIFETIME as usize); 
        
                   test_signature_scheme_correctness::<Sig>(19, 0, Sig::LIFETIME as usize); 
        
               }*/

with Poseidon instead of SHA no?

I'm not sure about the content of this PR, which seems to have deviated significantly from this goal.

0xKarl98 · 2025-11-27T11:04:01Z

pub fn test_large_base_sha() {

Yeah I have removed this commented-out SHA part and just keep the poseidon

tcoratger · 2025-11-27T11:07:45Z

src/symmetric/message_hash.rs

+
+#[cfg(test)]
+/// Splits a list of bytes into smaller fixed-size bit chunks.
+///
+/// Each byte in the input slice is divided into `chunk_size`-bit chunks,
+/// starting from the least significant bits. The `chunk_size` must divide 8 exactly
+/// (i.e., valid values are 1, 2, 4, or 8), since each byte contains 8 bits.
+#[must_use]
+#[inline]
+pub fn bytes_to_chunks(bytes: &[u8], chunk_size: usize) -> Vec<u8> {
+    // Only the chunk sizes 1, 2, 4, or 8 are valid.
+    assert!(
+        matches!(chunk_size, 1 | 2 | 4 | 8),
+        "chunk_size must be 1, 2, 4, or 8"
+    );
+
+    // Calculate how many chunks each byte will produce and preallocate exactly.
+    let chunks_per_byte = 8 / chunk_size;
+    let mut out = Vec::with_capacity(bytes.len() * chunks_per_byte);
+
+    match chunk_size {
+        8 => {
+            out.extend_from_slice(bytes);
+        }
+        4 => {
+            for &b in bytes {
+                out.push(b & 0x0F);
+                out.push(b >> 4);
+            }
+        }
+        2 => {
+            for &b in bytes {
+                out.push(b & 0b11);
+                out.push((b >> 2) & 0b11);
+                out.push((b >> 4) & 0b11);
+                out.push((b >> 6) & 0b11);
+            }
+        }
+        1 => {
+            for &b in bytes {
+                out.push(b & 1);
+                out.push((b >> 1) & 1);
+                out.push((b >> 2) & 1);
+                out.push((b >> 3) & 1);
+                out.push((b >> 4) & 1);
+                out.push((b >> 5) & 1);
+                out.push((b >> 6) & 1);
+                out.push((b >> 7) & 1);
+            }
+        }
+        _ => unreachable!(),
+    }
+
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::bytes_to_chunks;
+    use proptest::prelude::*;
+
+    #[test]
+    fn test_bytes_to_chunks() {
+        let byte_a: u8 = 0b0110_1100;
+        let byte_b: u8 = 0b1010_0110;
+
+        let bytes = [byte_a, byte_b];
+        let expected_chunks = [0b00, 0b11, 0b10, 0b01, 0b10, 0b01, 0b10, 0b10];
+
+        let chunks = bytes_to_chunks(&bytes, 2);
+
+        assert_eq!(chunks.len(), 8);
+
+        for i in 0..chunks.len() {
+            assert_eq!(chunks[i], expected_chunks[i]);
+        }
+
+        // now test chunk size 8
+        let chunks = bytes_to_chunks(&bytes, 8);
+
+        assert_eq!(chunks.len(), 2);
+        assert_eq!(chunks[0], byte_a);
+        assert_eq!(chunks[1], byte_b);
+    }
+
+    proptest! {
+        #[test]
+        fn prop_bytes_to_chunks_matches_manual_bit_extraction(
+            bytes in proptest::collection::vec(any::<u8>(), 0..32),
+            chunk_size in prop_oneof![Just(1usize), Just(2), Just(4), Just(8)],
+        ) {
+            let chunks = bytes_to_chunks(&bytes, chunk_size);
+
+            let chunks_per_byte = 8 / chunk_size;
+            let mut expected = Vec::with_capacity(bytes.len() * chunks_per_byte);
+
+            for &b in &bytes {
+                for i in 0..chunks_per_byte {
+                    let shifted = b >> (i * chunk_size);
+                    let mask = if chunk_size == 8 { 0xFF } else { (1u8 << chunk_size) - 1 };
+                    expected.push(shifted & mask);
+                }
+            }
+
+            prop_assert_eq!(chunks.as_slice(), expected.as_slice());
+        }
+    }
+}


I don't think that we need all this neither no?

Yeah i was thought too much , have removed them

This reverts commit 090a200.

tcoratger · 2025-11-27T11:18:16Z