use crate::net::wire; use anyhow::{Result, anyhow}; use tracing::{debug, info}; use super::framing; use super::payloads::*; use super::trust::TransportError; use crate::identity::Identity; const SERVER_HELLO_CONTEXT: &[u8] = b"VNOX-LNEx-v4-server-hello\0"; const CLIENT_AUTH_CONTEXT: &[u8] = b"VNOX-LNEx-v4-client-auth\0"; /// Bytes signed by the server identity: context, TLS exporter, HELLO without signature. pub fn server_hello_transcript(binding: &[u8], unsigned_hello: &[u8]) -> Vec { let mut out = SERVER_HELLO_CONTEXT.to_vec(); out.extend_from_slice(binding); out.extend_from_slice(unsigned_hello); out } /// Bytes signed by the client identity. The TLS exporter makes the signature valid for /// this connection only, so it cannot be relayed to another server or connection. pub fn client_auth_transcript( binding: &[u8], signed_hello: &[u8], unsigned_auth: &[u8], ) -> Vec { let mut out = CLIENT_AUTH_CONTEXT.to_vec(); out.extend_from_slice(binding); out.extend_from_slice(&(signed_hello.len() as u32).to_be_bytes()); out.extend_from_slice(signed_hello); out.extend_from_slice(unsigned_auth); out } /// What the handshake learned about the server and the new session. #[derive(Debug, Clone)] pub struct Outcome { pub session_id: String, pub node_name: String, pub private_mode: bool, pub node_admin: bool, pub live_profiles: bool, pub node_settings: bool, pub channel_structure: bool, pub forums: bool, /// Lower-case hex Ed25519 identity of the server. pub server_identity: String, } /// Perform HELLO, AUTH, SESSION inside an established TLS 1.3 connection. /// /// * `binding` is the TLS exporter value, covered by both signatures. /// * `trust_key` and `expected_identity` implement the identity pin: a server presenting a /// different Ed25519 identity than the stored one is rejected before AUTH is sent. pub async fn run( stream: &mut (impl tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin), identity: &Identity, seq: &mut u32, binding: &[u8], trust_key: &str, expected_identity: Option<&str>, ) -> Result { run_inner( stream, identity, seq, binding, trust_key, expected_identity, None, ) .await } async fn run_inner( stream: &mut (impl tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin), identity: &Identity, seq: &mut u32, binding: &[u8], trust_key: &str, expected_identity: Option<&str>, supplied_proof: Option>, ) -> Result { // HELLO let pkt = framing::read(stream).await?; if pkt.packet_id == PID_ERROR { let e: ErrorPayload = wire::decode(&pkt.payload)?; return Err(anyhow!("server rejected the connection: {}", e.message)); } if pkt.packet_id != PID_HELLO { return Err(anyhow!("expected HELLO, got 0x{:04X}", pkt.packet_id)); } if pkt.sequence != 0 { return Err(anyhow!("invalid HELLO sequence")); } let hello: HelloPayload = wire::decode(&pkt.payload)?; debug!("HELLO node={}", hello.node_name); if hello.lnex_version != LNEX_VERSION { return Err(TransportError::ProtocolMismatch(format!( "The server speaks LNEx {} but this client requires {}. Update the outdated side.", hello.lnex_version, LNEX_VERSION )) .into()); } if hello.server_pubkey.len() != 32 || hello.challenge_nonce.len() != 32 { return Err(anyhow!("invalid server handshake key/challenge")); } 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(); server_key .verify_strict( &server_hello_transcript(binding, &wire::encode(&unsigned_hello)?), &signature, ) .map_err(|_| anyhow!("server handshake signature verification failed"))?; let server_identity = hex::encode(server_public); if let Some(expected) = expected_identity && expected != server_identity { return Err(TransportError::IdentityChanged { address: trust_key.to_string(), expected: expected.to_string(), actual: server_identity, } .into()); } // Keep the full signed hello for the client-auth transcript. let signed_hello = wire::encode(&hello)?; // AUTH let sk = identity .signing_key() .ok_or_else(|| anyhow!("no signing key"))?; use ed25519_dalek::Signer; let account_proof = match supplied_proof { Some(proof) => proof, None => crate::net::account::admission_proof(identity).await?, }; anyhow::ensure!( !account_proof.is_empty(), "Central account sign-in required" ); let mut auth = AuthPayload { client_pubkey: sk.verifying_key().to_bytes().to_vec(), nickname: identity.nickname.clone(), lnex_version: LNEX_VERSION.into(), signature: Vec::new(), account_proof, }; let transcript = client_auth_transcript(binding, &signed_hello, &wire::encode(&auth)?); auth.signature = sk.sign(&transcript).to_bytes().to_vec(); framing::write(stream, PID_AUTH, seq, &wire::encode(&auth)?).await?; debug!("AUTH sent nick={}", identity.nickname); // SESSION let pkt = framing::read(stream).await?; if pkt.packet_id == PID_ERROR { 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)); } if pkt.sequence != 1 { return Err(anyhow!("invalid SESSION sequence")); } let sess: SessionPayload = wire::decode(&pkt.payload)?; if sess.session_id.is_empty() || sess.token.is_empty() { return Err(anyhow!("invalid session response")); } info!( "authenticated, session {}", sess.session_id.chars().take(8).collect::() ); Ok(Outcome { session_id: sess.session_id, node_name: hello.node_name, private_mode: hello.private_mode, node_admin: sess.node_admin, live_profiles: sess.live_profiles, node_settings: sess.node_settings, channel_structure: sess.channel_structure, forums: sess.forums, server_identity, }) } #[cfg(test)] mod tests { use super::*; use ed25519_dalek::{Signer, SigningKey}; use tokio::io::AsyncWriteExt; async fn run_for_test( stream: &mut (impl tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin), identity: &Identity, seq: &mut u32, binding: &[u8], trust_key: &str, expected_identity: Option<&str>, ) -> Result { run_inner( stream, identity, seq, binding, trust_key, expected_identity, Some(b"test-account-proof".to_vec()), ) .await } /// Scripted gateway: sends a HELLO signed over `hello_binding` and returns the AUTH it gets. async fn fake_server( mut stream: tokio::io::DuplexStream, server_key: SigningKey, hello_binding: [u8; 32], version: &str, send_session: bool, ) -> (AuthPayload, Vec) { let mut hello = HelloPayload { lnex_version: version.into(), server_pubkey: server_key.verifying_key().to_bytes().to_vec(), challenge_nonce: vec![7; 32], node_name: "fake".into(), private_mode: true, server_signature: Vec::new(), }; let unsigned = wire::encode(&hello).unwrap(); hello.server_signature = server_key .sign(&server_hello_transcript(&hello_binding, &unsigned)) .to_bytes() .to_vec(); let signed = wire::encode(&hello).unwrap(); let mut seq = 0; framing::write(&mut stream, PID_HELLO, &mut seq, &signed) .await .unwrap(); let Ok(packet) = framing::read(&mut stream).await else { return (AuthPayload::default(), signed); }; let auth: AuthPayload = wire::decode(&packet.payload).unwrap(); if send_session { let session = SessionPayload { session_id: "session-1".into(), token: "token".into(), expires_at: 0, node_admin: false, live_profiles: false, node_settings: false, channel_structure: false, forums: false, }; framing::write( &mut stream, PID_SESSION, &mut seq, &wire::encode(&session).unwrap(), ) .await .unwrap(); } let _ = stream.shutdown().await; (auth, signed) } fn identity() -> Identity { crate::identity::generate("handshake-test") } #[tokio::test] async fn authenticated_handshake_returns_server_identity_and_binds_signature() { let server_key = SigningKey::generate(&mut rand::rng()); let (mut client, server) = tokio::io::duplex(8192); let task = tokio::spawn(fake_server(server, server_key.clone(), [9; 32], "v4", true)); let mut seq = 0; let outcome = run_for_test(&mut client, &identity(), &mut seq, &[9; 32], "h:7600", None) .await .unwrap(); assert_eq!(outcome.session_id, "session-1"); assert_eq!( outcome.server_identity, hex::encode(server_key.verifying_key().to_bytes()) ); // The AUTH signature is valid for this connection and invalid for any other one. let (auth, signed_hello) = task.await.unwrap(); assert_eq!(auth.account_proof, b"test-account-proof"); let client_public = ed25519_dalek::VerifyingKey::from_bytes( &auth.client_pubkey.clone().try_into().unwrap(), ) .unwrap(); let signature = ed25519_dalek::Signature::from_slice(&auth.signature).unwrap(); let mut unsigned_auth = auth.clone(); unsigned_auth.signature.clear(); let unsigned = wire::encode(&unsigned_auth).unwrap(); client_public .verify_strict( &client_auth_transcript(&[9; 32], &signed_hello, &unsigned), &signature, ) .unwrap(); assert!( client_public .verify_strict( &client_auth_transcript(&[8; 32], &signed_hello, &unsigned), &signature ) .is_err(), "a signature made on one TLS connection must not verify on another" ); } #[tokio::test] async fn hello_relayed_from_another_tls_connection_is_rejected() { let server_key = SigningKey::generate(&mut rand::rng()); let (mut client, server) = tokio::io::duplex(8192); // The relay forwards a HELLO signed for a different TLS session. tokio::spawn(fake_server(server, server_key, [1; 32], "v4", false)); let mut seq = 0; let error = run_for_test(&mut client, &identity(), &mut seq, &[2; 32], "h:7600", None) .await .unwrap_err(); assert!(error.to_string().contains("signature verification failed")); assert_eq!(seq, 0, "no AUTH may be sent to an unauthenticated peer"); } #[tokio::test] async fn changed_server_identity_is_blocked_before_auth() { let server_key = SigningKey::generate(&mut rand::rng()); let (mut client, server) = tokio::io::duplex(8192); tokio::spawn(fake_server(server, server_key, [3; 32], "v4", false)); let mut seq = 0; let error = run_for_test( &mut client, &identity(), &mut seq, &[3; 32], "h:7600", Some(&"00".repeat(32)), ) .await .unwrap_err(); assert!(matches!( error.downcast_ref::(), Some(TransportError::IdentityChanged { .. }) )); assert_eq!(seq, 0); } #[tokio::test] async fn old_protocol_version_gives_explicit_error() { let server_key = SigningKey::generate(&mut rand::rng()); let (mut client, server) = tokio::io::duplex(8192); tokio::spawn(fake_server(server, server_key, [4; 32], "v2", false)); let mut seq = 0; let error = run_for_test(&mut client, &identity(), &mut seq, &[4; 32], "h:7600", None) .await .unwrap_err(); assert!(matches!( error.downcast_ref::(), Some(TransportError::ProtocolMismatch(m)) if m.contains("v2") && m.contains("v4") )); } #[tokio::test] async fn empty_account_proof_is_rejected_before_auth() { let key = SigningKey::generate(&mut rand::rng()); let (mut client, server) = tokio::io::duplex(8192); let task = tokio::spawn(fake_server(server, key, [9; 32], "v4", false)); let mut seq = 0; let error = run_inner( &mut client, &identity(), &mut seq, &[9; 32], "h:7600", None, Some(Vec::new()), ) .await .unwrap_err(); assert!( error .to_string() .contains("Central account sign-in required") ); assert_eq!(seq, 0); drop(client); task.await.unwrap(); } } #[cfg(test)] mod capability_tests { use super::*; #[test] fn legacy_sessions_do_not_advertise_admin_and_new_flag_roundtrips() { let legacy: SessionPayload = wire::decode(&[10, 1, b's', 18, 1, b't']).unwrap(); assert!(!legacy.node_admin); assert!(!legacy.live_profiles); let mut privileged = legacy; privileged.node_admin = true; privileged.live_profiles = true; let bytes = wire::encode(&privileged).unwrap(); assert!(wire::decode::(&bytes).unwrap().node_admin); assert!( wire::decode::(&bytes) .unwrap() .live_profiles ); } }