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:
parent
8460fb28fd
commit
3d7dd5413b
65 changed files with 6048 additions and 1156 deletions
|
|
@ -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))
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue