v0.0.2: musl build fix, plain XOR cipher mode, iperf3 bench

- src/tun.rs: use libc::Ioctl for TUNSETIFF so musl (c_int) builds
  alongside glibc (c_ulong). v0.0.1 failed to cross-compile to
  aarch64/armv7 musl on this point.
- Add cipher_mode = "chained" | "plain" config. Chained stays default
  (per-packet avalanche). Plain is auto-vectorizable pure XOR; useful
  only when XOR becomes the bottleneck (10 Gbps+ / jumbo frames).
- tests/netns/bench.sh: 5-netns topology + iperf3 UDP over VXLAN to
  measure throughput/CPU per cipher_mode for ip4 and ip6. VXLAN MTU set
  to the standard 1450 (v4) / 1430 (v6) against veth=1500.
- tests/netns/run.sh: set vxlan MTU explicitly to match.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: root

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "transparent-udp-obfus"
-version = "0.0.1"
+version = "0.0.2"
 edition = "2021"
 
 [[bin]]

Cargo.toml

@@ -17,6 +17,8 @@ pub struct Config {
     #[serde(default)]
     pub sender_mode: SenderMode,
     #[serde(default)]
+    pub cipher_mode: CipherMode,
+    #[serde(default)]
     pub local_traffic: Vec<TrafficRule>,
     #[serde(default)]
     pub remote_traffic: Vec<TrafficRule>,
@@ -54,6 +56,18 @@ pub enum AfSpec {
     Ip6,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum CipherMode {
+    /// Tail→head chained XOR. Intra-packet avalanche; not SIMD-vectorizable.
+    #[default]
+    Chained,
+    /// Pure stateless XOR with the keystream. ~10–30× faster (AVX2/NEON)
+    /// but identical plaintext segments at the same offset produce identical
+    /// ciphertext.
+    Plain,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Default)]
 #[serde(rename_all = "snake_case")]
 pub enum SenderMode {

src/config.rs

@@ -1,31 +1,48 @@
 use chacha20::cipher::{KeyIvInit, StreamCipher};
 use chacha20::ChaCha20;
 
+use crate::config::CipherMode;
+
 pub const KS_LEN: usize = 9000;
 const BUF_LEN: usize = KS_LEN + 1;
 
 pub struct Keystream {
     bytes: [u8; BUF_LEN],
+    mode: CipherMode,
 }
 
 impl Keystream {
-    pub fn from_passphrase(passphrase: &str) -> Self {
+    pub fn from_passphrase(passphrase: &str, mode: CipherMode) -> Self {
         let key_hash = blake3::hash(passphrase.as_bytes());
         let key: [u8; 32] = *key_hash.as_bytes();
         let nonce = [0u8; 12];
         let mut cipher = ChaCha20::new(&key.into(), &nonce.into());
         let mut bytes = [0u8; BUF_LEN];
         cipher.apply_keystream(&mut bytes);
-        Self { bytes }
+        Self { bytes, mode }
     }
 
     pub fn max_payload(&self) -> usize {
         KS_LEN
     }
 
-    /// Chained XOR encode, processed tail → head, in place.
-    /// `C[i] = P[i] ^ K[i] ^ C[i+1]`, with `C[N] = K[N]`.
     pub fn encode(&self, buf: &mut [u8]) -> bool {
+        match self.mode {
+            CipherMode::Chained => self.encode_chained(buf),
+            CipherMode::Plain => self.xor_plain(buf),
+        }
+    }
+
+    pub fn decode(&self, buf: &mut [u8]) -> bool {
+        match self.mode {
+            CipherMode::Chained => self.decode_chained(buf),
+            CipherMode::Plain => self.xor_plain(buf),
+        }
+    }
+
+    /// Chained XOR encode, tail → head, in place.
+    /// `C[i] = P[i] ^ K[i] ^ C[i+1]`, with `C[N] = K[N]`.
+    fn encode_chained(&self, buf: &mut [u8]) -> bool {
         let n = buf.len();
         if n == 0 || n > KS_LEN {
             return false;
@@ -40,8 +57,8 @@ impl Keystream {
         true
     }
 
-    /// Reverse of `encode`. Processed head → tail, in place.
-    pub fn decode(&self, buf: &mut [u8]) -> bool {
+    /// Reverse of `encode_chained`. Head → tail, in place.
+    fn decode_chained(&self, buf: &mut [u8]) -> bool {
         let n = buf.len();
         if n == 0 || n > KS_LEN {
             return false;
@@ -53,6 +70,20 @@ impl Keystream {
         }
         true
     }
+
+    /// Pure stateless XOR. Encode == decode. Auto-vectorizable (the compiler
+    /// turns this into AVX2/NEON chunks).
+    fn xor_plain(&self, buf: &mut [u8]) -> bool {
+        let n = buf.len();
+        if n == 0 || n > KS_LEN {
+            return false;
+        }
+        let k = &self.bytes[..n];
+        for (b, kb) in buf.iter_mut().zip(k.iter()) {
+            *b ^= *kb;
+        }
+        true
+    }
 }
 
 #[cfg(test)]
@@ -61,20 +92,22 @@ mod tests {
 
     #[test]
     fn roundtrip() {
-        let ks = Keystream::from_passphrase("hunter2");
-        for n in [1, 2, 7, 16, 100, 1500, 8999, 9000] {
-            let pt: Vec<u8> = (0..n).map(|i| (i * 31) as u8).collect();
-            let mut buf = pt.clone();
-            assert!(ks.encode(&mut buf));
-            assert_ne!(buf, pt, "ciphertext equals plaintext at n={n}");
-            assert!(ks.decode(&mut buf));
-            assert_eq!(buf, pt, "roundtrip mismatch at n={n}");
+        for mode in [CipherMode::Chained, CipherMode::Plain] {
+            let ks = Keystream::from_passphrase("hunter2", mode);
+            for n in [1, 2, 7, 16, 100, 1500, 8999, 9000] {
+                let pt: Vec<u8> = (0..n).map(|i| (i * 31) as u8).collect();
+                let mut buf = pt.clone();
+                assert!(ks.encode(&mut buf));
+                assert_ne!(buf, pt, "ciphertext equals plaintext at n={n} mode={mode:?}");
+                assert!(ks.decode(&mut buf));
+                assert_eq!(buf, pt, "roundtrip mismatch at n={n} mode={mode:?}");
+            }
         }
     }
 
     #[test]
-    fn tail_change_affects_head() {
-        let ks = Keystream::from_passphrase("hunter2");
+    fn chained_tail_change_affects_head() {
+        let ks = Keystream::from_passphrase("hunter2", CipherMode::Chained);
         let mut a = vec![0u8; 64];
         let mut b = vec![0u8; 64];
         b[63] = 1;
@@ -83,9 +116,20 @@ mod tests {
         assert_ne!(a[0], b[0], "tail change must propagate to head");
     }
 
+    #[test]
+    fn plain_is_stateless() {
+        let ks = Keystream::from_passphrase("hunter2", CipherMode::Plain);
+        let mut a = vec![0u8; 64];
+        let mut b = vec![0u8; 64];
+        b[63] = 1;
+        ks.encode(&mut a);
+        ks.encode(&mut b);
+        assert_eq!(a[0], b[0], "plain XOR: head must be independent of tail");
+    }
+
     #[test]
     fn rejects_oversize() {
-        let ks = Keystream::from_passphrase("x");
+        let ks = Keystream::from_passphrase("x", CipherMode::Chained);
         let mut buf = vec![0u8; KS_LEN + 1];
         assert!(!ks.encode(&mut buf));
     }

src/keystream.rs

@@ -39,7 +39,7 @@ fn main() -> Result<()> {
 
     let cli = Cli::parse();
     let cfg = Config::load(&cli.config).context("loading config")?;
-    tracing::info!(?cfg.sender_mode, threads = cfg.num_threads, "starting");
+    tracing::info!(?cfg.sender_mode, ?cfg.cipher_mode, threads = cfg.num_threads, "starting");
 
     let rt = tokio::runtime::Builder::new_multi_thread()
         .worker_threads(cfg.num_threads)
@@ -52,7 +52,7 @@ fn main() -> Result<()> {
 async fn async_main(cfg: Config) -> Result<()> {
     let local_rules = Arc::new(CompiledRule::compile_many(&cfg.local_traffic)?);
     let remote_rules = Arc::new(CompiledRule::compile_many(&cfg.remote_traffic)?);
-    let keystream = Arc::new(Keystream::from_passphrase(&cfg.passphrase));
+    let keystream = Arc::new(Keystream::from_passphrase(&cfg.passphrase, cfg.cipher_mode));
 
     // Create TUN queues: one read queue per worker for the sender, plus one
     // dedicated write queue shared across all receiver tasks.

src/main.rs

@@ -7,8 +7,10 @@ const IFF_TUN: u16 = 0x0001;
 const IFF_NO_PI: u16 = 0x1000;
 const IFF_MULTI_QUEUE: u16 = 0x0100;
 
-// TUNSETIFF = _IOW('T', 202, int) = 0x400454ca on Linux.
-const TUNSETIFF: libc::c_ulong = 0x400454ca;
+// TUNSETIFF = _IOW('T', 202, int) = 0x400454ca on Linux. The request type
+// differs between libcs (c_ulong on glibc, c_int on musl), so we use the
+// libc::Ioctl type alias so musl builds compile.
+const TUNSETIFF: libc::Ioctl = 0x400454ca as libc::Ioctl;
 
 #[repr(C)]
 struct Ifreq {