moq-e2ee 0.0.11

End-to-end encryption for MoQ groups, datagrams, and track names.
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

use crate::limits::DATAGRAM_WINDOW;

/// Datagram duplicate suppression: a 1024-bit sliding bitmask below the greatest opened sequence.
///
/// Only successful opens are marked, so a forged datagram never burns a real one.
/// Sequences below the window are unknown, not duplicates: an operational gap.
#[derive(Default)]
pub(crate) struct DatagramWindow {
	highest: Option<u64>,
	bits: [u64; DATAGRAM_WINDOW as usize / 64],
}

impl DatagramWindow {
	pub fn is_duplicate(&self, sequence: u64) -> bool {
		let Some(highest) = self.highest else {
			return false;
		};
		sequence <= highest && highest - sequence < DATAGRAM_WINDOW && self.bit(sequence)
	}

	pub fn mark(&mut self, sequence: u64) {
		if let Some(highest) = self.highest {
			if sequence > highest {
				// Slide forward, clearing the slots the new sequences will reuse.
				for cleared in highest + 1..=sequence.min(highest + DATAGRAM_WINDOW) {
					self.set(cleared, false);
				}
				self.highest = Some(sequence);
			} else if highest - sequence >= DATAGRAM_WINDOW {
				return;
			}
		} else {
			self.highest = Some(sequence);
		}
		self.set(sequence, true);
	}

	fn bit(&self, sequence: u64) -> bool {
		let slot = (sequence % DATAGRAM_WINDOW) as usize;
		self.bits[slot / 64] & (1 << (slot % 64)) != 0
	}

	fn set(&mut self, sequence: u64, value: bool) {
		let slot = (sequence % DATAGRAM_WINDOW) as usize;
		let mask = 1u64 << (slot % 64);
		if value {
			self.bits[slot / 64] |= mask;
		} else {
			self.bits[slot / 64] &= !mask;
		}
	}
}

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

	#[test]
	fn slides_below_the_greatest_opened() {
		let mut window = DatagramWindow::default();
		assert!(!window.is_duplicate(0));
		window.mark(0);
		assert!(window.is_duplicate(0));
		for seq in 1..DATAGRAM_WINDOW {
			window.mark(seq);
		}
		assert!(window.is_duplicate(0));
		window.mark(DATAGRAM_WINDOW);
		assert!(!window.is_duplicate(0));
		assert!(window.is_duplicate(1));
		assert!(window.is_duplicate(DATAGRAM_WINDOW));
	}

	#[test]
	fn jump_clears_reused_slots() {
		let mut window = DatagramWindow::default();
		window.mark(5);
		window.mark(5 + DATAGRAM_WINDOW * 3);
		assert!(!window.is_duplicate(5));
		assert!(!window.is_duplicate(5 + DATAGRAM_WINDOW));
		assert!(!window.is_duplicate(5 + DATAGRAM_WINDOW * 2));
		assert!(window.is_duplicate(5 + DATAGRAM_WINDOW * 3));
	}

	#[test]
	fn late_within_window_marks() {
		let mut window = DatagramWindow::default();
		window.mark(100);
		assert!(!window.is_duplicate(90));
		window.mark(90);
		assert!(window.is_duplicate(90));
		window.mark(100 + DATAGRAM_WINDOW);
		window.mark(90);
		assert!(!window.is_duplicate(90));
	}
}