michael/omnivox-rs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

0.15.0: simple builder API, v2.1 framing, stream lane, benches

Browse Source 
- omnivox::server::<T>()/client::<T>() builders; plain closures, enum in,
  match in the callback — the original C++ UX with the ceremony removed
- serde + bincode replace the hand-rolled Cereal codec (vectors.rs still
  governs the crypto leaves via the C++ golden oracles)
- v2.1 frames: u32 len | type | ct | tag; nonce derived from the sequence
  counter (no wire nonce), type byte authenticated as AAD; any frame-level
  failure is fatal, authenticated-but-undecodable payloads are skipped
- stream lane: send_stream/on_stream, 1 MiB frames, shared sequence with
  messages (exact sender interleaving preserved); see dump-agent/viewer
- per-connection bounded queues + writer tasks; reply/reply_stream are
  non-blocking try_send lanes for callbacks
- benches: seal/open criterion group + transport harness (spray msg/s,
  stream GiB/s, raw loopback baseline)
- profile.dev.package scrypt/pbkdf2 opt-level 3: golden-vector scrypt at
  N=2^17 was unusable in debug builds
- PROTOCOL-V2.md and README rewritten for v2.1
This commit is contained in:
michael
2026-09-30 08:07:38 -04:00
parent c614d8345f
commit fea8ea3ab1
15 changed files with 2827 additions and 1193 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/loopback.rs
+73 -112
View File
@@ -1,9 +1,9 @@
//! Loopback behavior tests for the v2 transport: framing discipline,
//! timeouts, junk handling, and the send-path contracts.
//! Behavior tests for the v2.1 transport via the public builder API:
//! framing discipline, timeouts, the echo roundtrip, and send-path returns.
mod support;
use omnivox::{Config, ConnectionContext, Decision, OmniVox};
use omnivox::{Config, Decision, Server};
use std::{
sync::{
Arc,
@@ -11,7 +11,7 @@ use std::{
},
time::Duration,
};
use support::{Msg, TEST_PSK, client_session, frame};
use support::{Msg, TEST_PSK, client_session};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
fn test_config() -> Config {
@@ -21,33 +21,28 @@ fn test_config() -> Config {
send_timeout_ms: 1000,
handshake_timeout_ms: 5000,
max_message_size: 8192,
max_stream_frame: 8192,
max_connections: 16,
allow_insecure_defaults: true,
}
}
async fn start_server(port: u16, rx: Arc<AtomicU32>, config: Config) -> Arc<OmniVox<Msg>> {
let server = Arc::new(OmniVox::<Msg>::new());
server.set_encrypt_key(TEST_PSK);
let data = Arc::new(move |msg: &Msg, _ctx: &ConnectionContext| {
if msg.0.starts_with(b"ok") {
rx.fetch_add(1, Ordering::SeqCst);
}
});
server
.start_server(
port,
config,
data,
Arc::new(|_ctx| {}),
Arc::new(|_ctx| Decision::Allow),
)
async fn counting_server(port: u16, rx: Arc<AtomicU32>) -> Server<Msg> {
omnivox::server::<Msg>()
.key(TEST_PSK)
.config(test_config())
.on_data(move |msg: &Msg, _ctx| {
if msg.0.starts_with(b"ok") {
rx.fetch_add(1, Ordering::SeqCst);
}
})
.on_connect(|_ctx| Decision::Allow)
.serve(port)
.await
.unwrap();
server
.unwrap()
}
async fn read_expect_eof(r: &mut tokio::net::tcp::OwnedReadHalf) {
async fn expect_eof(r: &mut tokio::net::tcp::OwnedReadHalf) {
let mut buf = [0u8; 1];
let n = tokio::time::timeout(Duration::from_secs(4), r.read(&mut buf))
.await
@@ -57,136 +52,102 @@ async fn read_expect_eof(r: &mut tokio::net::tcp::OwnedReadHalf) {
}
#[tokio::test]
async fn tampered_body_with_valid_counter_is_skipped_connection_survives() {
let port = 18201;
async fn tampered_frame_disconnects_v21_policy() {
// v2.1: authentication failure is fatal — no skip-and-continue.
let port = 18401;
let rx = Arc::new(AtomicU32::new(0));
let server = start_server(port, Arc::clone(&rx), test_config()).await;
let server = counting_server(port, Arc::clone(&rx)).await;
let (r, mut w, s) = client_session(port, &TEST_PSK).await;
// Counter 1, tampered ciphertext: auth fails, frame dropped, alive.
let mut bad = frame(&s.send_key, 1, b"ok-junk");
let last = bad.len() - 1;
bad[last] ^= 0x01;
w.write_all(&bad).await.unwrap();
// Counter 1 valid (the tampered frame consumed nothing).
w.write_all(&frame(&s.send_key, 1, b"ok1")).await.unwrap();
w.write_all(&frame(&s.send_key, 2, b"ok2")).await.unwrap();
tokio::time::sleep(Duration::from_millis(300)).await;
assert_eq!(rx.load(Ordering::SeqCst), 2);
// still alive: another frame gets through
w.write_all(&frame(&s.send_key, 3, b"ok3")).await.unwrap();
tokio::time::sleep(Duration::from_millis(300)).await;
assert_eq!(rx.load(Ordering::SeqCst), 3);
let (mut r, mut w, s) = client_session(port, &TEST_PSK).await;
let mut good = support::msg_frame(&s.send_key, 1, b"ok1");
let last = good.len() - 5; // flip a ciphertext byte
good[last] ^= 0x01;
w.write_all(&good).await.unwrap();
expect_eof(&mut r).await;
assert_eq!(rx.load(Ordering::SeqCst), 0);
server.stop().await;
drop(r);
drop(w);
}
#[tokio::test]
async fn zero_size_header_disconnects_immediately() {
// v2 retires the v1 no-return quirk: bad header closes, no follow-up.
let port = 18202;
async fn zero_size_header_disconnects() {
let port = 18402;
let rx = Arc::new(AtomicU32::new(0));
let server = start_server(port, Arc::clone(&rx), test_config()).await;
let server = counting_server(port, rx).await;
let (mut r, mut w, _s) = client_session(port, &TEST_PSK).await;
w.write_all(&0u32.to_le_bytes()).await.unwrap();
read_expect_eof(&mut r).await;
expect_eof(&mut r).await;
server.stop().await;
}
#[tokio::test]
async fn oversized_header_disconnects() {
let port = 18203;
let port = 18403;
let rx = Arc::new(AtomicU32::new(0));
let server = start_server(port, Arc::clone(&rx), test_config()).await;
let server = counting_server(port, rx).await;
let (mut r, mut w, _s) = client_session(port, &TEST_PSK).await;
w.write_all(&8193u32.to_le_bytes()).await.unwrap();
read_expect_eof(&mut r).await;
w.write_all(&9000u32.to_le_bytes()).await.unwrap();
expect_eof(&mut r).await;
server.stop().await;
}
#[tokio::test]
async fn header_stall_times_out() {
let port = 18204;
let port = 18404;
let rx = Arc::new(AtomicU32::new(0));
let server = start_server(port, Arc::clone(&rx), test_config()).await;
let server = counting_server(port, rx).await;
let (mut r, mut w, _s) = client_session(port, &TEST_PSK).await;
w.write_all(&[0x10, 0x00]).await.unwrap(); // partial header, then silence
read_expect_eof(&mut r).await;
expect_eof(&mut r).await;
server.stop().await;
}
#[tokio::test]
async fn send_to_unknown_client_is_false() {
let server = OmniVox::<Msg>::new();
server.set_encrypt_key(TEST_PSK);
assert!(!server.send_to_client(&Msg(b"x".to_vec()), 999).await);
assert!(!server.send_to_server(&Msg(b"x".to_vec())).await);
let rx = Arc::new(AtomicU32::new(0));
let server = omnivox::server::<Msg>()
.key(TEST_PSK)
.config(test_config())
.on_data(move |_: &Msg, _| {})
.serve(18405)
.await
.unwrap();
assert!(!server.send_to_client(999, &Msg(b"x".to_vec())).await);
assert_eq!(server.broadcast(&Msg(b"x".to_vec())).await, 0);
server.stop().await;
let _ = rx;
}
#[tokio::test]
async fn valid_handshake_then_api_roundtrip() {
let port = 18205;
let rx = Arc::new(AtomicU32::new(0));
let server = Arc::new(OmniVox::<Msg>::new());
server.set_encrypt_key(TEST_PSK);
let data = Arc::new({
let rx = Arc::clone(&rx);
move |msg: &Msg, ctx: &ConnectionContext| {
if msg.0.starts_with(b"ping") {
rx.fetch_add(1, Ordering::SeqCst);
let server = Arc::clone(SERVER_FOR_ECHO.get().unwrap());
let id = ctx.id;
let reply = Msg(b"pong".to_vec());
tokio::spawn(async move {
server.send_to_client(&reply, id).await;
});
}
}
});
let _ = SERVER_FOR_ECHO.set(server.clone());
server
.start_server(
port,
test_config(),
data,
Arc::new(|_c| {}),
Arc::new(|_c| Decision::Allow),
)
async fn echo_roundtrip_through_the_public_api() {
let port = 18406;
let server = omnivox::server::<Msg>()
.key(TEST_PSK)
.config(test_config())
.on_data(|msg, ctx| {
// echo via the synchronous callback lane
let _ = ctx.reply(msg);
})
.serve(port)
.await
.unwrap();
let client = OmniVox::<Msg>::new();
client.set_encrypt_key(TEST_PSK);
let got = Arc::new(AtomicU32::new(0));
let g = Arc::clone(&got);
client
.connect_to_server(
"127.0.0.1",
port,
test_config(),
Some(Arc::new(move |msg: &Msg, _c| {
if msg.0 == b"pong" {
g.fetch_add(1, Ordering::SeqCst);
}
})),
Arc::new(|_c| {}),
)
let client = omnivox::client::<Msg>()
.key(TEST_PSK)
.config(test_config())
.on_data(move |msg, _ctx| {
if msg.0 == b"ping" {
g.fetch_add(1, Ordering::SeqCst);
}
})
.connect("127.0.0.1", port)
.await
.unwrap();
assert!(client.send_to_server(&Msg(b"ping".to_vec())).await);
assert!(client.send(&Msg(b"ping".to_vec())).await);
tokio::time::sleep(Duration::from_millis(400)).await;
assert_eq!(rx.load(Ordering::SeqCst), 1);
assert_eq!(got.load(Ordering::SeqCst), 1, "encrypted echo back");
assert_eq!(got.load(Ordering::SeqCst), 1, "encrypted echo returned");
client.stop().await;
server.stop().await;
}
static SERVER_FOR_ECHO: std::sync::OnceLock<Arc<OmniVox<Msg>>> = std::sync::OnceLock::new();