Add project files.

2026-06-20 09:31:59 -05:00
parent 9bb3f00d86
commit 4baa4ce8c0
346 changed files with 55751 additions and 0 deletions
@@ -0,0 +1,76 @@
+// Copyright 2025 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+
+#![feature(test)]
+
+extern crate test;
+
+#[cfg(test)]
+mod tests {
+    use spqr::{chain, ChainParams, Direction, EpochSecret};
+    use test::{black_box, Bencher};
+
+    #[bench]
+    fn add_epoch(b: &mut Bencher) {
+        let mut c = chain::Chain::new(b"1", Direction::A2B, ChainParams::default().into_pb_test())
+            .expect("should be valid");
+        let mut e: u64 = 0;
+        b.iter(|| {
+            // Inner closure, the actual test
+            e += 1;
+            c.add_epoch(EpochSecret {
+                epoch: e,
+                secret: vec![1],
+            });
+            black_box(());
+        });
+    }
+
+    #[bench]
+    fn send_key(b: &mut Bencher) {
+        let mut c = chain::Chain::new(b"1", Direction::A2B, ChainParams::default().into_pb_test())
+            .expect("should be valid");
+        b.iter(|| {
+            // Inner closure, the actual test
+            black_box(c.send_key(0).unwrap());
+        });
+    }
+
+    #[bench]
+    fn recv_key(b: &mut Bencher) {
+        let mut c = chain::Chain::new(b"1", Direction::A2B, ChainParams::default().into_pb_test())
+            .expect("should be valid");
+        let mut k: u32 = 0;
+        b.iter(|| {
+            // Inner closure, the actual test
+            k += 1;
+            black_box(c.recv_key(0, k).unwrap());
+        });
+    }
+
+    #[bench]
+    fn recv_skip_key(b: &mut Bencher) {
+        let mut c = chain::Chain::new(b"1", Direction::A2B, ChainParams::default().into_pb_test())
+            .expect("should be valid");
+        let mut k: u32 = 0;
+        b.iter(|| {
+            // Inner closure, the actual test
+            k += 2;
+            black_box(c.recv_key(0, k).unwrap());
+            black_box(c.recv_key(0, k - 1).unwrap());
+        });
+    }
+
+    #[bench]
+    fn recv_with_truncate(b: &mut Bencher) {
+        let mut c = chain::Chain::new(b"1", Direction::A2B, ChainParams::default().into_pb_test())
+            .expect("should be valid");
+        let mut k: u32 = 0;
+        b.iter(|| {
+            // Inner closure, the actual test
+            k += 2;
+            black_box(c.recv_key(0, k).unwrap());
+            // k-1 stays around and will eventually be truncated.
+        });
+    }
+}
@@ -0,0 +1,69 @@
+// Copyright 2025 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+
+#![feature(test)]
+
+extern crate test;
+
+#[cfg(test)]
+mod tests {
+    use spqr::encoding::gf;
+    use test::{black_box, Bencher};
+
+    #[bench]
+    fn add(b: &mut Bencher) {
+        let p1 = gf::GF16 { value: 0x1234 };
+        let p2 = gf::GF16 { value: 0x4567 };
+        b.iter(|| {
+            // Inner closure, the actual test
+            black_box(p1 + p2);
+        });
+    }
+    #[bench]
+    fn mul(b: &mut Bencher) {
+        let p1 = gf::GF16 { value: 0x1234 };
+        let p2 = gf::GF16 { value: 0x4567 };
+        b.iter(|| {
+            // Inner closure, the actual test
+            black_box(p1 * p2);
+        });
+    }
+    #[bench]
+    fn sub(b: &mut Bencher) {
+        let p1 = gf::GF16 { value: 0x1234 };
+        let p2 = gf::GF16 { value: 0x4567 };
+        b.iter(|| {
+            // Inner closure, the actual test
+            black_box(p1 - p2);
+        });
+    }
+    #[bench]
+    fn div(b: &mut Bencher) {
+        let p1 = gf::GF16 { value: 0x1234 };
+        let p2 = gf::GF16 { value: 0x4567 };
+        b.iter(|| {
+            // Inner closure, the actual test
+            black_box(p1 / p2);
+        });
+    }
+    #[bench]
+    fn parallel_mult_2(b: &mut Bencher) {
+        let p1 = gf::GF16 { value: 0x1234 };
+        let mut p2 = [gf::GF16 { value: 0x4567 }; 2];
+        b.iter(|| {
+            // Inner closure, the actual test
+            gf::parallel_mult(p1, &mut p2);
+            black_box(p2);
+        });
+    }
+    #[bench]
+    fn parallel_mult_16(b: &mut Bencher) {
+        let p1 = gf::GF16 { value: 0x1234 };
+        let mut p2 = [gf::GF16 { value: 0x4567 }; 16];
+        b.iter(|| {
+            // Inner closure, the actual test
+            gf::parallel_mult(p1, &mut p2);
+            black_box(p2);
+        });
+    }
+}
@@ -0,0 +1,92 @@
+// Copyright 2025 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+
+#![feature(test)]
+
+extern crate test;
+
+#[cfg(test)]
+mod tests {
+    use prost::Message;
+    use spqr::encoding::polynomial::{PolyDecoder, PolyEncoder};
+    use spqr::encoding::{Chunk, Decoder, Encoder};
+    use spqr::proto::pq_ratchet as pqrpb;
+    use test::{black_box, Bencher};
+
+    #[bench]
+    fn encode_bytes(b: &mut Bencher) {
+        b.iter(|| {
+            black_box(PolyEncoder::encode_bytes(&[3u8; 1088]).expect("encode_bytes"));
+        });
+    }
+
+    #[bench]
+    fn chunk_at_encode(b: &mut Bencher) {
+        let chunks_needed = 1088 / 32;
+        let mut encoder = PolyEncoder::encode_bytes(&[3u8; 1088]).expect("encode_bytes");
+        b.iter(|| {
+            black_box(encoder.chunk_at(chunks_needed + 3));
+        });
+    }
+
+    #[bench]
+    fn decode_one_chunk(b: &mut Bencher) {
+        let chunks_needed = 1088 / 32;
+        let mut chunks = Vec::<Chunk>::new();
+        let mut encoder = PolyEncoder::encode_bytes(&[3u8; 1088]).expect("encode_bytes");
+        for i in 1..chunks_needed + 1 {
+            chunks.push(encoder.chunk_at(i));
+        }
+        b.iter(|| {
+            let mut decoder = PolyDecoder::new(1088).expect("for_message_type");
+            for chunk in &chunks {
+                decoder.add_chunk(chunk);
+            }
+            black_box(decoder.decoded_message().unwrap());
+        });
+    }
+
+    #[bench]
+    fn decode_all_chunks(b: &mut Bencher) {
+        let chunks_needed = 1088 / 32;
+        let mut chunks = Vec::<Chunk>::new();
+        let mut encoder = PolyEncoder::encode_bytes(&[3u8; 1088]).expect("encode_bytes");
+        for i in chunks_needed..chunks_needed * 2 {
+            chunks.push(encoder.chunk_at(i));
+        }
+        b.iter(|| {
+            let mut decoder = PolyDecoder::new(1088).expect("for_message_type");
+            for chunk in &chunks {
+                decoder.add_chunk(chunk);
+            }
+            black_box(decoder.decoded_message().unwrap());
+        });
+    }
+
+    #[bench]
+    fn encoder_from_pb(b: &mut Bencher) {
+        let encoder = PolyEncoder::encode_bytes(&[3u8; 1088]).expect("encode_bytes");
+        let bytes = encoder.into_pb_test().encode_to_vec();
+        b.iter(|| {
+            black_box(PolyEncoder::from_pb_test(
+                pqrpb::PolynomialEncoder::decode(bytes.as_slice()).unwrap(),
+            ))
+        });
+    }
+
+    #[bench]
+    fn decoder_to_from_pb(b: &mut Bencher) {
+        let chunks_needed = 1088 / 32;
+        let mut encoder = PolyEncoder::encode_bytes(&[3u8; 1088]).expect("encode_bytes");
+        let mut decoder = PolyDecoder::new(1088).expect("for_message_type");
+        for i in 1..chunks_needed {
+            decoder.add_chunk(&encoder.chunk_at(i));
+        }
+        let bytes = decoder.into_pb_test().encode_to_vec();
+        b.iter(|| {
+            black_box(PolyDecoder::from_pb_test(
+                pqrpb::PolynomialDecoder::decode(bytes.as_slice()).unwrap(),
+            ))
+        });
+    }
+}
@@ -0,0 +1,96 @@
+// Copyright 2025 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+
+#![feature(test)]
+
+extern crate test;
+
+#[cfg(test)]
+mod tests {
+    use rand::TryRngCore;
+    use rand_core::OsRng;
+    use spqr::*;
+    use test::{black_box, Bencher};
+
+    fn state(dir: Direction) -> SerializedState {
+        initial_state(Params {
+            version: Version::MAX,
+            min_version: Version::MAX,
+            auth_key: b"1",
+            direction: dir,
+            chain_params: ChainParams::default(),
+        })
+        .expect("should be valid params")
+    }
+
+    #[bench]
+    fn init_a(b: &mut Bencher) {
+        b.iter(|| {
+            // Inner closure, the actual test
+            black_box(state(Direction::A2B));
+        });
+    }
+    #[bench]
+    fn init_b(b: &mut Bencher) {
+        b.iter(|| {
+            // Inner closure, the actual test
+            black_box(state(Direction::B2A));
+        });
+    }
+    #[bench]
+    fn send_recv(bench: &mut Bencher) {
+        let mut ctr: u64 = 0;
+        let mut a = state(Direction::A2B);
+        let mut b = state(Direction::B2A);
+        let mut rng = OsRng.unwrap_err();
+        let mut drop_ctr = 0;
+        bench.iter(|| {
+            ctr += 1;
+            let (x, y) = if ctr % 2 == 1 {
+                (&mut a, &mut b)
+            } else {
+                (&mut b, &mut a)
+            };
+            let Send {
+                state,
+                msg,
+                key: key_a,
+            } = send(x, &mut rng).unwrap();
+            *x = state;
+            let Recv { state, key: key_b } = recv(y, &msg).unwrap();
+            assert_eq!(key_a, key_b);
+            if drop_ctr == 0 {
+                drop_ctr += 30;
+                // We 'drop' a message by not replacing y's state.
+            } else {
+                drop_ctr -= 1;
+                *y = state;
+            }
+        });
+    }
+
+    #[bench]
+    fn long_chain_send(bench: &mut Bencher) {
+        let mut rng = OsRng.unwrap_err();
+        let mut a = state(Direction::A2B);
+        let mut b = state(Direction::B2A);
+
+        // Build a state with a lot of unused chain keys.
+        for _i in 0..8 {
+            for _j in 0..24000 {
+                let Send { state, .. } = send(&a, &mut rng).unwrap();
+                a = state;
+            }
+            let Send { state, msg, .. } = send(&a, &mut rng).unwrap();
+            a = state;
+            let Recv { state, .. } = recv(&b, &msg).unwrap();
+            b = state;
+        }
+
+        println!("state size: {}", b.len());
+        let Send { msg, .. } = send(&a, &mut rng).unwrap();
+        bench.iter(|| {
+            black_box(recv(&b, &msg).unwrap());
+        });
+    }
+}