feat(client): TLS 1.3 control connection with SPKI pinning and LNEx v3
Replace the custom X25519/HKDF/ChaCha20 TCP layer with rustls (TLS 1.3 only, ALPN vnox-lnex/3, no plaintext or fallback). Add a trust store (pin, trust on first use, public CA), block changed fingerprints and identities, bind the Ed25519 auth signature to the TLS exporter, add RU/EN trust dialog and update the interop test and e2e voice tool.
This commit is contained in:
parent
5f594046a6
commit
29883a3187
31 changed files with 2085 additions and 567 deletions
|
|
@ -1,66 +1,9 @@
|
|||
//! Session frame reader. Frames travel inside the TLS 1.3 stream, so there is no per frame
|
||||
//! encryption: a dedicated task retains partial frames across command/timer selection and
|
||||
//! enforces strictly increasing sequence numbers.
|
||||
use anyhow::{Result, anyhow};
|
||||
use tokio::io::AsyncReadExt;
|
||||
use tokio::io::AsyncWriteExt;
|
||||
|
||||
use super::super::crypto::SessionCrypto;
|
||||
use super::super::payloads::HDR_SIZE;
|
||||
use super::RawPacket;
|
||||
use super::parse_header;
|
||||
|
||||
const ENCRYPTED_FLAG: u16 = 1 << 1;
|
||||
const KNOWN_FLAGS: u16 = ENCRYPTED_FLAG;
|
||||
|
||||
pub async fn read_encrypted(
|
||||
stream: &mut (impl tokio::io::AsyncRead + Unpin),
|
||||
crypto: &SessionCrypto,
|
||||
) -> Result<RawPacket> {
|
||||
let mut buf = [0u8; HDR_SIZE];
|
||||
stream.read_exact(&mut buf).await?;
|
||||
let (packet_id, flags, sequence, payload_length) = parse_header(&buf)?;
|
||||
if flags & !KNOWN_FLAGS != 0 {
|
||||
return Err(anyhow!("unknown packet flags: 0x{:04X}", flags));
|
||||
}
|
||||
if flags & ENCRYPTED_FLAG == 0 {
|
||||
return Err(anyhow!("packet not encrypted"));
|
||||
}
|
||||
let mut encrypted = vec![0u8; payload_length as usize];
|
||||
if !encrypted.is_empty() {
|
||||
stream.read_exact(&mut encrypted).await?;
|
||||
}
|
||||
let payload = crypto.decrypt_s2c_aad(sequence as u64, &encrypted, &buf)?;
|
||||
Ok(RawPacket {
|
||||
packet_id,
|
||||
sequence,
|
||||
payload,
|
||||
})
|
||||
}
|
||||
|
||||
pub async fn write_encrypted(
|
||||
stream: &mut (impl tokio::io::AsyncWrite + Unpin),
|
||||
id: u16,
|
||||
seq: &mut u32,
|
||||
payload: &[u8],
|
||||
crypto: &SessionCrypto,
|
||||
) -> Result<()> {
|
||||
if *seq == u32::MAX {
|
||||
return Err(anyhow!("session sequence exhausted; reconnect required"));
|
||||
}
|
||||
if payload.len() > super::super::payloads::MAX_PAYLOAD as usize - 16 {
|
||||
return Err(anyhow!("payload too large"));
|
||||
}
|
||||
let mut hdr = [0u8; HDR_SIZE];
|
||||
hdr[0..2].copy_from_slice(&id.to_be_bytes());
|
||||
hdr[2..4].copy_from_slice(&ENCRYPTED_FLAG.to_be_bytes());
|
||||
hdr[4..8].copy_from_slice(&seq.to_be_bytes());
|
||||
hdr[8..12].copy_from_slice(&((payload.len() + 16) as u32).to_be_bytes());
|
||||
let encrypted = crypto.encrypt_c2s_aad(*seq as u64, payload, &hdr);
|
||||
*seq += 1;
|
||||
let mut frame = Vec::with_capacity(HDR_SIZE + encrypted.len());
|
||||
frame.extend_from_slice(&hdr);
|
||||
frame.extend_from_slice(&encrypted);
|
||||
stream.write_all(&frame).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// A dedicated reader retains partial frames across command/timer selection.
|
||||
/// Dropping a session cancels its reader and releases the socket half.
|
||||
|
|
@ -69,25 +12,21 @@ pub struct Reader {
|
|||
task: tokio::task::JoinHandle<()>,
|
||||
}
|
||||
impl Reader {
|
||||
pub fn new(
|
||||
mut stream: impl tokio::io::AsyncRead + Unpin + Send + 'static,
|
||||
crypto: SessionCrypto,
|
||||
) -> Self {
|
||||
pub fn new(mut stream: impl tokio::io::AsyncRead + Unpin + Send + 'static) -> Self {
|
||||
let (sender, receiver) = tokio::sync::mpsc::channel(32);
|
||||
let task = tokio::spawn(async move {
|
||||
// HELLO was 0 and SESSION was 1.
|
||||
let mut expected = 2u32;
|
||||
loop {
|
||||
let result = read_encrypted(&mut stream, &crypto)
|
||||
.await
|
||||
.and_then(|packet| {
|
||||
if packet.sequence != expected {
|
||||
return Err(anyhow!("replayed or reordered control packet"));
|
||||
}
|
||||
expected = expected
|
||||
.checked_add(1)
|
||||
.ok_or_else(|| anyhow!("session sequence exhausted"))?;
|
||||
Ok(packet)
|
||||
});
|
||||
let result = super::read(&mut stream).await.and_then(|packet| {
|
||||
if packet.sequence != expected {
|
||||
return Err(anyhow!("replayed or reordered control packet"));
|
||||
}
|
||||
expected = expected
|
||||
.checked_add(1)
|
||||
.ok_or_else(|| anyhow!("session sequence exhausted"))?;
|
||||
Ok(packet)
|
||||
});
|
||||
let failed = result.is_err();
|
||||
if sender.send(result).await.is_err() || failed {
|
||||
break;
|
||||
|
|
@ -112,34 +51,18 @@ impl Drop for Reader {
|
|||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use hkdf::Hkdf;
|
||||
use sha2::{Digest, Sha256};
|
||||
use tokio::io::AsyncWriteExt;
|
||||
use tokio::time::{Duration, timeout};
|
||||
|
||||
fn server_frame(pid: u16, seq: u32, payload: &[u8]) -> Vec<u8> {
|
||||
let mut keys = [0u8; 64];
|
||||
Hkdf::<Sha256>::new(Some(b"VNOX-LNEx-KDF-v2"), &[7; 32])
|
||||
.expand(b"session-keys", &mut keys)
|
||||
.unwrap();
|
||||
let key: [u8; 32] = keys[32..].try_into().unwrap();
|
||||
let cid: [u8; 8] = Sha256::digest(b"fixture-session")[..8].try_into().unwrap();
|
||||
let mut header = [0u8; 12];
|
||||
header[..2].copy_from_slice(&pid.to_be_bytes());
|
||||
header[2..4].copy_from_slice(&ENCRYPTED_FLAG.to_be_bytes());
|
||||
header[4..8].copy_from_slice(&seq.to_be_bytes());
|
||||
header[8..].copy_from_slice(&((payload.len() + 16) as u32).to_be_bytes());
|
||||
let body =
|
||||
crate::net::crypto::cipher::encrypt_with_aad(&key, &cid, seq as u64, payload, &header);
|
||||
[header.as_slice(), body.as_slice()].concat()
|
||||
}
|
||||
fn crypto() -> SessionCrypto {
|
||||
SessionCrypto::derive(&[7; 32], "fixture-session")
|
||||
let mut seq = seq;
|
||||
super::super::encode_frame(pid, &mut seq, payload)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn cancelling_wait_retains_partial_control_frame() {
|
||||
let (reader, mut writer) = tokio::io::duplex(256);
|
||||
let mut reader = Reader::new(reader, crypto());
|
||||
let mut reader = Reader::new(reader);
|
||||
let frame = server_frame(5, 2, b"protobuf");
|
||||
writer.write_all(&frame[..5]).await.unwrap();
|
||||
assert!(
|
||||
|
|
@ -157,7 +80,7 @@ mod tests {
|
|||
#[tokio::test]
|
||||
async fn replayed_control_sequence_is_rejected() {
|
||||
let (reader, mut writer) = tokio::io::duplex(256);
|
||||
let mut reader = Reader::new(reader, crypto());
|
||||
let mut reader = Reader::new(reader);
|
||||
let frame = server_frame(5, 2, b"");
|
||||
writer.write_all(&frame).await.unwrap();
|
||||
reader.next().await.unwrap();
|
||||
|
|
@ -165,22 +88,12 @@ mod tests {
|
|||
assert!(reader.next().await.is_err());
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn changing_packet_id_invalidates_authentication() {
|
||||
let (mut reader, mut writer) = tokio::io::duplex(256);
|
||||
let mut frame = server_frame(5, 2, b"same body");
|
||||
frame[1] ^= 1;
|
||||
async fn legacy_encrypted_flag_is_rejected() {
|
||||
let (reader, mut writer) = tokio::io::duplex(256);
|
||||
let mut reader = Reader::new(reader);
|
||||
let mut frame = server_frame(5, 2, b"0123456789abcdef");
|
||||
frame[2..4].copy_from_slice(&2u16.to_be_bytes());
|
||||
writer.write_all(&frame).await.unwrap();
|
||||
assert!(read_encrypted(&mut reader, &crypto()).await.is_err());
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn sequence_exhaustion_never_wraps_nonce() {
|
||||
let (_, mut writer) = tokio::io::duplex(256);
|
||||
let mut seq = u32::MAX;
|
||||
assert!(
|
||||
write_encrypted(&mut writer, 4, &mut seq, b"", &crypto())
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
assert_eq!(seq, u32::MAX);
|
||||
assert!(reader.next().await.is_err());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ pub fn decode_frame(bytes: &[u8]) -> Result<RawPacket> {
|
|||
let hdr: [u8; HDR_SIZE] = bytes[..HDR_SIZE].try_into().expect("header length");
|
||||
let (packet_id, flags, sequence, payload_length) = parse_header(&hdr)?;
|
||||
if flags != 0 {
|
||||
return Err(anyhow!("unexpected handshake flags"));
|
||||
return Err(anyhow!("unexpected frame flags"));
|
||||
}
|
||||
let end = HDR_SIZE + payload_length as usize;
|
||||
if bytes.len() < end {
|
||||
|
|
@ -57,7 +57,7 @@ pub async fn read(stream: &mut (impl tokio::io::AsyncRead + Unpin)) -> Result<Ra
|
|||
stream.read_exact(&mut buf).await?;
|
||||
let (packet_id, flags, sequence, payload_length) = parse_header(&buf)?;
|
||||
if flags != 0 {
|
||||
return Err(anyhow!("unexpected handshake flags"));
|
||||
return Err(anyhow!("unexpected frame flags"));
|
||||
}
|
||||
let mut payload = vec![0u8; payload_length as usize];
|
||||
if !payload.is_empty() {
|
||||
|
|
@ -76,6 +76,9 @@ pub async fn write(
|
|||
seq: &mut u32,
|
||||
payload: &[u8],
|
||||
) -> Result<()> {
|
||||
if *seq == u32::MAX {
|
||||
return Err(anyhow!("session sequence exhausted; reconnect required"));
|
||||
}
|
||||
let frame = encode_frame(id, seq, payload);
|
||||
stream.write_all(&frame).await?;
|
||||
Ok(())
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue