feat(client): protocol v2 wire layer, screen sharing, channel webhooks and secure voice

Verified against the real gateway via tests/gateway_interop.rs.
This commit is contained in:
Loki 2026-10-24 16:51:15 +02:00
parent 8460fb28fd
commit 3d7dd5413b
Signed by: boba
GPG key ID: 253067914055423B
65 changed files with 6048 additions and 1156 deletions

View file

@ -1,5 +1,6 @@
use crate::net::wire;
use anyhow::{Result, anyhow};
use tokio::net::TcpStream;
use tracing::{debug, info};
use super::crypto::SessionCrypto;
@ -12,7 +13,7 @@ use crate::identity::Identity;
/// Returns (session_id, node_name, private_mode, crypto).
/// All subsequent packets must be encrypted with `crypto`.
pub async fn run(
stream: &mut TcpStream,
stream: &mut (impl tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin),
identity: &Identity,
seq: &mut u32,
) -> Result<(String, String, bool, SessionCrypto)> {
@ -21,57 +22,94 @@ pub async fn run(
if pkt.packet_id != PID_HELLO {
return Err(anyhow!("expected HELLO, got 0x{:04X}", pkt.packet_id));
}
let hello: HelloPayload = serde_json::from_slice(&pkt.payload)?;
let hello: HelloPayload = wire::decode(&pkt.payload)?;
debug!("← HELLO node={}", hello.node_name);
if pkt.sequence != 0 {
return Err(anyhow!("invalid HELLO sequence"));
}
let server_public: [u8; 32] = hello
.server_pubkey
.as_slice()
.try_into()
.map_err(|_| anyhow!("invalid server identity key"))?;
let server_key = ed25519_dalek::VerifyingKey::from_bytes(&server_public)?;
let signature = ed25519_dalek::Signature::from_slice(&hello.server_signature)?;
let mut unsigned_hello = hello.clone();
unsigned_hello.server_signature.clear();
let mut hello_transcript = b"VNOX-LNEx-v2-server-hello\0".to_vec();
hello_transcript.extend_from_slice(&wire::encode(&unsigned_hello)?);
server_key
.verify_strict(&hello_transcript, &signature)
.map_err(|_| anyhow!("server handshake signature verification failed"))?;
// Keep full signed hello for the client-auth transcript before moving fields.
let signed_hello = wire::encode(&hello)?;
// Generate our own ephemeral X25519 keypair
let (eph_sk, eph_pk) = SessionCrypto::new_ephemeral();
let eph_pk_hex = hex::encode(eph_pk.as_bytes());
let eph_pk_hex = eph_pk.as_bytes().to_vec();
// Parse server's ephemeral key from HELLO
let server_eph_raw =
hex::decode(&hello.server_eph_pubkey).map_err(|_| anyhow!("bad server_eph_pubkey hex"))?;
let server_eph_raw = hello.server_eph_pubkey;
let server_eph_key: [u8; 32] = server_eph_raw
.try_into()
.map_err(|_| anyhow!("bad server_eph_pubkey length"))?;
let server_eph_pk = x25519_dalek::PublicKey::from(server_eph_key);
// AUTH — include our ephemeral public key
let nonce = hex::decode(&hello.challenge_nonce)?;
if hello.lnex_version != LNEX_VERSION {
return Err(anyhow!("unsupported LNEx version"));
}
if hello.server_pubkey.len() != 32 || hello.challenge_nonce.len() != 32 {
return Err(anyhow!("invalid server handshake key/challenge"));
}
let sk = identity
.signing_key()
.ok_or_else(|| anyhow!("no signing key"))?;
use ed25519_dalek::Signer;
let sig = sk.sign(&nonce);
let auth = AuthPayload {
client_pubkey: identity.pubkey_hex.clone(),
let mut auth = AuthPayload {
client_pubkey: sk.verifying_key().to_bytes().to_vec(),
nickname: identity.nickname.clone(),
lnex_version: LNEX_VERSION.into(),
signature: hex::encode(sig.to_bytes()),
signature: Vec::new(),
client_eph_pubkey: eph_pk_hex,
};
framing::write(stream, PID_AUTH, seq, &serde_json::to_vec(&auth)?).await?;
let mut auth_transcript = b"VNOX-LNEx-v2-client-auth\0".to_vec();
auth_transcript.extend_from_slice(&(signed_hello.len() as u32).to_be_bytes());
auth_transcript.extend_from_slice(&signed_hello);
auth_transcript.extend_from_slice(&wire::encode(&auth)?);
auth.signature = sk.sign(&auth_transcript).to_bytes().to_vec();
framing::write(stream, PID_AUTH, seq, &wire::encode(&auth)?).await?;
debug!("→ AUTH nick={}", identity.nickname);
// SESSION
let pkt = framing::read(stream).await?;
if pkt.packet_id == PID_ERROR {
let e: ErrorPayload = serde_json::from_slice(&pkt.payload)?;
let e: ErrorPayload = wire::decode(&pkt.payload)?;
return Err(anyhow!("auth rejected: {}", e.message));
}
if pkt.packet_id != PID_SESSION {
return Err(anyhow!("expected SESSION, got 0x{:04X}", pkt.packet_id));
}
let sess: SessionPayload = serde_json::from_slice(&pkt.payload)?;
if pkt.sequence != 1 {
return Err(anyhow!("invalid SESSION sequence"));
}
let sess: SessionPayload = wire::decode(&pkt.payload)?;
// Derive encryption keys from ECDH shared secret
let shared_secret = SessionCrypto::ecdh(eph_sk, &server_eph_pk);
if !shared_secret.was_contributory() {
return Err(anyhow!("invalid server ECDH key"));
}
if sess.session_id.is_empty() || sess.token.is_empty() {
return Err(anyhow!("invalid session response"));
}
let crypto = SessionCrypto::derive(shared_secret.as_bytes(), &sess.session_id);
info!(
"authenticated — session {} encrypted",
&sess.session_id[..8]
sess.session_id.chars().take(8).collect::<String>()
);
Ok((sess.session_id, hello.node_name, hello.private_mode, crypto))