diff --git a/Cargo.lock b/Cargo.lock index 1e6344e..fd2b361 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3020,6 +3020,10 @@ name = "vnox-voice-node" version = "0.1.0" dependencies = [ "anyhow", + "chacha20poly1305", + "hex", + "prost", + "prost-build", "serde", "serde_json", "tokio", diff --git a/Cargo.toml b/Cargo.toml index 772844e..56360e7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -36,3 +36,5 @@ toml = "1.1" reqwest = { version = "0.13.5", default-features = false, features = ["rustls", "json", "form", "query", "stream"] } hmac = "0.13" subtle = "2.6" +prost = "0.14" +prost-build = "0.14" diff --git a/docs/design/channel-authorization.md b/docs/design/channel-authorization.md new file mode 100644 index 0000000..db21961 --- /dev/null +++ b/docs/design/channel-authorization.md @@ -0,0 +1,13 @@ +# Channel and role authorization + +Channel create, edit and delete require guild ownership or actual current guild membership with `MANAGE_CHANNELS`. A stale role assignment does not substitute for membership. Client-supplied guild IDs cannot authorize modification of a channel in another guild: edit/delete use the channel's persisted scope. Global/default channels have no modeled server-administrator account and cannot be mutated through these authenticated user operations. Operators configure them server-side. + +The channel list exposes global channels and only those guild channels where the requester is a member. Member and role lists also require current membership. + +Role management requires `MANAGE_ROLES`, membership and a role belonging to that same guild. Assignment/removal requires the target to be a current guild member. A role manager may grant or manage only permissions they hold; guild owners and administrators bypass that subset check. This prevents a limited role manager from assigning the owner's administrative role or creating an administrator role. Permission queries additionally join on matching role/assignment guild IDs, so legacy invalid cross-guild assignments cannot supply permissions. + +Access mutations take the gateway's shared access write lease. Joins and media authorization take a read lease through their state transition. No client socket write holds this lease. This orders membership/permission removal against issuance of fresh room credentials. + +Deleting a channel clears active text/voice subscriptions, revokes the in-process UDP credentials and closes screen-share ownership/subscriptions before removing cached channel metadata. Removing `VOICE_SPEAK` through role deletion/unassignment rechecks active voice sessions and revokes their credentials and screen shares if no remaining role or owner status supplies permission. Voice reconnection requires fresh authorization. + +This policy currently applies within one gateway process. It does not claim distributed locking across multiple gateways sharing a database. Existing queued delivery and in-flight network traffic obey the documented delivery-time checks and cannot be recalled after transmission. diff --git a/docs/design/media-broadcast.md b/docs/design/media-broadcast.md new file mode 100644 index 0000000..aaf1847 --- /dev/null +++ b/docs/design/media-broadcast.md @@ -0,0 +1,52 @@ +# Authenticated screen broadcast, LNEx media extension + +The gateway authorizes signalling; established WebRTC transports media directly +between consenting clients (ICE + DTLS-SRTP, VP8 video and separate Opus audio). +An initial publisher has at most four viewers. This mesh is deliberately bounded; +an SFU can replace it later inside the combined daemon. No custom packet crypto, +UDP video fragmentation, global discovery signalling endpoint, or separate voice +machine is introduced. + +## Wire contract + +The existing authenticated/encrypted LNEx connection carries protobuf packets +`MediaControl` (0x0180, client→gateway) and `MediaEvent` (0x0181, gateway→client). +Control fields: action(1), channel_id(2), share_id(3), target_session_id(4), body(5), +mline_index(6), application_audio(7), microphone(8). Event has identical fields, +plus server-stamped sender_session_id(9), publisher_user_id(10). Strings are UTF-8; +share_id is a UUID and target_session_id is a server session identifier. Actions: +START=1, STOP=2, WATCH=3, UNWATCH=4, OFFER=5, ANSWER=6, ICE=7. + +START creates one live share per publisher session; its ack and announcement +carry the authenticated publisher identity and track manifest. WATCH is explicit +receiver consent and authorizes only that viewer/publisher pair. The publisher +then sends OFFER; the viewer replies ANSWER; both may send ICE. SDP is limited to +64 KiB and candidates to 2 KiB; no media bytes travel in these packets. The +server never trusts a client-supplied sender, publisher identity, room membership, +or subscription. Clients ignore ICE/answers not matching a live authorized peer. + +Every operation requires authenticated membership in the exact voice channel. +START additionally checks voice-speaking permissions. Guild membership is +revalidated; stale roles do not grant access. Off-channel, unknown-share, +non-owner STOP, unsolicited offers/answers and unsubscribed ICE are rejected. +Channel leave, kick and disconnect revoke shares/subscriptions and emit STOP or +UNWATCH. A viewer's connection is closed on revoke; revocation does not pretend +to erase media already received. Control uses a per-session token bucket of 20 messages/s with a burst of 64; +its entry is removed on revoke/disconnect. Recipient counts are bounded. + +## Client media and explicit consent + +A local portal-approved capture may be published only after a separate user +start action. Video, selected application/output audio and microphone have +independent track IDs and are not mixed. Missing application audio is an error; +it never enables system audio. The microphone follows existing mute permission +and remains disabled unless separately requested. Receiver viewing is opt-in; +video is rendered in memory, audio uses the selected voice output, and closing +stops peer pipelines. Stop closes every peer, clears frames and sends STOP. + +GStreamer webrtcbin provides SDP/ICE/DTLS/SRTP; installed codec/plugin capability +is checked before starting. Host candidates work on reachable networks; optional +administrator-configured STUN/TURN is needed across some NATs. No public relay or +third-party STUN destination is silently chosen. Synthetic two-peer tests must +prove decoded video and distinct application/microphone samples reach the peer; +private desktop/audio capture is never part of automated verification. diff --git a/docs/design/webhook-api.md b/docs/design/webhook-api.md index dbec503..b3f2b16 100644 --- a/docs/design/webhook-api.md +++ b/docs/design/webhook-api.md @@ -1,6 +1,6 @@ # Community webhook API v1 -Additive LNEx packets `0x0200..0x0205` manage channel-scoped integrations over an already authenticated encrypted session. `MANAGE_WEBHOOKS` is permission bit11. Management requires a persisted text channel in a guild, actual current membership, and the permission (or guild ownership). The operational HTTP listener never exposes management APIs. +Additive LNEx packets `0x0200..0x0206` manage channel-scoped integrations over an already authenticated encrypted session. `MANAGE_WEBHOOKS` is permission bit11. Management requires a persisted text channel in a guild, actual current membership, and the permission (or guild ownership). The operational HTTP listener never exposes management APIs. - `WebhookCreate`: channel_id, name, direction (`incoming`/`outgoing`), provider (`generic`/`github`), endpoint for outgoing. - `WebhookList`: channel_id; returns descriptors without secrets. @@ -8,6 +8,8 @@ Additive LNEx packets `0x0200..0x0205` manage channel-scoped integrations over a - `WebhookResult`: descriptor plus new secret only for create/rotate. - `WebhookListResult`: descriptors. Descriptors include suspension state. All management requests use the additive `WebhookRequest` message; the packet identifies the operation. +Requests carry a unique request_id (up to 64 ASCII alphanumeric/hyphen characters), echoed in both success responses and dedicated `WebhookErrorResult` packet `0x0206`. Clients discard stale/unknown replies, including one-time secrets, and refresh after a timeout because a mutation may already have committed. + Only incoming delivery is public HTTP: `POST /v1/webhooks/{webhook_id}`. Generic integrations use `Authorization: Bearer ` and JSON `{ "content": "..." }`; unknown identity/avatar/mention fields are rejected. Optional `Idempotency-Key` deduplicates retries. GitHub adapters verify `X-Hub-Signature-256` over raw bytes and use `X-GitHub-Delivery` for deduplication. GitHub initially supports push, pull_request, issues, release and ping summaries. Delivery body is capped64KiB, content4000characters; mass mention syntax is denied. A webhook sender has a reserved `webhook:` identity, never a user-provided sender ID. Production publishing requires HTTPS proxying; bearer tokens must not appear in URLs or access logs. Incoming generic secrets are random256-bit values stored only as SHA256 hashes. GitHub HMAC and outgoing signing keys require reversible storage and are AEAD-sealed using `VNOX_WEBHOOK_SECRET_KEY` (64hexcharacters, protected environment). Those modes are unavailable if the master key is not configured. Key rotation replaces the active secret and invalidates the old token immediately. No DM/Hub/private-account access is granted. diff --git a/gateway/src/bootstrap/server_identity.rs b/gateway/src/bootstrap/server_identity.rs index aaa9790..ff0382d 100644 --- a/gateway/src/bootstrap/server_identity.rs +++ b/gateway/src/bootstrap/server_identity.rs @@ -3,7 +3,7 @@ use ed25519_dalek::SigningKey; use serde::{Deserialize, Serialize}; use std::path::Path; -#[derive(Debug, Clone, Serialize, Deserialize)] +#[derive(Clone, Serialize, Deserialize)] struct StoredIdentity { pubkey_hex: String, privkey_hex: String, @@ -15,6 +15,10 @@ pub struct ServerIdentity { } impl ServerIdentity { + pub fn sign(&self, message: &[u8]) -> Vec { + use ed25519_dalek::Signer; + self.signing_key.sign(message).to_bytes().to_vec() + } pub fn pubkey_hex(&self) -> String { hex::encode(self.signing_key.verifying_key().to_bytes()) } @@ -22,7 +26,16 @@ impl ServerIdentity { pub fn load_or_generate(data_dir: &Path) -> Result { let path = data_dir.join("server_identity.json"); - if path.exists() { + if std::fs::symlink_metadata(&path).is_ok() { + anyhow::ensure!( + std::fs::symlink_metadata(&path)?.file_type().is_file(), + "server identity must be a regular file" + ); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600))?; + } let text = std::fs::read_to_string(&path)?; let stored: StoredIdentity = serde_json::from_str(&text)?; let signing_key = SigningKey::from_bytes( @@ -50,8 +63,67 @@ impl ServerIdentity { }; std::fs::create_dir_all(data_dir)?; - std::fs::write(&path, serde_json::to_string_pretty(&stored)?)?; + let temporary = data_dir.join(format!(".server-identity-{}.tmp", uuid::Uuid::new_v4())); + let mut options = std::fs::OpenOptions::new(); + options.write(true).create_new(true); + #[cfg(unix)] + { + use std::os::unix::fs::OpenOptionsExt; + options.mode(0o600); + } + let result = (|| -> Result<()> { + use std::io::Write; + let mut file = options.open(&temporary)?; + file.write_all(serde_json::to_string_pretty(&stored)?.as_bytes())?; + file.sync_all()?; + std::fs::hard_link(&temporary, &path)?; + #[cfg(unix)] + std::fs::File::open(data_dir)?.sync_all()?; + Ok(()) + })(); + let _ = std::fs::remove_file(&temporary); + if let Err(error) = result { + if error + .downcast_ref::() + .is_some_and(|e| e.kind() == std::io::ErrorKind::AlreadyExists) + { + return Self::load_or_generate(data_dir); + } + return Err(error); + } Ok(Self { signing_key }) } } + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn gateway_identity_is_private_stable_and_never_replaced() { + let dir = + std::env::temp_dir().join(format!("vnox-private-identity-{}", uuid::Uuid::new_v4())); + let first = ServerIdentity::load_or_generate(&dir).unwrap(); + let second = ServerIdentity::load_or_generate(&dir).unwrap(); + assert_eq!(first.pubkey_hex(), second.pubkey_hex()); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + assert_eq!( + std::fs::metadata(dir.join("server_identity.json")) + .unwrap() + .permissions() + .mode() + & 0o777, + 0o600 + ); + } + std::fs::write(dir.join("server_identity.json"), "corrupt").unwrap(); + assert!(ServerIdentity::load_or_generate(&dir).is_err()); + assert_eq!( + std::fs::read_to_string(dir.join("server_identity.json")).unwrap(), + "corrupt" + ); + std::fs::remove_dir_all(dir).unwrap(); + } +} diff --git a/gateway/src/domain/auth.rs b/gateway/src/domain/auth.rs index ce690e9..4f9d2e2 100644 --- a/gateway/src/domain/auth.rs +++ b/gateway/src/domain/auth.rs @@ -2,7 +2,7 @@ use anyhow::Result; use ed25519_dalek::{Signature, VerifyingKey}; /// Verify Ed25519 signature from AUTH packet. -pub fn verify_auth(challenge: &[u8; 32], pubkey: &[u8; 32], signature: &[u8; 64]) -> Result<()> { +pub fn verify_auth(challenge: &[u8], pubkey: &[u8; 32], signature: &[u8; 64]) -> Result<()> { let key = VerifyingKey::from_bytes(pubkey).map_err(|_| anyhow::anyhow!("invalid pubkey"))?; let sig = Signature::from_bytes(signature); key.verify_strict(challenge, &sig) diff --git a/gateway/src/domain/session.rs b/gateway/src/domain/session.rs index 977a975..6ff65e1 100644 --- a/gateway/src/domain/session.rs +++ b/gateway/src/domain/session.rs @@ -9,7 +9,9 @@ pub struct Session { pub token: String, pub user_id: String, pub nickname: String, + /// Viewed text channel; independent of the active voice room. pub channel_id: Option, + pub voice_channel_id: Option, } pub type SessionStore = Arc>>; @@ -25,6 +27,7 @@ pub async fn create(store: &SessionStore, user_id: String, nickname: String) -> user_id, nickname, channel_id: None, + voice_channel_id: None, }; store.write().await.insert(s.session_id.clone(), s.clone()); s diff --git a/gateway/src/domain/storage/guilds/roles.rs b/gateway/src/domain/storage/guilds/roles.rs index 2b83898..c410965 100644 --- a/gateway/src/domain/storage/guilds/roles.rs +++ b/gateway/src/domain/storage/guilds/roles.rs @@ -64,7 +64,7 @@ impl super::super::Storage { match &self.pool { Pool::Sqlite(p) => Ok(sqlx::query_as::<_, RoleRow>( "SELECT r.id,r.guild_id,r.name,r.color,r.permissions,r.position \ - FROM roles r JOIN member_roles mr ON r.id=mr.role_id \ + FROM roles r JOIN member_roles mr ON r.id=mr.role_id AND r.guild_id=mr.guild_id \ WHERE mr.guild_id=? AND mr.user_id=? ORDER BY r.position DESC", ) .bind(guild_id) @@ -73,7 +73,7 @@ impl super::super::Storage { .await?), Pool::Postgres(p) => Ok(sqlx::query_as::<_, RoleRow>( "SELECT r.id,r.guild_id,r.name,r.color,r.permissions,r.position \ - FROM roles r JOIN member_roles mr ON r.id=mr.role_id \ + FROM roles r JOIN member_roles mr ON r.id=mr.role_id AND r.guild_id=mr.guild_id \ WHERE mr.guild_id=$1 AND mr.user_id=$2 ORDER BY r.position DESC", ) .bind(guild_id) @@ -92,7 +92,7 @@ impl super::super::Storage { Pool::Sqlite(p) => { let rows: Vec

= sqlx::query_as::<_, P>( "SELECT r.permissions FROM roles r \ - JOIN member_roles mr ON r.id=mr.role_id \ + JOIN member_roles mr ON r.id=mr.role_id AND r.guild_id=mr.guild_id \ WHERE mr.guild_id=? AND mr.user_id=?", ) .bind(guild_id) @@ -104,7 +104,7 @@ impl super::super::Storage { Pool::Postgres(p) => { let rows: Vec

= sqlx::query_as::<_, P>( "SELECT r.permissions FROM roles r \ - JOIN member_roles mr ON r.id=mr.role_id \ + JOIN member_roles mr ON r.id=mr.role_id AND r.guild_id=mr.guild_id \ WHERE mr.guild_id=$1 AND mr.user_id=$2", ) .bind(guild_id) diff --git a/gateway/src/handler/channel/create.rs b/gateway/src/handler/channel/create.rs index 8d6f6c7..728961e 100644 --- a/gateway/src/handler/channel/create.rs +++ b/gateway/src/handler/channel/create.rs @@ -5,10 +5,7 @@ use tracing::{info, warn}; use crate::{ domain::{channels, session}, - net::{ - io, - state::{BroadcastMsg, State}, - }, + net::{io, state::State}, proto::{ ChannelCreatePayload, ChannelDeletePayload, ChannelListItem, ChannelListPayload, ChannelStatePayload, PacketId, SessionCrypto, encode_packet, to_payload, @@ -62,7 +59,12 @@ pub async fn handle_channel_create( req.channel_name.trim().to_string() }; - if channel_id.is_empty() { + if channel_id.is_empty() + || channel_id.len() > 128 + || channel_name.chars().count() > 100 + || channel_id.chars().any(char::is_control) + || channel_name.chars().any(char::is_control) + { io::send_encrypted( stream, PacketId::Error, @@ -96,6 +98,13 @@ pub async fn handle_channel_create( return Ok(()); } + let access = state.access.write().await; + if !super::may_manage(state, &sess.user_id, req.guild_id.as_deref()).await? { + drop(access); + super::denied(stream, seq, crypto).await?; + return Ok(()); + } + let guild_id = req.guild_id.clone(); let created = channels::create( @@ -107,10 +116,8 @@ pub async fn handle_channel_create( ) .await; - // Persist to DB (best-effort, log and continue on failure). - #[allow(clippy::collapsible_if)] - if created { - if let Err(e) = state + if created + && let Err(error) = state .storage .create_channel( &channel_id, @@ -119,11 +126,12 @@ pub async fn handle_channel_create( guild_id.as_deref(), ) .await - { - warn!("failed to persist channel to storage: {e}"); - } + { + channels::delete(&state.channels, &channel_id).await; + return Err(error); } + drop(access); if !created { io::send_encrypted( stream, @@ -165,22 +173,22 @@ pub async fn handle_channel_create( ) .await?; - // Broadcast a ChannelCreate event to all other sessions so their sidebars update. - let _ = state.broadcast.send(BroadcastMsg { - channel_id: None, - exclude_session: Some(session_id.into()), - target_session_id: None, - data: encode_packet( + super::notify_guild( + state, + guild_id.as_deref(), + Some(session_id), + encode_packet( PacketId::ChannelCreate, 0, &to_payload(&ChannelCreatePayload { channel_id: channel_id.clone(), channel_name: channel_name.clone(), kind: kind.as_str().into(), - guild_id: req.guild_id.clone(), + guild_id: guild_id.clone(), }), ), - }); + ) + .await?; Ok(()) } @@ -217,15 +225,23 @@ pub async fn handle_channel_delete( return Ok(()); } - let existed = channels::delete(&state.channels, &req.channel_id).await; - - // Remove from DB (best-effort). - #[allow(clippy::collapsible_if)] - if existed { - if let Err(e) = state.storage.delete_channel(&req.channel_id).await { - warn!("failed to remove channel from storage: {e}"); - } + let access = state.access.write().await; + let channel = channels::get_channel(&state.channels, &req.channel_id).await; + if !super::may_manage( + state, + &sess.user_id, + channel.as_ref().and_then(|c| c.guild_id.as_deref()), + ) + .await? + { + drop(access); + super::denied(stream, seq, crypto).await?; + return Ok(()); } + state.storage.delete_channel(&req.channel_id).await?; + super::revoke_channel(state, &req.channel_id).await; + let existed = channels::delete(&state.channels, &req.channel_id).await; + drop(access); if !existed { io::send_encrypted( @@ -247,19 +263,21 @@ pub async fn handle_channel_delete( req.channel_id, sess.nickname ); - // Broadcast deletion to all sessions. - let _ = state.broadcast.send(BroadcastMsg { - channel_id: None, - exclude_session: Some(session_id.into()), - target_session_id: None, - data: encode_packet( + super::notify_guild( + state, + channel + .as_ref() + .and_then(|channel| channel.guild_id.as_deref()), + None, + encode_packet( PacketId::ChannelDelete, 0, &to_payload(&ChannelDeletePayload { channel_id: req.channel_id.clone(), }), ), - }); + ) + .await?; Ok(()) } @@ -273,7 +291,10 @@ pub async fn handle_channel_list( crypto: &SessionCrypto, state: &State, ) -> Result<()> { - let _sess = session::get(&state.sessions, session_id).await; + let Some(sess) = session::get(&state.sessions, session_id).await else { + return Ok(()); + }; + let guilds = state.storage.list_user_guilds(&sess.user_id).await?; // Decode optional guild_id filter from request. let filter_guild_id = if !payload.is_empty() { @@ -286,6 +307,11 @@ pub async fn handle_channel_list( let channels = channels::list(&state.channels).await; let items: Vec = channels .iter() + .filter(|c| { + c.guild_id + .as_ref() + .is_none_or(|guild| guilds.iter().any(|g| &g.id == guild)) + }) .filter(|c| { filter_guild_id .as_ref() diff --git a/gateway/src/handler/channel/edit.rs b/gateway/src/handler/channel/edit.rs index ca69ed3..4649703 100644 --- a/gateway/src/handler/channel/edit.rs +++ b/gateway/src/handler/channel/edit.rs @@ -1,14 +1,11 @@ use anyhow::Result; use prost::Message; use tokio::io::{AsyncRead, AsyncWrite}; -use tracing::{info, warn}; +use tracing::info; use crate::{ domain::{channels, session}, - net::{ - io, - state::{BroadcastMsg, State}, - }, + net::{io, state::State}, proto::{ChannelEditPayload, PacketId, SessionCrypto, encode_packet, to_payload}, }; @@ -29,7 +26,12 @@ pub async fn handle_channel_edit( let channel_id = req.channel_id.trim().to_string(); let channel_name = req.channel_name.trim().to_string(); - if channel_id.is_empty() || channel_name.is_empty() { + if channel_id.is_empty() + || channel_name.is_empty() + || channel_id.len() > 128 + || channel_name.chars().count() > 100 + || channel_name.chars().any(char::is_control) + { io::send_encrypted( stream, PacketId::Error, @@ -44,8 +46,26 @@ pub async fn handle_channel_edit( return Ok(()); } + let access = state.access.write().await; + let channel = channels::get_channel(&state.channels, &channel_id).await; + if !super::may_manage( + state, + &sess.user_id, + channel.as_ref().and_then(|c| c.guild_id.as_deref()), + ) + .await? + { + drop(access); + super::denied(stream, seq, crypto).await?; + return Ok(()); + } + state + .storage + .update_channel(&channel_id, &channel_name) + .await?; let renamed = channels::rename(&state.channels, &channel_id, &channel_name).await; + drop(access); if !renamed { io::send_encrypted( stream, @@ -61,24 +81,18 @@ pub async fn handle_channel_edit( return Ok(()); } - if let Err(e) = state - .storage - .update_channel(&channel_id, &channel_name) - .await - { - warn!("failed to update channel in storage: {e}"); - } - info!( "channel_edit: '{}' renamed to '{}' by {}", channel_id, channel_name, sess.nickname ); - let _ = state.broadcast.send(BroadcastMsg { - channel_id: Some(channel_id.clone()), - exclude_session: Some(session_id.into()), - target_session_id: None, - data: encode_packet( + super::notify_guild( + state, + channel + .as_ref() + .and_then(|channel| channel.guild_id.as_deref()), + None, + encode_packet( PacketId::ChannelEdit, 0, &to_payload(&ChannelEditPayload { @@ -86,7 +100,8 @@ pub async fn handle_channel_edit( channel_name: channel_name.clone(), }), ), - }); + ) + .await?; Ok(()) } diff --git a/gateway/src/handler/channel/join.rs b/gateway/src/handler/channel/join.rs index 766ae59..6975f5f 100644 --- a/gateway/src/handler/channel/join.rs +++ b/gateway/src/handler/channel/join.rs @@ -1,9 +1,4 @@ -use std::net::SocketAddr; - -use anyhow::Result; -use tokio::io::{AsyncRead, AsyncWrite}; -use tracing::info; - +use super::{broadcast_leave, set_channel, set_voice_channel}; use crate::{ domain::{channels, session}, net::{ @@ -15,11 +10,11 @@ use crate::{ UserJoinPayload, encode_packet, to_payload, }, }; - -use super::{broadcast_leave, set_channel}; - +use anyhow::Result; +use std::net::SocketAddr; +use tokio::io::{AsyncRead, AsyncWrite}; const HISTORY_LIMIT: i64 = 50; - +#[allow(clippy::too_many_arguments)] pub async fn join( stream: &mut (impl AsyncRead + AsyncWrite + Unpin), seq: &mut u32, @@ -27,135 +22,224 @@ pub async fn join( channel_id: &str, crypto: &SessionCrypto, state: &State, - addr: SocketAddr, + _addr: SocketAddr, ) -> Result<()> { + let guard = state.access.read().await; let Some(sess) = session::get(&state.sessions, session_id).await else { return Ok(()); }; - let prev_channel = sess.channel_id; - - let ch = match channels::get_channel(&state.channels, channel_id).await { - Some(c) => c, - None => { - io::send_encrypted( - stream, - PacketId::Error, - seq, - &to_payload(&proto::ErrorPayload { - code: proto::ErrorCode::ChannelNotFound as u32, - message: "not found".into(), - }), - crypto, - ) - .await?; - return Ok(()); - } + let Some(ch) = channels::get_channel(&state.channels, channel_id).await else { + drop(guard); + return io::send_encrypted( + stream, + PacketId::Error, + seq, + &to_payload(&proto::ErrorPayload { + code: proto::ErrorCode::ChannelNotFound as u32, + message: "not found".into(), + }), + crypto, + ) + .await; }; - - // Validate the destination before changing membership or exposing its history. - // Role assignments alone are insufficient: a kicked user can retain stale roles. - if let Some(guild_id) = ch.guild_id.as_deref() { - let is_member = state + if let Some(guild) = &ch.guild_id + && !state .storage .list_user_guilds(&sess.user_id) .await? .iter() - .any(|guild| guild.id == guild_id); - if !is_member { - io::send_encrypted( + .any(|g| g.id == *guild) + { + drop(guard); + return io::send_encrypted( + stream, + PacketId::Error, + seq, + &to_payload(&proto::ErrorPayload { + code: proto::ErrorCode::PermissionDenied as u32, + message: "guild membership required".into(), + }), + crypto, + ) + .await; + } + let is_voice = ch.kind == channels::ChannelKind::Voice; + if is_voice && state.voice_member_tx.is_none() { + drop(guard); + return io::send_encrypted( + stream, + PacketId::Error, + seq, + &to_payload(&proto::ErrorPayload { + code: proto::ErrorCode::NodeUnavailable as u32, + message: "voice requires the combined server process".into(), + }), + crypto, + ) + .await; + } + if is_voice && let Some(guild) = &ch.guild_id { + let owner = state + .storage + .get_guild(guild) + .await? + .is_some_and(|g| g.owner_id == sess.user_id); + let perms = state + .storage + .get_user_role_perms(guild, &sess.user_id) + .await?; + if !owner + && !crate::domain::permissions::Permissions::from_role_perms(&perms) + .has(crate::domain::permissions::Permissions::VOICE_SPEAK) + { + drop(guard); + return io::send_encrypted( stream, PacketId::Error, seq, &to_payload(&proto::ErrorPayload { code: proto::ErrorCode::PermissionDenied as u32, - message: "guild membership required".into(), + message: "VOICE_SPEAK permission required".into(), }), crypto, ) - .await?; - return Ok(()); + .await; } } - - if prev_channel.as_deref() == Some(channel_id) { + let previous = if is_voice { + sess.voice_channel_id.clone() + } else { + sess.channel_id.clone() + }; + if previous.as_deref() == Some(channel_id) { return Ok(()); } - - if let Some(prev) = prev_channel { - channels::leave(&state.channels, &prev, session_id).await; - broadcast_leave(state, &prev, session_id).await; + if let Some(previous) = previous { + channels::leave(&state.channels, &previous, session_id).await; + broadcast_leave(state, &previous, session_id).await; + if is_voice { + state.media.revoke(state, session_id).await; + if let Some(tx) = &state.voice_member_tx { + let _=tx.send(serde_json::json!({"type":"leave","session_id":session_id,"channel_id":previous,"user_id":sess.user_id}).to_string()); + } + } } - channels::join(&state.channels, channel_id, session_id).await; - set_channel(state, session_id, Some(channel_id.into())).await; - + if is_voice { + set_voice_channel(state, session_id, Some(channel_id.into())).await; + } else { + set_channel(state, session_id, Some(channel_id.into())).await; + } + // Issue/revoke credentials while access mutations are serialized. Never hold this guard while writing to a client socket. + let credentials = if is_voice { + if let Some(tx) = &state.voice_member_tx { + use rand::Rng; + let (route_id, c2s_key, s2c_key) = { + let mut rng = rand::rng(); + let mut r = [0u8; 16]; + let mut c = [0u8; 32]; + let mut s = [0u8; 32]; + rng.fill_bytes(&mut r); + rng.fill_bytes(&mut c); + rng.fill_bytes(&mut s); + (r, c, s) + }; + let event = serde_json::json!({"type":"join","session_id":session_id,"channel_id":channel_id,"user_id":sess.user_id,"route_id":hex::encode(route_id),"c2s_key":hex::encode(c2s_key),"s2c_key":hex::encode(s2c_key)}); + if tx.send(event.to_string()).is_err() { + channels::leave(&state.channels, channel_id, session_id).await; + set_voice_channel(state, session_id, None).await; + drop(guard); + return io::send_encrypted( + stream, + PacketId::Error, + seq, + &to_payload(&proto::ErrorPayload { + code: proto::ErrorCode::NodeUnavailable as u32, + message: "voice service unavailable".into(), + }), + crypto, + ) + .await; + } + Some(proto::VoiceSession { + route_id: route_id.to_vec(), + c2s_key: c2s_key.to_vec(), + s2c_key: s2c_key.to_vec(), + channel_id: channel_id.into(), + }) + } else { + None + } + } else { + None + }; let mut members = Vec::new(); for sid in channels::members(&state.channels, channel_id).await { if let Some(s) = session::get(&state.sessions, &sid).await { members.push(MemberInfo { - user_id: s.user_id.clone(), - nickname: s.nickname.clone(), - in_voice: ch.kind == channels::ChannelKind::Voice, + user_id: s.user_id, + nickname: s.nickname, + in_voice: is_voice, }); } } - - let sp = ChannelStatePayload { - channel_id: ch.id.clone(), - channel_name: ch.name.clone(), + let message = UserJoinPayload { + channel_id: channel_id.into(), + user_id: sess.user_id, + nickname: sess.nickname, + }; + let _ = state.broadcast.send(BroadcastMsg { + channel_id: Some(channel_id.into()), + exclude_session: Some(session_id.into()), + target_session_id: None, + data: encode_packet(PacketId::UserJoin, 0, &to_payload(&message)), + }); + drop(guard); + let payload = ChannelStatePayload { + channel_id: ch.id, + channel_name: ch.name, kind: ch.kind.as_str().into(), members, voice_endpoint: state.config.voice.bind.clone(), - guild_id: ch.guild_id.clone(), + guild_id: ch.guild_id, }; io::send_encrypted( stream, PacketId::ChannelState, seq, - &to_payload(&sp), + &to_payload(&payload), crypto, ) .await?; - - let history = state.storage.get_history(channel_id, HISTORY_LIMIT).await?; - if !history.is_empty() { - let hp = ChatHistoryPayload { - channel_id: channel_id.into(), - messages: history, - }; - io::send_encrypted(stream, PacketId::ChatHistory, seq, &to_payload(&hp), crypto).await?; + if let Some(credentials) = credentials { + io::send_encrypted( + stream, + PacketId::VoiceSession, + seq, + &to_payload(&credentials), + crypto, + ) + .await?; } - - if let Some(sess) = session::get(&state.sessions, session_id).await { - let jp = UserJoinPayload { - channel_id: channel_id.into(), - user_id: sess.user_id.clone(), - nickname: sess.nickname.clone(), - }; - let _ = state.broadcast.send(BroadcastMsg { - channel_id: Some(channel_id.into()), - exclude_session: Some(session_id.into()), - target_session_id: None, - data: encode_packet(PacketId::UserJoin, 0, &to_payload(&jp)), - }); + if !is_voice { + let history = state.storage.get_history(channel_id, HISTORY_LIMIT).await?; + if !history.is_empty() { + let _ = state.broadcast.send(BroadcastMsg { + channel_id: Some(channel_id.into()), + exclude_session: None, + target_session_id: Some(session_id.into()), + data: encode_packet( + PacketId::ChatHistory, + 0, + &to_payload(&ChatHistoryPayload { + channel_id: channel_id.into(), + messages: history, + }), + ), + }); + } } - - if ch.kind == channels::ChannelKind::Voice - && let Some(tx) = &state.voice_member_tx - && let Some(sess) = session::get(&state.sessions, session_id).await - { - let event = serde_json::json!({ - "type": "join", - "channel_id": channel_id, - "user_id": sess.user_id, - "endpoint": format!("{}:{}", addr.ip(), addr.port()), - }); - let _ = tx.send(event.to_string()); - } - - info!("session {} joined {channel_id}", &session_id[..8]); Ok(()) } - #[cfg(test)] mod tests; diff --git a/gateway/src/handler/channel/join/tests.rs b/gateway/src/handler/channel/join/tests.rs index 5fec427..0a865a1 100644 --- a/gateway/src/handler/channel/join/tests.rs +++ b/gateway/src/handler/channel/join/tests.rs @@ -143,3 +143,574 @@ async fn guild_member_can_switch_channels() { Some("private") ); } + +#[tokio::test] +async fn text_navigation_preserves_voice_and_leaving_unrelated_channel_is_noop() { + let (mut state, sid) = fixture().await; + let (tx, mut rx) = tokio::sync::broadcast::channel(16); + tokio::spawn(async move { while rx.recv().await.is_ok() {} }); + state.voice_member_tx = Some(tx); + attempt_join(&state, &sid, "voice").await; + let sess = session::get(&state.sessions, &sid).await.unwrap(); + assert_eq!(sess.channel_id.as_deref(), Some("general")); + assert_eq!(sess.voice_channel_id.as_deref(), Some("voice")); + channels::create( + &state.channels, + "other-text", + "Other", + channels::ChannelKind::Text, + None, + ) + .await; + attempt_join(&state, &sid, "other-text").await; + assert!( + channels::members(&state.channels, "voice") + .await + .contains(&sid) + ); + let (mut stream, _) = tokio::io::duplex(65536); + super::super::leave( + &mut stream, + &mut 0, + &sid, + "general", + &SessionCrypto::derive(&[7; 32], &sid), + &state, + ) + .await + .unwrap(); + let sess = session::get(&state.sessions, &sid).await.unwrap(); + assert_eq!(sess.channel_id.as_deref(), Some("other-text")); + assert_eq!(sess.voice_channel_id.as_deref(), Some("voice")); + super::super::leave( + &mut stream, + &mut 0, + &sid, + "voice", + &SessionCrypto::derive(&[7; 32], &sid), + &state, + ) + .await + .unwrap(); + let sess = session::get(&state.sessions, &sid).await.unwrap(); + assert_eq!(sess.channel_id.as_deref(), Some("other-text")); + assert_eq!(sess.voice_channel_id, None); +} + +#[tokio::test] +async fn channel_mutations_require_guild_authority_and_deletion_revokes_voice_credentials() { + use crate::proto::{ChannelDeletePayload, ChannelEditPayload}; + let (mut state, sid) = fixture().await; + let guild = state + .storage + .create_guild("owner", "Private") + .await + .unwrap(); + channels::create( + &state.channels, + "managed", + "Managed", + channels::ChannelKind::Voice, + Some(guild.clone()), + ) + .await; + state + .storage + .create_channel("managed", "Managed", "voice", Some(&guild)) + .await + .unwrap(); + let (mut stream, _peer) = tokio::io::duplex(65536); + let crypto = SessionCrypto::derive(&[7; 32], &sid); + crate::handler::channel::handle_channel_edit( + &mut stream, + &mut 0, + &sid, + &to_payload(&ChannelEditPayload { + channel_id: "managed".into(), + channel_name: "stolen".into(), + }), + &crypto, + &state, + ) + .await + .unwrap(); + assert_eq!( + channels::get_channel(&state.channels, "managed") + .await + .unwrap() + .name, + "Managed" + ); + crate::handler::channel::handle_channel_delete( + &mut stream, + &mut 0, + &sid, + &to_payload(&ChannelDeletePayload { + channel_id: "managed".into(), + }), + &crypto, + &state, + ) + .await + .unwrap(); + assert!( + channels::get_channel(&state.channels, "managed") + .await + .is_some() + ); + assert!( + !super::super::may_manage(&state, "owner", None) + .await + .unwrap() + ); + let owner = session::create(&state.sessions, "owner".into(), "Owner".into()).await; + channels::join(&state.channels, "managed", &owner.session_id).await; + super::super::set_voice_channel(&state, &owner.session_id, Some("managed".into())).await; + let (tx, mut rx) = tokio::sync::broadcast::channel(8); + state.voice_member_tx = Some(tx); + crate::handler::channel::handle_channel_delete( + &mut stream, + &mut 0, + &owner.session_id, + &to_payload(&ChannelDeletePayload { + channel_id: "managed".into(), + }), + &crypto, + &state, + ) + .await + .unwrap(); + assert!( + channels::get_channel(&state.channels, "managed") + .await + .is_none() + ); + assert!( + session::get(&state.sessions, &owner.session_id) + .await + .unwrap() + .voice_channel_id + .is_none() + ); + let event: serde_json::Value = serde_json::from_str(&rx.try_recv().unwrap()).unwrap(); + assert_eq!(event["type"], "leave"); + assert_eq!(event["session_id"], owner.session_id); +} + +#[tokio::test] +async fn guild_role_handlers_reject_cross_guild_targets_and_privilege_escalation() { + use crate::domain::permissions::Permissions; + use crate::proto::{RoleAssignPayload, RoleDeletePayload}; + let (state, sid) = fixture().await; + let guild = state + .storage + .create_guild("visitor", "Owned") + .await + .unwrap(); + let other = state + .storage + .create_guild("elsewhere", "Other") + .await + .unwrap(); + let foreign = state + .storage + .create_role( + &other, + "foreign", + "#fff", + Permissions::ADMINISTRATOR.bits(), + 1, + ) + .await + .unwrap(); + let (mut stream, _peer) = tokio::io::duplex(65536); + let crypto = SessionCrypto::derive(&[7; 32], &sid); + crate::handler::guild::handle_role_assign( + &mut stream, + &mut 0, + &sid, + &to_payload(&RoleAssignPayload { + guild_id: guild.clone(), + user_id: "visitor".into(), + role_id: foreign.clone(), + }), + &crypto, + &state, + ) + .await + .unwrap(); + crate::handler::guild::handle_role_delete( + &mut stream, + &mut 0, + &sid, + &to_payload(&RoleDeletePayload { + guild_id: guild.clone(), + role_id: foreign.clone(), + }), + &crypto, + &state, + ) + .await + .unwrap(); + assert!( + state + .storage + .list_guild_roles(&other) + .await + .unwrap() + .iter() + .any(|r| r.id == foreign) + ); + let otherguild = state + .storage + .create_guild("owner", "Managed") + .await + .unwrap(); + state + .storage + .add_guild_member(&otherguild, "visitor") + .await + .unwrap(); + let manager = state + .storage + .create_role( + &otherguild, + "manager", + "#fff", + Permissions::MANAGE_ROLES.bits(), + 1, + ) + .await + .unwrap(); + state + .storage + .assign_role(&otherguild, "visitor", &manager) + .await + .unwrap(); + let powerful = state + .storage + .create_role( + &otherguild, + "admin", + "#fff", + Permissions::ADMINISTRATOR.bits(), + 2, + ) + .await + .unwrap(); + crate::handler::guild::handle_role_assign( + &mut stream, + &mut 0, + &sid, + &to_payload(&RoleAssignPayload { + guild_id: otherguild.clone(), + user_id: "visitor".into(), + role_id: powerful, + }), + &crypto, + &state, + ) + .await + .unwrap(); + let actual = Permissions::from_role_perms( + &state + .storage + .get_user_role_perms(&otherguild, "visitor") + .await + .unwrap(), + ); + assert!(!actual.contains(Permissions::ADMINISTRATOR)); +} + +#[tokio::test] +async fn removing_voice_role_revokes_existing_udp_membership() { + use crate::domain::permissions::Permissions; + use crate::proto::RoleAssignPayload; + let (mut state, sid) = fixture().await; + let guild = state + .storage + .create_guild("owner", "Private") + .await + .unwrap(); + state + .storage + .add_guild_member(&guild, "visitor") + .await + .unwrap(); + let role = state + .storage + .create_role( + &guild, + "speaker", + "#fff", + Permissions::VOICE_SPEAK.bits(), + 1, + ) + .await + .unwrap(); + state + .storage + .assign_role(&guild, "visitor", &role) + .await + .unwrap(); + channels::create( + &state.channels, + "managed", + "Managed", + channels::ChannelKind::Voice, + Some(guild.clone()), + ) + .await; + channels::join(&state.channels, "managed", &sid).await; + super::super::set_voice_channel(&state, &sid, Some("managed".into())).await; + let owner = session::create(&state.sessions, "owner".into(), "Owner".into()).await; + let (tx, mut rx) = tokio::sync::broadcast::channel(8); + state.voice_member_tx = Some(tx); + let (mut stream, _peer) = tokio::io::duplex(65536); + crate::handler::guild::handle_role_unassign( + &mut stream, + &mut 0, + &owner.session_id, + &to_payload(&RoleAssignPayload { + guild_id: guild, + user_id: "visitor".into(), + role_id: role, + }), + &SessionCrypto::derive(&[7; 32], &owner.session_id), + &state, + ) + .await + .unwrap(); + assert!( + session::get(&state.sessions, &sid) + .await + .unwrap() + .voice_channel_id + .is_none() + ); + assert!( + !channels::members(&state.channels, "managed") + .await + .contains(&sid) + ); + let event: serde_json::Value = serde_json::from_str(&rx.try_recv().unwrap()).unwrap(); + assert_eq!(event["type"], "leave"); + assert_eq!(event["session_id"], sid); +} + +#[tokio::test] +async fn private_channel_notifications_target_members_and_acknowledge_editor() { + use crate::proto::{ChannelCreatePayload, ChannelDeletePayload, ChannelEditPayload}; + let (state, owner_sid) = fixture().await; + let guild = state + .storage + .create_guild("visitor", "Private") + .await + .unwrap(); + state + .storage + .add_guild_member(&guild, "member") + .await + .unwrap(); + let member = session::create(&state.sessions, "member".into(), "Member".into()).await; + let outsider = session::create(&state.sessions, "outsider".into(), "Outsider".into()).await; + let mut events = state.broadcast.subscribe(); + let crypto = SessionCrypto::derive(&[7; 32], &owner_sid); + let (mut stream, _peer) = tokio::io::duplex(65536); + let creation = ChannelCreatePayload { + channel_id: "private-notification".into(), + channel_name: "Private name".into(), + kind: "text".into(), + guild_id: Some(guild.clone()), + }; + crate::handler::channel::handle_channel_create( + &mut stream, + &mut 0, + &owner_sid, + &to_payload(&creation), + &crypto, + &state, + ) + .await + .unwrap(); + crate::handler::channel::handle_channel_edit( + &mut stream, + &mut 0, + &owner_sid, + &to_payload(&ChannelEditPayload { + channel_id: creation.channel_id.clone(), + channel_name: "Renamed privately".into(), + }), + &crypto, + &state, + ) + .await + .unwrap(); + crate::handler::channel::handle_channel_delete( + &mut stream, + &mut 0, + &owner_sid, + &to_payload(&ChannelDeletePayload { + channel_id: creation.channel_id.clone(), + }), + &crypto, + &state, + ) + .await + .unwrap(); + let mut notifications = Vec::new(); + while let Ok(event) = events.try_recv() { + notifications.push(event) + } + assert_eq!(notifications.len(), 5); + assert!(notifications.iter().all(|event|matches!(event.target_session_id.as_deref(),Some(id) if id==owner_sid || id==member.session_id))); + assert!( + notifications + .iter() + .all(|event| event.target_session_id.as_deref() != Some(&outsider.session_id)) + ); + assert!( + notifications.iter().any( + |event| event.target_session_id.as_deref() == Some(&owner_sid) + && crate::proto::PacketHeader::from_bytes(event.data[..12].try_into().unwrap()) + .packet_id + == PacketId::ChannelEdit as u16 + ) + ); + assert!( + super::super::may_deliver_metadata( + &state, + &member.session_id, + PacketId::ChannelCreate, + &to_payload(&creation) + ) + .await + ); + state + .storage + .remove_guild_member(&guild, "member") + .await + .unwrap(); + assert!( + !super::super::may_deliver_metadata( + &state, + &member.session_id, + PacketId::ChannelCreate, + &to_payload(&creation) + ) + .await + ); +} + +#[tokio::test] +async fn queued_targeted_history_is_rechecked_after_leave_or_guild_revoke() { + use std::time::Duration; + use tokio::io::AsyncReadExt; + let (state, sid) = fixture().await; + let crypto = SessionCrypto::derive(&[7; 32], &sid); + let history = |channel: &str| BroadcastMsg { + channel_id: Some(channel.into()), + exclude_session: None, + target_session_id: Some(sid.clone()), + data: encode_packet( + PacketId::ChatHistory, + 0, + &to_payload(&ChatHistoryPayload { + channel_id: channel.into(), + messages: vec![], + }), + ), + }; + // The same queued target/channel envelope is deliverable while subscribed. + let (mut stream, mut peer) = tokio::io::duplex(65536); + let mut seq = 2; + crate::handler::deliver::deliver_encrypted( + &mut stream, + &mut seq, + &sid, + &history("general"), + &crypto, + &state, + ) + .await + .unwrap(); + let mut first = [0u8; 12]; + peer.read_exact(&mut first).await.unwrap(); + assert_eq!( + u16::from_be_bytes(first[..2].try_into().unwrap()), + PacketId::ChatHistory as u16 + ); + assert_eq!(seq, 3); + + super::super::leave(&mut stream, &mut seq, &sid, "general", &crypto, &state) + .await + .unwrap(); + let (mut stream, mut peer) = tokio::io::duplex(65536); + crate::handler::deliver::deliver_encrypted( + &mut stream, + &mut seq, + &sid, + &history("general"), + &crypto, + &state, + ) + .await + .unwrap(); + assert_eq!( + seq, 3, + "discarded history cannot consume an encryption sequence" + ); + assert!( + tokio::time::timeout(Duration::from_millis(15), peer.read_u8()) + .await + .is_err() + ); + + let guild = state + .storage + .create_guild("owner", "Private history") + .await + .unwrap(); + state + .storage + .add_guild_member(&guild, "visitor") + .await + .unwrap(); + channels::create( + &state.channels, + "private-history", + "Private", + channels::ChannelKind::Text, + Some(guild.clone()), + ) + .await; + attempt_join(&state, &sid, "private-history").await; + let queued = history("private-history"); + { + let _access = state.access.write().await; + state + .storage + .remove_guild_member(&guild, "visitor") + .await + .unwrap(); + super::super::revoke_guild_access(&state, &guild, Some("visitor")).await; + } + let (mut stream, mut peer) = tokio::io::duplex(65536); + crate::handler::deliver::deliver_encrypted( + &mut stream, + &mut seq, + &sid, + &queued, + &crypto, + &state, + ) + .await + .unwrap(); + assert_eq!(seq, 3); + assert!( + tokio::time::timeout(Duration::from_millis(15), peer.read_u8()) + .await + .is_err(), + "history queued before a guild kick must not be delivered afterwards" + ); +} diff --git a/gateway/src/handler/channel/leave.rs b/gateway/src/handler/channel/leave.rs index 9ab8fd4..b3c4638 100644 --- a/gateway/src/handler/channel/leave.rs +++ b/gateway/src/handler/channel/leave.rs @@ -8,7 +8,7 @@ use crate::{ proto::SessionCrypto, }; -use super::{broadcast_leave, set_channel}; +use super::{broadcast_leave, set_channel, set_voice_channel}; pub async fn leave( _stream: &mut (impl AsyncRead + AsyncWrite + Unpin), @@ -18,17 +18,25 @@ pub async fn leave( _crypto: &SessionCrypto, state: &State, ) -> Result<()> { - let user_id = session::get(&state.sessions, session_id) - .await - .map(|s| s.user_id); - - let is_voice = channels::get_channel(&state.channels, channel_id) - .await - .is_some_and(|c| c.kind == channels::ChannelKind::Voice); + let Some(sess) = session::get(&state.sessions, session_id).await else { + return Ok(()); + }; + let is_voice = sess.voice_channel_id.as_deref() == Some(channel_id); + if !is_voice && sess.channel_id.as_deref() != Some(channel_id) { + return Ok(()); + } + let user_id = Some(sess.user_id); channels::leave(&state.channels, channel_id, session_id).await; - set_channel(state, session_id, None).await; + if is_voice { + set_voice_channel(state, session_id, None).await; + } else { + set_channel(state, session_id, None).await; + } broadcast_leave(state, channel_id, session_id).await; + if is_voice { + state.media.revoke(state, session_id).await; + } if is_voice && let Some(tx) = &state.voice_member_tx @@ -36,6 +44,7 @@ pub async fn leave( { let event = serde_json::json!({ "type": "leave", + "session_id": session_id, "channel_id": channel_id, "user_id": uid, }); diff --git a/gateway/src/handler/channel/mod.rs b/gateway/src/handler/channel/mod.rs index 47bf4f4..3418049 100644 --- a/gateway/src/handler/channel/mod.rs +++ b/gateway/src/handler/channel/mod.rs @@ -33,3 +33,274 @@ async fn set_channel(state: &State, session_id: &str, ch: Option) { s.channel_id = ch; } } + +async fn set_voice_channel(state: &State, session_id: &str, ch: Option) { + if let Some(s) = state.sessions.write().await.get_mut(session_id) { + s.voice_channel_id = ch; + } +} + +/// Remove active subscriptions and UDP credentials when guild access is revoked. +pub async fn revoke_guild_access(state: &State, guild: &str, user: Option<&str>) { + let sessions: Vec<_> = state + .sessions + .read() + .await + .values() + .filter(|s| user.is_none_or(|u| u == s.user_id)) + .cloned() + .collect(); + for sess in sessions { + for (voice, ch) in [(false, sess.channel_id), (true, sess.voice_channel_id)] { + let Some(ch) = ch else { continue }; + if !crate::domain::channels::get_channel(&state.channels, &ch) + .await + .is_some_and(|c| c.guild_id.as_deref() == Some(guild)) + { + continue; + } + crate::domain::channels::leave(&state.channels, &ch, &sess.session_id).await; + if voice { + set_voice_channel(state, &sess.session_id, None).await; + if let Some(tx) = &state.voice_member_tx { + let _=tx.send(serde_json::json!({"type":"leave","session_id":sess.session_id,"channel_id":ch,"user_id":sess.user_id}).to_string()); + } + state.media.revoke(state, &sess.session_id).await; + let event = crate::proto::VoiceState { + user_id: sess.user_id.clone(), + channel_id: ch.clone(), + state: "disconnected".into(), + }; + let _ = state.broadcast.send(BroadcastMsg { + channel_id: None, + exclude_session: None, + target_session_id: Some(sess.session_id.clone()), + data: encode_packet(PacketId::VoiceState, 0, &to_payload(&event)), + }); + } else { + set_channel(state, &sess.session_id, None).await; + } + broadcast_leave(state, &ch, &sess.session_id).await; + } + } +} + +/// Global channels have no modeled server administrator: authenticated users cannot mutate them. +pub(super) async fn may_manage( + state: &State, + user: &str, + guild: Option<&str>, +) -> anyhow::Result { + let Some(guild) = guild else { return Ok(false) }; + let Some(info) = state.storage.get_guild(guild).await? else { + return Ok(false); + }; + if info.owner_id == user { + return Ok(true); + } + if !state + .storage + .list_user_guilds(user) + .await? + .iter() + .any(|g| g.id == guild) + { + return Ok(false); + } + let roles = state.storage.get_user_role_perms(guild, user).await?; + Ok( + crate::domain::permissions::Permissions::from_role_perms(&roles) + .has(crate::domain::permissions::Permissions::MANAGE_CHANNELS), + ) +} + +pub(super) async fn denied( + stream: &mut (impl tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin), + seq: &mut u32, + crypto: &crate::proto::SessionCrypto, +) -> anyhow::Result<()> { + crate::net::io::send_encrypted( + stream, + PacketId::Error, + seq, + &to_payload(&crate::proto::ErrorPayload { + code: crate::proto::ErrorCode::PermissionDenied as u32, + message: "guild MANAGE_CHANNELS permission required".into(), + }), + crypto, + ) + .await +} + +/// Caller serializes access mutation against joins. Revoke before removing cached channel metadata. +pub async fn revoke_channel(state: &State, channel: &str) { + let sessions: Vec<_> = state + .sessions + .read() + .await + .values() + .filter(|s| { + s.channel_id.as_deref() == Some(channel) + || s.voice_channel_id.as_deref() == Some(channel) + }) + .cloned() + .collect(); + for session in sessions { + crate::domain::channels::leave(&state.channels, channel, &session.session_id).await; + if session.channel_id.as_deref() == Some(channel) { + set_channel(state, &session.session_id, None).await; + } + if session.voice_channel_id.as_deref() == Some(channel) { + set_voice_channel(state, &session.session_id, None).await; + if let Some(tx) = &state.voice_member_tx { + let _ = tx.send( + serde_json::json!({"type":"leave","session_id":session.session_id}).to_string(), + ); + } + state.media.revoke(state, &session.session_id).await; + let event = crate::proto::VoiceState { + user_id: session.user_id, + channel_id: channel.into(), + state: "disconnected".into(), + }; + let _ = state.broadcast.send(BroadcastMsg { + channel_id: None, + exclude_session: None, + target_session_id: Some(session.session_id.clone()), + data: encode_packet(PacketId::VoiceState, 0, &to_payload(&event)), + }); + } + broadcast_leave(state, channel, &session.session_id).await; + } +} + +/// Removing voice permission also invalidates existing relay credentials and screen shares. +pub async fn recheck_voice_permissions( + state: &State, + guild: &str, + user: Option<&str>, +) -> anyhow::Result<()> { + let owner = state.storage.get_guild(guild).await?.map(|g| g.owner_id); + let sessions: Vec<_> = state + .sessions + .read() + .await + .values() + .filter(|s| user.is_none_or(|u| u == s.user_id)) + .cloned() + .collect(); + for session in sessions { + let Some(channel) = session.voice_channel_id else { + continue; + }; + if !crate::domain::channels::get_channel(&state.channels, &channel) + .await + .is_some_and(|c| c.guild_id.as_deref() == Some(guild)) + { + continue; + } + if owner.as_deref() == Some(&session.user_id) { + continue; + } + let roles = state + .storage + .get_user_role_perms(guild, &session.user_id) + .await?; + if crate::domain::permissions::Permissions::from_role_perms(&roles) + .has(crate::domain::permissions::Permissions::VOICE_SPEAK) + { + continue; + } + crate::domain::channels::leave(&state.channels, &channel, &session.session_id).await; + set_voice_channel(state, &session.session_id, None).await; + if let Some(tx) = &state.voice_member_tx { + let _ = tx.send( + serde_json::json!({"type":"leave","session_id":session.session_id}).to_string(), + ); + } + state.media.revoke(state, &session.session_id).await; + let event = crate::proto::VoiceState { + user_id: session.user_id, + channel_id: channel, + state: "disconnected".into(), + }; + let _ = state.broadcast.send(BroadcastMsg { + channel_id: None, + exclude_session: None, + target_session_id: Some(session.session_id.clone()), + data: encode_packet(PacketId::VoiceState, 0, &to_payload(&event)), + }); + } + Ok(()) +} + +/// Metadata is addressed only to currently persisted guild members, including non-subscribers. +pub(super) async fn notify_guild( + state: &State, + guild: Option<&str>, + exclude: Option<&str>, + data: Vec, +) -> anyhow::Result<()> { + let Some(guild) = guild else { return Ok(()) }; + let _access = state.access.read().await; + let members = state.storage.list_guild_members(guild).await?; + let sessions: Vec<_> = state + .sessions + .read() + .await + .values() + .filter(|session| { + Some(session.session_id.as_str()) != exclude + && members + .iter() + .any(|member| member.user_id == session.user_id) + }) + .map(|session| session.session_id.clone()) + .collect(); + for target in sessions { + let _ = state.broadcast.send(BroadcastMsg { + channel_id: None, + exclude_session: None, + target_session_id: Some(target), + data: data.clone(), + }); + } + Ok(()) +} + +/// Creation/rename payloads queued before removal must not disclose new metadata afterwards. +pub async fn may_deliver_metadata( + state: &State, + recipient: &str, + packet: PacketId, + payload: &[u8], +) -> bool { + use prost::Message; + let guild = match packet { + PacketId::ChannelCreate => match crate::proto::ChannelCreatePayload::decode(payload) { + Ok(message) => message.guild_id, + Err(_) => return false, + }, + PacketId::ChannelEdit => match crate::proto::ChannelEditPayload::decode(payload) { + Ok(message) => { + match crate::domain::channels::get_channel(&state.channels, &message.channel_id) + .await + { + Some(channel) => channel.guild_id, + None => return false, + } + } + Err(_) => return false, + }, + _ => return true, + }; + let Some(guild) = guild else { return true }; + let Some(session) = crate::domain::session::get(&state.sessions, recipient).await else { + return false; + }; + state + .storage + .list_user_guilds(&session.user_id) + .await + .is_ok_and(|guilds| guilds.iter().any(|g| g.id == guild)) +} diff --git a/gateway/src/handler/content/chat.rs b/gateway/src/handler/content/chat.rs index f099888..5e38b54 100644 --- a/gateway/src/handler/content/chat.rs +++ b/gateway/src/handler/content/chat.rs @@ -48,15 +48,12 @@ pub async fn handle(session_id: &str, mut msg: ChatMessagePayload, state: &State let _ = state.broadcast.send(BroadcastMsg { channel_id: Some(msg.channel_id.clone()), - exclude_session: Some(session_id.into()), + exclude_session: None, target_session_id: None, data: encode_packet(PacketId::ChatMessage, 0, &to_payload(&msg)), }); - debug!( - "chat {} → {}: {}", - sess.nickname, msg.channel_id, msg.content - ); + debug!(channel=%msg.channel_id,message_id=%msg.message_id,"chat message accepted"); Ok(()) } diff --git a/gateway/src/handler/content/message_edit.rs b/gateway/src/handler/content/message_edit.rs index 462adbd..d93b1f7 100644 --- a/gateway/src/handler/content/message_edit.rs +++ b/gateway/src/handler/content/message_edit.rs @@ -48,7 +48,7 @@ pub async fn handle_message_edit(session_id: &str, payload: &[u8], state: &State let _ = state.broadcast.send(BroadcastMsg { channel_id: Some(edit.channel_id.clone()), - exclude_session: Some(session_id.into()), + exclude_session: None, target_session_id: None, data: encode_packet(PacketId::MessageEdit, 0, &to_payload(&broadcast_msg)), }); @@ -81,7 +81,7 @@ pub async fn handle_message_delete(session_id: &str, payload: &[u8], state: &Sta let _ = state.broadcast.send(BroadcastMsg { channel_id: Some(delete.channel_id.clone()), - exclude_session: Some(session_id.into()), + exclude_session: None, target_session_id: None, data: encode_packet(PacketId::MessageDelete, 0, &to_payload(&delete)), }); diff --git a/gateway/src/handler/content/reaction.rs b/gateway/src/handler/content/reaction.rs index 1e3b561..931aed8 100644 --- a/gateway/src/handler/content/reaction.rs +++ b/gateway/src/handler/content/reaction.rs @@ -35,7 +35,7 @@ pub async fn handle_reaction_add( let _ = state.broadcast.send(BroadcastMsg { channel_id: Some(payload.channel_id.clone()), - exclude_session: Some(session_id.into()), + exclude_session: None, target_session_id: None, data: encode_packet(PacketId::MessageReactionAdd, 0, &to_payload(&payload)), }); @@ -79,7 +79,7 @@ pub async fn handle_reaction_remove( let _ = state.broadcast.send(BroadcastMsg { channel_id: Some(payload.channel_id.clone()), - exclude_session: Some(session_id.into()), + exclude_session: None, target_session_id: None, data: encode_packet(PacketId::MessageReactionRemove, 0, &to_payload(&payload)), }); diff --git a/gateway/src/handler/deliver.rs b/gateway/src/handler/deliver.rs index 6d2e68e..f360e3b 100644 --- a/gateway/src/handler/deliver.rs +++ b/gateway/src/handler/deliver.rs @@ -15,25 +15,59 @@ pub async fn deliver_encrypted( crypto: &SessionCrypto, state: &State, ) -> Result<()> { - if msg.exclude_session.as_deref() == Some(session_id) { + if msg.exclude_session.as_deref() == Some(session_id) + || msg + .target_session_id + .as_deref() + .is_some_and(|target| target != session_id) + { return Ok(()); } - if let Some(ref target) = msg.target_session_id { - if target != session_id { + if msg.data.len() >= crate::proto::PacketHeader::SIZE { + let hdr = crate::proto::PacketHeader::from_bytes( + msg.data[..crate::proto::PacketHeader::SIZE] + .try_into() + .unwrap(), + ); + if let Some(packet) = crate::proto::PacketId::from_u16(hdr.packet_id) + && matches!( + packet, + crate::proto::PacketId::ChannelCreate | crate::proto::PacketId::ChannelEdit + ) + && !crate::handler::channel::may_deliver_metadata( + state, + session_id, + packet, + &msg.data[crate::proto::PacketHeader::SIZE..], + ) + .await + { + return Ok(()); + } + if crate::proto::PacketId::from_u16(hdr.packet_id) + == Some(crate::proto::PacketId::MediaEvent) + && !crate::media::may_deliver( + state, + session_id, + &msg.data[crate::proto::PacketHeader::SIZE..], + ) + .await + { return Ok(()); } - io::deliver_encrypted(stream, crypto, seq, &msg.data).await?; - return Ok(()); } if let Some(ref ch) = msg.channel_id { + let access = state.access.read().await; let in_ch = session::get(&state.sessions, session_id) .await - .and_then(|s| s.channel_id) - .as_deref() - == Some(ch.as_str()); + .is_some_and(|s| { + s.channel_id.as_deref() == Some(ch.as_str()) + || s.voice_channel_id.as_deref() == Some(ch.as_str()) + }); if !in_ch { return Ok(()); } + drop(access); } io::deliver_encrypted(stream, crypto, seq, &msg.data).await } diff --git a/gateway/src/handler/dispatch.rs b/gateway/src/handler/dispatch.rs index 87cc5a6..0d29843 100644 --- a/gateway/src/handler/dispatch.rs +++ b/gateway/src/handler/dispatch.rs @@ -21,6 +21,7 @@ pub async fn dispatch( addr: std::net::SocketAddr, ) -> Result<()> { match pid { + PacketId::MediaControl => crate::media::handle(ctx, session_id, payload).await?, PacketId::WebhookCreate | PacketId::WebhookList | PacketId::WebhookRotate diff --git a/gateway/src/handler/friends/mod.rs b/gateway/src/handler/friends/mod.rs index 3e98d2d..35b38d4 100644 --- a/gateway/src/handler/friends/mod.rs +++ b/gateway/src/handler/friends/mod.rs @@ -35,3 +35,26 @@ pub use decline::handle_friend_decline; pub use list::handle_friend_list; pub use manage::{handle_block_list, handle_block_user, handle_friend_remove, handle_unblock_user}; pub use requests::{handle_friend_accept, handle_friend_request}; + +async fn notify_user( + state: &crate::net::state::State, + user: &str, + event: &crate::proto::FriendEventPayload, +) { + let ids: Vec<_> = state + .sessions + .read() + .await + .values() + .filter(|s| s.user_id == user) + .map(|s| s.session_id.clone()) + .collect(); + for id in ids { + let _ = state.broadcast.send(crate::net::state::BroadcastMsg { + channel_id: None, + exclude_session: None, + target_session_id: Some(id), + data: crate::proto::encode_packet(PacketId::FriendEvent, 0, &to_payload(event)), + }); + } +} diff --git a/gateway/src/handler/friends/requests.rs b/gateway/src/handler/friends/requests.rs index f89773c..eeef291 100644 --- a/gateway/src/handler/friends/requests.rs +++ b/gateway/src/handler/friends/requests.rs @@ -4,13 +4,10 @@ use tokio::io::{AsyncRead, AsyncWrite}; use crate::{ domain::session, - net::{ - io, - state::{BroadcastMsg, State}, - }, + net::{io, state::State}, proto::{ FriendAcceptPayload, FriendEventPayload, FriendRequestPayload, PacketId, SessionCrypto, - encode_packet, to_payload, + to_payload, }, }; @@ -82,12 +79,7 @@ pub async fn handle_friend_request( user_id: sess.user_id.clone(), nickname: Some(sess.nickname.clone()), }; - let _ = state.broadcast.send(BroadcastMsg { - channel_id: None, - exclude_session: None, - target_session_id: Some(req.to_user_id.clone()), - data: encode_packet(PacketId::FriendRequest, *seq, &to_payload(&ev)), - }); + super::notify_user(state, &req.to_user_id, &ev).await; io::send_encrypted( stream, @@ -136,12 +128,7 @@ pub async fn handle_friend_accept( user_id: sess.user_id.clone(), nickname: Some(sess.nickname.clone()), }; - let _ = state.broadcast.send(BroadcastMsg { - channel_id: None, - exclude_session: None, - target_session_id: Some(req.from_user_id.clone()), - data: encode_packet(PacketId::FriendAccept, *seq, &to_payload(&ev)), - }); + super::notify_user(state, &req.from_user_id, &ev).await; io::send_encrypted( stream, diff --git a/gateway/src/handler/guild/crud.rs b/gateway/src/handler/guild/crud.rs index bb6552d..51fff93 100644 --- a/gateway/src/handler/guild/crud.rs +++ b/gateway/src/handler/guild/crud.rs @@ -75,6 +75,7 @@ pub async fn handle_guild_delete( crypto: &SessionCrypto, state: &State, ) -> Result<()> { + let guard = state.access.write().await; let req = crate::proto::GuildDeletePayload::decode(payload)?; let sess = session::get(&state.sessions, session_id) .await @@ -86,6 +87,7 @@ pub async fn handle_guild_delete( .await? .ok_or_else(|| anyhow::anyhow!("guild not found"))?; if guild.owner_id != sess.user_id { + drop(guard); send_err( stream, seq, @@ -97,6 +99,7 @@ pub async fn handle_guild_delete( return Ok(()); } + crate::handler::channel::revoke_guild_access(state, &req.guild_id, None).await; state.storage.delete_guild(&req.guild_id).await?; state .storage @@ -110,6 +113,7 @@ pub async fn handle_guild_delete( ) .await?; + drop(guard); io::send_encrypted( stream, PacketId::GuildDelete, diff --git a/gateway/src/handler/guild/members.rs b/gateway/src/handler/guild/members.rs index 3b6358e..aa6f562 100644 --- a/gateway/src/handler/guild/members.rs +++ b/gateway/src/handler/guild/members.rs @@ -21,11 +21,30 @@ pub async fn handle_guild_member_join( crypto: &SessionCrypto, state: &State, ) -> Result<()> { + let guard = state.access.write().await; let req = GuildMemberJoinPayload::decode(payload)?; let sess = session::get(&state.sessions, session_id) .await .ok_or_else(|| anyhow::anyhow!("session not found"))?; + if !state + .storage + .list_user_guilds(&sess.user_id) + .await? + .iter() + .any(|g| g.id == req.guild_id) + { + drop(guard); + send_err( + stream, + seq, + crate::proto::ErrorCode::PermissionDenied, + "a valid invitation is required", + crypto, + ) + .await?; + return Ok(()); + } state .storage .add_guild_member(&req.guild_id, &sess.user_id) @@ -41,6 +60,7 @@ pub async fn handle_guild_member_join( .map(|r| r.color.clone()) .unwrap_or_else(|| "#ffffff".into()); + drop(guard); io::send_encrypted( stream, PacketId::GuildMemberJoin, @@ -75,6 +95,7 @@ pub async fn handle_guild_member_leave( crypto: &SessionCrypto, state: &State, ) -> Result<()> { + let guard = state.access.write().await; let req = GuildMemberLeavePayload::decode(payload)?; let sess = session::get(&state.sessions, session_id) .await @@ -85,10 +106,29 @@ pub async fn handle_guild_member_leave( } else { req.user_id.clone() }; + let owner = state + .storage + .get_guild(&req.guild_id) + .await? + .is_some_and(|g| g.owner_id == target); + if target != sess.user_id || owner { + drop(guard); + send_err( + stream, + seq, + crate::proto::ErrorCode::PermissionDenied, + "only a non-owner may leave their own membership", + crypto, + ) + .await?; + return Ok(()); + } state .storage .remove_guild_member(&req.guild_id, target.as_str()) .await?; + crate::handler::channel::revoke_guild_access(state, &req.guild_id, Some(&target)).await; + drop(guard); io::send_encrypted( stream, PacketId::GuildMemberLeave, @@ -111,6 +151,7 @@ pub async fn handle_guild_member_kick( crypto: &SessionCrypto, state: &State, ) -> Result<()> { + let guard = state.access.write().await; let req = GuildMemberKickPayload::decode(payload)?; let sess = session::get(&state.sessions, session_id) .await @@ -124,6 +165,7 @@ pub async fn handle_guild_member_kick( ) .await? { + drop(guard); send_err( stream, seq, @@ -135,10 +177,28 @@ pub async fn handle_guild_member_kick( return Ok(()); } + if state + .storage + .get_guild(&req.guild_id) + .await? + .is_some_and(|g| g.owner_id == req.user_id) + { + drop(guard); + send_err( + stream, + seq, + crate::proto::ErrorCode::PermissionDenied, + "guild owner cannot be kicked", + crypto, + ) + .await?; + return Ok(()); + } state .storage .remove_guild_member(&req.guild_id, &req.user_id) .await?; + crate::handler::channel::revoke_guild_access(state, &req.guild_id, Some(&req.user_id)).await; state .storage .append_audit_log( @@ -150,6 +210,7 @@ pub async fn handle_guild_member_kick( None, ) .await?; + drop(guard); io::send_encrypted( stream, PacketId::GuildMemberKick, diff --git a/gateway/src/handler/guild/members_list.rs b/gateway/src/handler/guild/members_list.rs index efb9684..af7efef 100644 --- a/gateway/src/handler/guild/members_list.rs +++ b/gateway/src/handler/guild/members_list.rs @@ -29,7 +29,24 @@ pub async fn handle_member_list_fetch( None => return Ok(()), }; - // Optional: verify the requester is a member of the guild. + if !state + .storage + .list_user_guilds(&sess.user_id) + .await? + .iter() + .any(|g| g.id == req.guild_id) + { + send_err( + stream, + seq, + crate::proto::ErrorCode::PermissionDenied, + "guild membership required", + crypto, + ) + .await?; + return Ok(()); + } + // Membership is checked before listing identities. let owner_id = state .storage .get_guild(&req.guild_id) @@ -79,6 +96,7 @@ pub async fn handle_role_assign( None => return Ok(()), }; + let access = state.access.write().await; if !require_perm( state, &req.guild_id, @@ -87,6 +105,7 @@ pub async fn handle_role_assign( ) .await? { + drop(access); send_err( stream, seq, @@ -98,6 +117,31 @@ pub async fn handle_role_assign( return Ok(()); } + let role = super::roles::role_permissions(state, &req.guild_id, &req.role_id).await?; + if !state + .storage + .list_user_guilds(&req.user_id) + .await? + .iter() + .any(|g| g.id == req.guild_id) + || match role { + Some(permissions) => { + !super::roles::may_grant(state, &req.guild_id, &sess.user_id, permissions).await? + } + None => true, + } + { + drop(access); + send_err( + stream, + seq, + crate::proto::ErrorCode::PermissionDenied, + "role or target not permitted in this guild", + crypto, + ) + .await?; + return Ok(()); + } state .storage .assign_role(&req.guild_id, &req.user_id, &req.role_id) @@ -114,6 +158,7 @@ pub async fn handle_role_assign( ) .await?; + drop(access); // Confirm to caller. io::send_encrypted( stream, @@ -145,6 +190,7 @@ pub async fn handle_role_unassign( None => return Ok(()), }; + let access = state.access.write().await; if !require_perm( state, &req.guild_id, @@ -153,6 +199,7 @@ pub async fn handle_role_unassign( ) .await? { + drop(access); send_err( stream, seq, @@ -164,10 +211,37 @@ pub async fn handle_role_unassign( return Ok(()); } + let role = super::roles::role_permissions(state, &req.guild_id, &req.role_id).await?; + if !state + .storage + .list_user_guilds(&req.user_id) + .await? + .iter() + .any(|g| g.id == req.guild_id) + || match role { + Some(permissions) => { + !super::roles::may_grant(state, &req.guild_id, &sess.user_id, permissions).await? + } + None => true, + } + { + drop(access); + send_err( + stream, + seq, + crate::proto::ErrorCode::PermissionDenied, + "role or target not permitted in this guild", + crypto, + ) + .await?; + return Ok(()); + } state .storage .remove_role_from_user(&req.guild_id, &req.user_id, &req.role_id) .await?; + crate::handler::channel::recheck_voice_permissions(state, &req.guild_id, Some(&req.user_id)) + .await?; state .storage .append_audit_log( @@ -180,6 +254,7 @@ pub async fn handle_role_unassign( ) .await?; + drop(access); io::send_encrypted( stream, PacketId::GuildRoleUnassign, @@ -205,7 +280,26 @@ pub async fn handle_role_list_fetch( state: &State, ) -> Result<()> { let req = GuildRoleListFetchPayload::decode(payload)?; - let _sess = session::get(&state.sessions, session_id).await; + let Some(sess) = session::get(&state.sessions, session_id).await else { + return Ok(()); + }; + if !state + .storage + .list_user_guilds(&sess.user_id) + .await? + .iter() + .any(|g| g.id == req.guild_id) + { + send_err( + stream, + seq, + crate::proto::ErrorCode::PermissionDenied, + "guild membership required", + crypto, + ) + .await?; + return Ok(()); + } let rows = state.storage.list_guild_roles(&req.guild_id).await?; let roles: Vec = rows diff --git a/gateway/src/handler/guild/mod.rs b/gateway/src/handler/guild/mod.rs index 056627b..aeb7706 100644 --- a/gateway/src/handler/guild/mod.rs +++ b/gateway/src/handler/guild/mod.rs @@ -46,6 +46,15 @@ async fn require_perm( { return Ok(true); } + if !state + .storage + .list_user_guilds(user_id) + .await? + .iter() + .any(|g| g.id == guild_id) + { + return Ok(false); + } let perms = state.storage.get_user_role_perms(guild_id, user_id).await?; Ok(Permissions::from_role_perms(&perms).has(required)) } diff --git a/gateway/src/handler/guild/roles.rs b/gateway/src/handler/guild/roles.rs index 3111d33..f87d6bc 100644 --- a/gateway/src/handler/guild/roles.rs +++ b/gateway/src/handler/guild/roles.rs @@ -23,6 +23,7 @@ pub async fn handle_role_create( .await .ok_or_else(|| anyhow::anyhow!("session not found"))?; + let access = state.access.write().await; if !super::require_perm( state, &req.guild_id, @@ -31,6 +32,7 @@ pub async fn handle_role_create( ) .await? { + drop(access); send_err( stream, seq, @@ -44,6 +46,22 @@ pub async fn handle_role_create( let color = req.color.as_deref().unwrap_or("#ffffff"); let permissions = req.permissions.unwrap_or(0); + if req.name.trim().is_empty() + || req.name.chars().count() > 64 + || req.name.chars().any(char::is_control) + || !may_grant(state, &req.guild_id, &sess.user_id, permissions).await? + { + drop(access); + send_err( + stream, + seq, + crate::proto::ErrorCode::PermissionDenied, + "cannot grant requested role", + crypto, + ) + .await?; + return Ok(()); + } let role_id = state .storage .create_role(&req.guild_id, &req.name, color, permissions, 1) @@ -60,6 +78,7 @@ pub async fn handle_role_create( None, ) .await?; + drop(access); io::send_encrypted( stream, PacketId::RoleCreate, @@ -90,6 +109,7 @@ pub async fn handle_role_delete( .await .ok_or_else(|| anyhow::anyhow!("session not found"))?; + let access = state.access.write().await; if !super::require_perm( state, &req.guild_id, @@ -98,6 +118,7 @@ pub async fn handle_role_delete( ) .await? { + drop(access); send_err( stream, seq, @@ -109,7 +130,32 @@ pub async fn handle_role_delete( return Ok(()); } + let Some(permissions) = role_permissions(state, &req.guild_id, &req.role_id).await? else { + drop(access); + send_err( + stream, + seq, + crate::proto::ErrorCode::PermissionDenied, + "role is outside this guild", + crypto, + ) + .await?; + return Ok(()); + }; + if !may_grant(state, &req.guild_id, &sess.user_id, permissions).await? { + drop(access); + send_err( + stream, + seq, + crate::proto::ErrorCode::PermissionDenied, + "cannot manage requested role", + crypto, + ) + .await?; + return Ok(()); + } state.storage.delete_role(&req.role_id).await?; + crate::handler::channel::recheck_voice_permissions(state, &req.guild_id, None).await?; state .storage .append_audit_log( @@ -121,6 +167,7 @@ pub async fn handle_role_delete( None, ) .await?; + drop(access); io::send_encrypted( stream, PacketId::RoleDelete, @@ -134,3 +181,36 @@ pub async fn handle_role_delete( .await?; Ok(()) } + +/// A role manager cannot create/assign permissions they do not themselves hold. +pub(super) async fn may_grant( + state: &State, + guild: &str, + actor: &str, + permissions: u64, +) -> Result { + if state + .storage + .get_guild(guild) + .await? + .is_some_and(|g| g.owner_id == actor) + { + return Ok(true); + } + let held = + Permissions::from_role_perms(&state.storage.get_user_role_perms(guild, actor).await?); + Ok(held.has(Permissions::ADMINISTRATOR) || permissions & !held.bits() == 0) +} +pub(super) async fn role_permissions( + state: &State, + guild: &str, + role: &str, +) -> Result> { + Ok(state + .storage + .list_guild_roles(guild) + .await? + .into_iter() + .find(|r| r.id == role) + .map(|r| r.permissions as u64)) +} diff --git a/gateway/src/handler/run.rs b/gateway/src/handler/run.rs index f51893d..cf97664 100644 --- a/gateway/src/handler/run.rs +++ b/gateway/src/handler/run.rs @@ -25,9 +25,10 @@ pub async fn run_session( crypto, state, }; + let mut reader = io::EncryptedReader::default(); loop { tokio::select! { - result = io::read_encrypted(ctx.stream, ctx.crypto) => { + result = reader.read(ctx.stream, ctx.crypto) => { let (hdr, payload) = result?; let pid = match PacketId::from_u16(hdr.packet_id) { Some(p) => p, diff --git a/gateway/src/lib.rs b/gateway/src/lib.rs index a89de09..81ad8ed 100644 --- a/gateway/src/lib.rs +++ b/gateway/src/lib.rs @@ -2,6 +2,7 @@ pub mod admin; pub mod bootstrap; pub mod domain; pub mod handler; +pub mod media; pub mod net; pub mod proto; pub mod webhooks; @@ -228,7 +229,11 @@ async fn handle( state: State, ) -> Result<()> { let mut seq = 0u32; - let (sess, crypto) = net::handshake::run(&mut stream, addr, &state, &mut seq).await?; + let (sess, crypto) = tokio::time::timeout( + std::time::Duration::from_secs(15), + net::handshake::run(&mut stream, addr, &state, &mut seq), + ) + .await??; let sid = sess.session_id.clone(); state .sessions_count @@ -293,29 +298,27 @@ async fn handle( }); } - if let Some(ch) = session::get(&state.sessions, &sid) - .await - .and_then(|s| s.channel_id) - { - let is_voice = channels::get_channel(&state.channels, &ch) - .await - .is_some_and(|c| c.kind == channels::ChannelKind::Voice); - - channels::leave(&state.channels, &ch, &sid).await; - handler::channel::broadcast_leave(&state, &ch, &sid).await; - - if is_voice - && let Some(tx) = &state.voice_member_tx - && let Some(ref uid) = user_id + if let Some(sess) = session::get(&state.sessions, &sid).await { + for ch in [sess.channel_id, sess.voice_channel_id] + .into_iter() + .flatten() { - let event = serde_json::json!({ - "type": "leave", - "channel_id": ch, - "user_id": uid, - }); - let _ = tx.send(event.to_string()); + let is_voice = channels::get_channel(&state.channels, &ch) + .await + .is_some_and(|c| c.kind == channels::ChannelKind::Voice); + channels::leave(&state.channels, &ch, &sid).await; + handler::channel::broadcast_leave(&state, &ch, &sid).await; + if is_voice + && let Some(tx) = &state.voice_member_tx + && let Some(ref uid) = user_id + { + let _ = tx.send( + serde_json::json!({"type":"leave","session_id":sid,"channel_id":ch,"user_id":uid}).to_string(), + ); + } } } + state.media.revoke(&state, &sid).await; session::remove(&state.sessions, &sid).await; state .sessions_count diff --git a/gateway/src/media/mod.rs b/gateway/src/media/mod.rs new file mode 100644 index 0000000..924a0a1 --- /dev/null +++ b/gateway/src/media/mod.rs @@ -0,0 +1,524 @@ +//! Bounded authenticated signalling. No media packets or bearer auth endpoints. +use crate::{ + domain::{ + channels::{self, ChannelKind}, + permissions::Permissions, + session, + }, + handler::Ctx, + net::{ + io, + state::{BroadcastMsg, State}, + }, + proto::{self, MediaControl, MediaEvent, PacketId, encode_packet, to_payload}, +}; +use anyhow::{Result, bail}; +use prost::Message; +use std::collections::{HashMap, HashSet}; +use tokio::{ + io::{AsyncRead, AsyncWrite}, + sync::Mutex, +}; + +pub const START: u32 = 1; +pub const STOP: u32 = 2; +pub const WATCH: u32 = 3; +pub const UNWATCH: u32 = 4; +pub const OFFER: u32 = 5; +pub const ANSWER: u32 = 6; +pub const ICE: u32 = 7; +const MAX_VIEWERS: usize = 4; +const MAX_SHARES: usize = 128; + +#[derive(Clone)] +struct Share { + channel: String, + owner: String, + user: String, + viewers: HashSet, + audio: bool, + mic: bool, +} +#[derive(Default)] +pub struct Runtime { + shares: Mutex>, + rates: Mutex>, +} +struct SignalBudget { + updated: std::time::Instant, + tokens: f64, +} +impl SignalBudget { + fn consume(&mut self) -> bool { + let now = std::time::Instant::now(); + self.tokens = + (self.tokens + now.duration_since(self.updated).as_secs_f64() * 20.0).min(64.0); + self.updated = now; + if self.tokens < 1.0 { + return false; + } + self.tokens -= 1.0; + true + } +} +struct Route { + target: String, + event: MediaEvent, +} + +impl Share { + fn event(&self, action: u32, id: &str, sender: &str) -> MediaEvent { + MediaEvent { + action, + channel_id: self.channel.clone(), + share_id: id.into(), + target_session_id: String::new(), + body: String::new(), + mline_index: 0, + application_audio: self.audio, + microphone: self.mic, + sender_session_id: sender.into(), + publisher_user_id: self.user.clone(), + } + } +} +impl Runtime { + async fn apply( + &self, + sender: &str, + user: &str, + req: &MediaControl, + members: &HashSet, + ) -> Result> { + validate(req)?; + let mut shares = self.shares.lock().await; + if req.action == START { + if shares.len() >= MAX_SHARES + || shares.contains_key(&req.share_id) + || shares.values().any(|share| share.owner == sender) + { + bail!("share already active or server capacity reached"); + } + let share = Share { + channel: req.channel_id.clone(), + owner: sender.into(), + user: user.into(), + viewers: HashSet::new(), + audio: req.application_audio, + mic: req.microphone, + }; + let routes = members + .iter() + .map(|target| Route { + target: target.clone(), + event: share.event(START, &req.share_id, sender), + }) + .collect(); + shares.insert(req.share_id.clone(), share); + return Ok(routes); + } + // WATCH with an empty share ID requests current announcements, not a subscription. + if req.action == WATCH && req.share_id.is_empty() { + return Ok(shares + .iter() + .filter(|(_, share)| share.channel == req.channel_id) + .map(|(id, share)| Route { + target: sender.into(), + event: share.event(START, id, &share.owner), + }) + .collect()); + } + let share = shares + .get_mut(&req.share_id) + .ok_or_else(|| anyhow::anyhow!("unknown or expired share"))?; + if share.channel != req.channel_id { + bail!("share belongs to another voice channel"); + } + let mut routes = Vec::new(); + match req.action { + STOP => { + if share.owner != sender { + bail!("only publisher may stop a share"); + } + for target in members { + routes.push(Route { + target: target.clone(), + event: share.event(STOP, &req.share_id, sender), + }); + } + shares.remove(&req.share_id); + } + WATCH => { + if share.owner == sender || !members.contains(&share.owner) { + bail!("publisher unavailable or self subscription"); + } + if !share.viewers.contains(sender) && share.viewers.len() >= MAX_VIEWERS { + bail!("share viewer limit reached"); + } + if share.viewers.insert(sender.into()) { + routes.push(Route { + target: share.owner.clone(), + event: share.event(WATCH, &req.share_id, sender), + }); + } + routes.push(Route { + target: sender.into(), + event: share.event(WATCH, &req.share_id, &share.owner), + }); + } + UNWATCH => { + if !share.viewers.remove(sender) { + bail!("subscription not active"); + } + routes.push(Route { + target: share.owner.clone(), + event: share.event(UNWATCH, &req.share_id, sender), + }); + routes.push(Route { + target: sender.into(), + event: share.event(UNWATCH, &req.share_id, &share.owner), + }); + } + OFFER | ANSWER | ICE => { + let target = req.target_session_id.as_str(); + if target == sender || !members.contains(target) { + bail!("target is not a voice peer"); + } + let publisher_to_viewer = share.owner == sender && share.viewers.contains(target); + let viewer_to_publisher = share.owner == target && share.viewers.contains(sender); + if !(publisher_to_viewer || viewer_to_publisher) + || req.action == OFFER && !publisher_to_viewer + || req.action == ANSWER && !viewer_to_publisher + { + bail!("signal is not authorized for this subscription"); + } + let mut event = share.event(req.action, &req.share_id, sender); + event.target_session_id = target.into(); + event.body = req.body.clone(); + event.mline_index = req.mline_index; + routes.push(Route { + target: target.into(), + event, + }); + } + _ => bail!("unknown media action"), + } + Ok(routes) + } + + /// Revoke all publishing/viewing rights for a leaving or disconnected session. + pub async fn revoke(&self, state: &State, leaving: &str) { + self.rates.lock().await.remove(leaving); + let channels = state.channels.read().await; + let mut shares = self.shares.lock().await; + let mut routes = Vec::new(); + shares.retain(|id, share| { + if share.owner == leaving { + let mut targets = share.viewers.clone(); + targets.insert(leaving.to_owned()); + if let Some(channel) = channels.get(&share.channel) { + targets.extend(channel.members.iter().cloned()); + } + for target in targets { + routes.push(Route { + target, + event: share.event(STOP, id, leaving), + }); + } + false + } else { + if share.viewers.remove(leaving) { + routes.push(Route { + target: share.owner.clone(), + event: share.event(UNWATCH, id, leaving), + }); + routes.push(Route { + target: leaving.to_owned(), + event: share.event(UNWATCH, id, &share.owner), + }); + } + true + } + }); + drop(shares); + send(state, routes); + } +} + +fn validate(req: &MediaControl) -> Result<()> { + if req.channel_id.is_empty() || req.channel_id.len() > 128 || req.target_session_id.len() > 64 { + bail!("invalid media scope"); + } + if !(req.action == WATCH && req.share_id.is_empty()) + && uuid::Uuid::parse_str(&req.share_id).is_err() + { + bail!("share ID must be a UUID"); + } + match req.action { + OFFER | ANSWER if req.body.is_empty() || req.body.len() > 65_536 => { + bail!("SDP size out of bounds") + } + ICE if req.body.len() > 2048 || req.mline_index > 2 => bail!("ICE candidate out of bounds"), + START | STOP | WATCH | UNWATCH + if !req.body.is_empty() || !req.target_session_id.is_empty() => + { + bail!("unexpected media control data") + } + START..=ICE => {} + _ => bail!("unknown media action"), + } + Ok(()) +} + +fn send(state: &State, routes: Vec) { + for route in routes { + let _ = state.broadcast.send(BroadcastMsg { + channel_id: None, + exclude_session: None, + target_session_id: Some(route.target), + data: encode_packet(PacketId::MediaEvent, 0, &to_payload(&route.event)), + }); + } +} + +/// Invoked only by authenticated LNEx dispatch, never by an HTTP endpoint. +pub async fn handle( + ctx: &mut Ctx<'_, S>, + sender: &str, + payload: &[u8], +) -> Result<()> { + let outcome = authorize_and_apply(ctx.state, sender, payload).await; + match outcome { + Ok(routes) => { + send(ctx.state, routes); + Ok(()) + } + Err(error) => { + io::send_encrypted( + ctx.stream, + PacketId::Error, + ctx.seq, + &to_payload(&proto::Error { + code: proto::ErrorCode::PermissionDenied as u32, + message: format!("media: {error}"), + }), + ctx.crypto, + ) + .await + } + } +} +async fn authorize_and_apply(state: &State, sender: &str, payload: &[u8]) -> Result> { + if payload.len() > 67_000 { + bail!("media control too large"); + } + let req = MediaControl::decode(payload)?; + validate(&req)?; + { + let mut rates = state.media.rates.lock().await; + let budget = rates.entry(sender.into()).or_insert(SignalBudget { + updated: std::time::Instant::now(), + tokens: 64.0, + }); + if !budget.consume() { + bail!("media control rate exceeded"); + } + } + // Shared authorization lease covers fresh guild/channel checks and mutation. + // It is dropped on return before the caller performs any socket I/O. + let _access = state.access.read().await; + let session = session::get(&state.sessions, sender) + .await + .ok_or_else(|| anyhow::anyhow!("session expired"))?; + let channel = channels::get_channel(&state.channels, &req.channel_id) + .await + .ok_or_else(|| anyhow::anyhow!("voice channel unavailable"))?; + if channel.kind != ChannelKind::Voice || !channel.members.contains(sender) { + bail!("voice membership required"); + } + if let Some(guild) = channel.guild_id.as_deref() { + if !state + .storage + .list_user_guilds(&session.user_id) + .await? + .iter() + .any(|item| item.id == guild) + { + bail!("guild membership required"); + } + if req.action == START { + let owner = state + .storage + .get_guild(guild) + .await? + .is_some_and(|g| g.owner_id == session.user_id); + let perms = state + .storage + .get_user_role_perms(guild, &session.user_id) + .await?; + if !owner && !Permissions::from_role_perms(&perms).has(Permissions::VOICE_SPEAK) { + bail!("VOICE_SPEAK permission required"); + } + } + } + // Hold current channel membership through the runtime mutation; leave/revoke + // uses the same ordering (membership first, then media) to prevent resurrection. + let channels = state.channels.read().await; + let channel = channels + .get(&req.channel_id) + .ok_or_else(|| anyhow::anyhow!("voice channel unavailable"))?; + if !channel.members.contains(sender) { + bail!("voice membership revoked"); + } + state + .media + .apply(sender, &session.user_id, &req, &channel.members) + .await +} + +/// Delivery-time membership check prevents queued SDP/ICE escaping after a leave. +pub async fn may_deliver(state: &State, recipient: &str, payload: &[u8]) -> bool { + let Ok(event) = MediaEvent::decode(payload) else { + return false; + }; + if event.action == STOP || event.action == UNWATCH { + return true; + } + let channels = state.channels.read().await; + let Some(channel) = channels.get(&event.channel_id) else { + return false; + }; + if channel.kind != ChannelKind::Voice + || !channel.members.contains(recipient) + || !channel.members.contains(&event.sender_session_id) + { + return false; + } + let shares = state.media.shares.lock().await; + let Some(share) = shares.get(&event.share_id) else { + return false; + }; + if share.channel != event.channel_id || !channel.members.contains(&share.owner) { + return false; + } + match event.action { + START => true, + WATCH | OFFER | ANSWER | ICE => { + (share.owner == recipient && share.viewers.contains(&event.sender_session_id)) + || (share.owner == event.sender_session_id && share.viewers.contains(recipient)) + } + _ => false, + } +} + +#[cfg(test)] +mod tests { + use super::*; + fn req(action: u32, id: &str) -> MediaControl { + MediaControl { + action, + channel_id: "voice".into(), + share_id: id.into(), + ..Default::default() + } + } + #[tokio::test] + async fn only_authorized_subscription_can_exchange_signals() { + let runtime = Runtime::default(); + let members = ["publisher", "viewer", "other"] + .into_iter() + .map(str::to_owned) + .collect(); + let id = uuid::Uuid::new_v4().to_string(); + runtime + .apply("publisher", "owner-user", &req(START, &id), &members) + .await + .expect("start"); + let mut offer = req(OFFER, &id); + offer.target_session_id = "viewer".into(); + offer.body = "v=0\r\n".into(); + assert!( + runtime + .apply("publisher", "owner-user", &offer, &members) + .await + .is_err() + ); + runtime + .apply("viewer", "viewer-user", &req(WATCH, &id), &members) + .await + .expect("watch"); + let routes = runtime + .apply("publisher", "owner-user", &offer, &members) + .await + .expect("authorized offer"); + assert_eq!(routes[0].target, "viewer"); + assert_eq!(routes[0].event.sender_session_id, "publisher"); + assert_eq!(routes[0].event.publisher_user_id, "owner-user"); + assert!( + runtime + .apply("viewer", "viewer-user", &offer, &members) + .await + .is_err() + ); + offer.action = ICE; + offer.target_session_id = "publisher".into(); + assert!( + runtime + .apply("other", "other-user", &offer, &members) + .await + .is_err() + ); + runtime + .apply("viewer", "viewer-user", &req(UNWATCH, &id), &members) + .await + .expect("unwatch"); + assert!( + runtime + .apply("viewer", "viewer-user", &offer, &members) + .await + .is_err() + ); + assert!( + runtime + .apply("viewer", "viewer-user", &req(STOP, &id), &members) + .await + .is_err() + ); + runtime + .apply("publisher", "owner-user", &req(STOP, &id), &members) + .await + .expect("stop"); + assert!( + runtime + .apply("viewer", "viewer-user", &req(WATCH, &id), &members) + .await + .is_err() + ); + } + #[test] + fn signalling_budget_bounds_bursts_and_refills() { + let mut budget = SignalBudget { + updated: std::time::Instant::now(), + tokens: 64.0, + }; + for _ in 0..64 { + assert!(budget.consume()); + } + assert!(!budget.consume()); + budget.updated = std::time::Instant::now() - std::time::Duration::from_secs(1); + assert!(budget.consume()); + assert!(budget.tokens < 20.1); + } + #[test] + fn signalling_limits_reject_unbounded_data() { + let mut signal = req(OFFER, &uuid::Uuid::new_v4().to_string()); + signal.body = "x".repeat(65_537); + assert!(validate(&signal).is_err()); + signal.action = ICE; + signal.body = "x".repeat(2049); + assert!(validate(&signal).is_err()); + signal.body.clear(); + signal.mline_index = 3; + assert!(validate(&signal).is_err()); + } +} diff --git a/gateway/src/net/handshake.rs b/gateway/src/net/handshake.rs index 789f886..2ade92d 100644 --- a/gateway/src/net/handshake.rs +++ b/gateway/src/net/handshake.rs @@ -10,7 +10,7 @@ use crate::{ proto::{self, AuthPayload, HelloPayload, PacketId, SessionCrypto, SessionPayload, to_payload}, }; -const LNEX_VERSION: &str = "v1"; +const LNEX_VERSION: &str = "v2"; /// Run HELLO → AUTH → SESSION with X25519 ECDH key exchange. /// @@ -29,20 +29,27 @@ pub async fn run( // HELLO — include server's ephemeral public key + privacy mode let challenge = auth::new_challenge(); let private_mode = state.config.is_private(); - let hello = HelloPayload { + let mut hello = HelloPayload { lnex_version: LNEX_VERSION.into(), server_pubkey: hex::decode(state.server_identity.pubkey_hex())?, challenge_nonce: challenge.to_vec(), node_name: state.config.node.name.clone(), server_eph_pubkey: eph_pk_raw.to_vec(), private_mode, + server_signature: Vec::new(), }; + let mut hello_transcript = b"VNOX-LNEx-v2-server-hello\0".to_vec(); + hello_transcript.extend_from_slice(&hello.encode_to_vec()); + hello.server_signature = state.server_identity.sign(&hello_transcript); io::send_packet(stream, PacketId::Hello, seq, &to_payload(&hello)).await?; debug!("{addr} ← HELLO (eph key included)"); // AUTH — receive client's ephemeral public key let (hdr, payload) = io::read_packet(stream).await?; - if PacketId::from_u16(hdr.packet_id) != Some(PacketId::Auth) { + if PacketId::from_u16(hdr.packet_id) != Some(PacketId::Auth) + || hdr.flags != 0 + || hdr.sequence != 0 + { io::send_error( stream, seq, @@ -54,7 +61,11 @@ pub async fn run( } let msg = AuthPayload::decode(payload.as_slice())?; - debug!("{addr} → AUTH nick={}", msg.nickname); + anyhow::ensure!( + !msg.nickname.trim().is_empty() && msg.nickname.chars().count() <= 64, + "invalid nickname" + ); + debug!("{addr} → AUTH"); if msg.lnex_version != LNEX_VERSION { io::send_error( @@ -70,7 +81,14 @@ pub async fn run( let pubkey: [u8; 32] = msg.client_pubkey.as_slice().try_into()?; let sig: [u8; 64] = msg.signature.as_slice().try_into()?; - if let Err(e) = auth::verify_auth(&challenge, &pubkey, &sig) { + let mut auth_without_signature = msg.clone(); + auth_without_signature.signature.clear(); + let hello_bytes = hello.encode_to_vec(); + let mut auth_transcript = b"VNOX-LNEx-v2-client-auth\0".to_vec(); + auth_transcript.extend_from_slice(&(hello_bytes.len() as u32).to_be_bytes()); + auth_transcript.extend_from_slice(&hello_bytes); + auth_transcript.extend_from_slice(&auth_without_signature.encode_to_vec()); + if let Err(e) = auth::verify_auth(&auth_transcript, &pubkey, &sig) { warn!("{addr} auth failed: {e}"); state.metrics.inc(&state.metrics.auth_failures); io::send_error( @@ -102,6 +120,7 @@ pub async fn run( let client_eph_raw: [u8; 32] = msg.client_eph_pubkey.as_slice().try_into()?; let client_eph_pk = x25519_dalek::PublicKey::from(client_eph_raw); let shared_secret = SessionCrypto::ecdh(eph_sk, &client_eph_pk); + anyhow::ensure!(shared_secret.was_contributory(), "invalid ephemeral key"); // SESSION let sess = session::create( diff --git a/gateway/src/net/io.rs b/gateway/src/net/io.rs index d2d2731..1169d7c 100644 --- a/gateway/src/net/io.rs +++ b/gateway/src/net/io.rs @@ -60,14 +60,19 @@ pub async fn send_encrypted( payload: &[u8], crypto: &SessionCrypto, ) -> Result<()> { - let encrypted = crypto.encrypt_s2c(*seq as u64, payload); + anyhow::ensure!(*seq < u32::MAX, "session sequence exhausted"); + anyhow::ensure!( + payload.len() <= MAX_PAYLOAD as usize - 16, + "payload too large" + ); let flags_val = flags::ENCRYPTED; let mut hdr_buf = [0u8; PacketHeader::SIZE]; hdr_buf[0..2].copy_from_slice(&(id as u16).to_be_bytes()); hdr_buf[2..4].copy_from_slice(&flags_val.to_be_bytes()); hdr_buf[4..8].copy_from_slice(&seq.to_be_bytes()); - hdr_buf[8..12].copy_from_slice(&(encrypted.len() as u32).to_be_bytes()); - *seq = seq.wrapping_add(1); + hdr_buf[8..12].copy_from_slice(&((payload.len() + 16) as u32).to_be_bytes()); + let encrypted = crypto.encrypt_s2c_frame(*seq as u64, payload, &hdr_buf); + *seq += 1; let mut out = Vec::with_capacity(PacketHeader::SIZE + encrypted.len()); out.extend_from_slice(&hdr_buf); @@ -96,7 +101,7 @@ pub async fn read_encrypted( if !encrypted.is_empty() { stream.read_exact(&mut encrypted).await?; } - let payload = crypto.decrypt_c2s(hdr.sequence as u64, &encrypted)?; + let payload = crypto.decrypt_c2s_frame(hdr.sequence as u64, &encrypted, &buf)?; Ok((hdr, payload)) } @@ -122,3 +127,115 @@ pub async fn deliver_encrypted( let payload = &raw_data[PacketHeader::SIZE..]; send_encrypted(stream, pid, seq, payload, crypto).await } + +/// Incremental framing state survives cancellation by broadcast delivery. +pub struct EncryptedReader { + bytes: Vec, + expected_sequence: u32, +} +impl Default for EncryptedReader { + fn default() -> Self { + Self { + bytes: Vec::new(), + expected_sequence: 1, + } + } +} +impl EncryptedReader { + pub async fn read( + &mut self, + stream: &mut (impl AsyncRead + Unpin), + crypto: &SessionCrypto, + ) -> Result<(PacketHeader, Vec)> { + loop { + let needed = if self.bytes.len() < PacketHeader::SIZE { + PacketHeader::SIZE + } else { + let header: &[u8; PacketHeader::SIZE] = + self.bytes[..PacketHeader::SIZE].try_into().unwrap(); + let hdr = PacketHeader::from_bytes(header); + anyhow::ensure!( + hdr.flags == flags::ENCRYPTED, + "unsupported encrypted frame flags" + ); + anyhow::ensure!( + hdr.payload_length >= 16 && hdr.payload_length <= MAX_PAYLOAD, + "invalid encrypted payload size" + ); + anyhow::ensure!( + hdr.sequence == self.expected_sequence && hdr.sequence < u32::MAX, + "invalid packet sequence" + ); + PacketHeader::SIZE + hdr.payload_length as usize + }; + if self.bytes.len() == needed && needed > PacketHeader::SIZE { + let header: &[u8; PacketHeader::SIZE] = + self.bytes[..PacketHeader::SIZE].try_into().unwrap(); + let hdr = PacketHeader::from_bytes(header); + let payload = crypto.decrypt_c2s_frame( + hdr.sequence as u64, + &self.bytes[PacketHeader::SIZE..], + header, + )?; + self.bytes.clear(); + self.expected_sequence += 1; + return Ok((hdr, payload)); + } + let mut chunk = [0u8; 8192]; + let limit = (needed - self.bytes.len()).min(chunk.len()); + let count = stream.read(&mut chunk[..limit]).await?; + anyhow::ensure!(count > 0, "connection closed during frame"); + self.bytes.extend_from_slice(&chunk[..count]); + } + } +} + +#[cfg(test)] +mod reader_tests { + use super::*; + fn frame(crypto: &SessionCrypto, seq: u32) -> Vec { + let mut header = [0u8; 12]; + header[..2].copy_from_slice(&(PacketId::Ping as u16).to_be_bytes()); + header[2..4].copy_from_slice(&flags::ENCRYPTED.to_be_bytes()); + header[4..8].copy_from_slice(&seq.to_be_bytes()); + header[8..].copy_from_slice(&20u32.to_be_bytes()); + let mut bytes = header.to_vec(); + bytes.extend_from_slice(&crypto.encrypt_c2s_frame(seq as u64, b"ping", &header)); + bytes + } + #[tokio::test] + async fn cancelled_partial_read_preserves_framing_and_rejects_replay() { + let crypto = SessionCrypto::derive(&[7; 32], "fixture"); + let bytes = frame(&crypto, 1); + let (mut server, mut peer) = tokio::io::duplex(128); + let mut reader = EncryptedReader::default(); + peer.write_all(&bytes[..5]).await.unwrap(); + assert!( + tokio::time::timeout( + std::time::Duration::from_millis(2), + reader.read(&mut server, &crypto) + ) + .await + .is_err() + ); + peer.write_all(&bytes[5..]).await.unwrap(); + let (_, body) = reader.read(&mut server, &crypto).await.unwrap(); + assert_eq!(body, b"ping"); + peer.write_all(&bytes).await.unwrap(); + assert!(reader.read(&mut server, &crypto).await.is_err()); + } + #[tokio::test] + async fn modifying_authenticated_packet_type_is_rejected() { + let crypto = SessionCrypto::derive(&[7; 32], "fixture"); + let mut bytes = frame(&crypto, 1); + bytes[1] ^= 1; + let (mut server, mut peer) = tokio::io::duplex(128); + peer.write_all(&bytes).await.unwrap(); + assert!( + EncryptedReader::default() + .read(&mut server, &crypto) + .await + .is_err() + ); + } +} diff --git a/gateway/src/net/state.rs b/gateway/src/net/state.rs index 9376e9f..3420cf1 100644 --- a/gateway/src/net/state.rs +++ b/gateway/src/net/state.rs @@ -15,6 +15,8 @@ pub type VoiceMemberTx = tokio::sync::broadcast::Sender; #[derive(Clone)] pub struct State { + pub access: Arc>, + pub media: Arc, pub webhooks: Arc, pub sessions: SessionStore, pub channels: ChannelStore, @@ -57,6 +59,8 @@ impl State { let burst = config.gateway.message_rate_burst.unwrap_or(10); let rate_limiter = Arc::new(RateLimiter::new(rate_per_sec, burst)); Self { + access: Arc::default(), + media: Arc::default(), webhooks: Arc::default(), sessions, channels, diff --git a/gateway/src/proto/crypto/cipher.rs b/gateway/src/proto/crypto/cipher.rs index 30b8f42..2fd0206 100644 --- a/gateway/src/proto/crypto/cipher.rs +++ b/gateway/src/proto/crypto/cipher.rs @@ -15,6 +15,16 @@ pub(super) fn encrypt_with_key( cid: &[u8; 8], seq: u64, plaintext: &[u8], +) -> Vec { + encrypt_with_aad(key, cid, seq, plaintext, &[]) +} + +pub(super) fn encrypt_with_aad( + key: &[u8; 32], + cid: &[u8; 8], + seq: u64, + plaintext: &[u8], + aad: &[u8], ) -> Vec { let cipher = ChaCha20Poly1305::new(&Key::from(*key)); let nonce_bytes = make_nonce(cid, seq); @@ -24,7 +34,7 @@ pub(super) fn encrypt_with_key( &nonce, Payload { msg: plaintext, - aad: &[], + aad, }, ) .expect("ChaCha20-Poly1305 encryption is infallible") @@ -35,6 +45,16 @@ pub(super) fn decrypt_with_key( cid: &[u8; 8], seq: u64, ciphertext: &[u8], +) -> anyhow::Result> { + decrypt_with_aad(key, cid, seq, ciphertext, &[]) +} + +pub(super) fn decrypt_with_aad( + key: &[u8; 32], + cid: &[u8; 8], + seq: u64, + ciphertext: &[u8], + aad: &[u8], ) -> anyhow::Result> { let cipher = ChaCha20Poly1305::new(&Key::from(*key)); let nonce_bytes = make_nonce(cid, seq); @@ -44,7 +64,7 @@ pub(super) fn decrypt_with_key( &nonce, Payload { msg: ciphertext, - aad: &[], + aad, }, ) .map_err(|e| anyhow::anyhow!("decryption failed: {e:?}")) diff --git a/gateway/src/proto/crypto/mod.rs b/gateway/src/proto/crypto/mod.rs index bb8e7a1..39b4ed2 100644 --- a/gateway/src/proto/crypto/mod.rs +++ b/gateway/src/proto/crypto/mod.rs @@ -13,7 +13,7 @@ pub struct SessionCrypto { impl SessionCrypto { pub fn derive(shared_secret: &[u8; 32], session_id: &str) -> Self { - let salt = b"VNOX-LNEx-KDF-v1"; + let salt = b"VNOX-LNEx-KDF-v2"; let hk = Hkdf::::new(Some(salt), shared_secret); let mut keys = [0u8; 64]; @@ -42,6 +42,22 @@ impl SessionCrypto { cipher::decrypt_with_key(&self.c2s_key, &self.cid, seq, ciphertext) } + #[cfg(test)] + pub(crate) fn encrypt_c2s_frame(&self, seq: u64, plaintext: &[u8], header: &[u8]) -> Vec { + cipher::encrypt_with_aad(&self.c2s_key, &self.cid, seq, plaintext, header) + } + pub fn encrypt_s2c_frame(&self, seq: u64, plaintext: &[u8], header: &[u8]) -> Vec { + cipher::encrypt_with_aad(&self.s2c_key, &self.cid, seq, plaintext, header) + } + pub fn decrypt_c2s_frame( + &self, + seq: u64, + ciphertext: &[u8], + header: &[u8], + ) -> anyhow::Result> { + cipher::decrypt_with_aad(&self.c2s_key, &self.cid, seq, ciphertext, header) + } + pub fn new_ephemeral() -> (EphemeralSecret, PublicKey) { let mut rng = rand::rng(); let sk = EphemeralSecret::random_from_rng(&mut rng); diff --git a/gateway/src/proto/packet/id.rs b/gateway/src/proto/packet/id.rs index 42f646b..dd613c8 100644 --- a/gateway/src/proto/packet/id.rs +++ b/gateway/src/proto/packet/id.rs @@ -1,6 +1,9 @@ #[repr(u16)] #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum PacketId { + WebhookErrorResult = 0x0206, + MediaControl = 0x0180, + MediaEvent = 0x0181, WebhookCreate = 0x0200, WebhookList = 0x0201, WebhookRotate = 0x0202, @@ -12,6 +15,7 @@ pub enum PacketId { Session = 0x0003, Ping = 0x0004, Pong = 0x0005, + VoiceSession = 0x0012, VoicePacket = 0x0010, VoiceState = 0x0011, ChatMessage = 0x0020, @@ -65,6 +69,7 @@ pub enum PacketId { PresenceUpdate = 0x0140, PresenceSync = 0x0141, PresenceEvent = 0x0142, + FriendEvent = 0x0158, FriendRequest = 0x0150, FriendAccept = 0x0151, FriendDecline = 0x0152, @@ -80,6 +85,9 @@ pub enum PacketId { impl PacketId { pub fn from_u16(v: u16) -> Option { match v { + 0x0206 => Some(Self::WebhookErrorResult), + 0x0180 => Some(Self::MediaControl), + 0x0181 => Some(Self::MediaEvent), 0x0200 => Some(Self::WebhookCreate), 0x0201 => Some(Self::WebhookList), 0x0202 => Some(Self::WebhookRotate), @@ -91,6 +99,7 @@ impl PacketId { 0x0003 => Some(Self::Session), 0x0004 => Some(Self::Ping), 0x0005 => Some(Self::Pong), + 0x0012 => Some(Self::VoiceSession), 0x0010 => Some(Self::VoicePacket), 0x0011 => Some(Self::VoiceState), 0x0020 => Some(Self::ChatMessage), @@ -144,6 +153,7 @@ impl PacketId { 0x0140 => Some(Self::PresenceUpdate), 0x0141 => Some(Self::PresenceSync), 0x0142 => Some(Self::PresenceEvent), + 0x0158 => Some(Self::FriendEvent), 0x0150 => Some(Self::FriendRequest), 0x0151 => Some(Self::FriendAccept), 0x0152 => Some(Self::FriendDecline), diff --git a/gateway/src/webhooks/management.rs b/gateway/src/webhooks/management.rs index 3646b0f..6eb3c17 100644 --- a/gateway/src/webhooks/management.rs +++ b/gateway/src/webhooks/management.rs @@ -48,13 +48,33 @@ pub async fn handle( let Some(session) = crate::domain::session::get(&ctx.state.sessions, session_id).await else { return Ok(()); }; - if !ctx.state.rate_limiter.try_consume(session_id) { - return error(ctx, "rate limited").await; - } if payload.len() > 8192 { - return error(ctx, "webhook management payload too large").await; + return error( + ctx, + "", + ErrorCode::InvalidPacket, + "webhook management payload too large", + ) + .await; } let req = WebhookRequest::decode(payload)?; + let request_id = req.request_id.clone(); + if request_id.len() > 64 + || !request_id + .bytes() + .all(|b| b.is_ascii_alphanumeric() || b == b'-') + { + return error( + ctx, + "", + ErrorCode::InvalidPacket, + "invalid request identifier", + ) + .await; + } + if !ctx.state.rate_limiter.try_consume(session_id) { + return error(ctx, &request_id, ErrorCode::RateLimited, "rate limited").await; + } let existing = if pid == PacketId::WebhookRotate || pid == PacketId::WebhookRevoke { ctx.state.storage.hook(&req.id).await? } else { @@ -65,7 +85,13 @@ pub async fn handle( .map(|h| h.channel_id.as_str()) .unwrap_or(&req.channel_id); let Some(guild) = authorize(ctx.state, &session.user_id, channel).await? else { - return error(ctx, "permission denied").await; + return error( + ctx, + &request_id, + ErrorCode::PermissionDenied, + "permission denied", + ) + .await; }; if pid == PacketId::WebhookList { let hooks = ctx @@ -80,7 +106,7 @@ pub async fn handle( ctx.stream, PacketId::WebhookListResult, ctx.seq, - &to_payload(&WebhookListResult { hooks }), + &to_payload(&WebhookListResult { hooks, request_id }), ctx.crypto, ) .await; @@ -91,17 +117,25 @@ pub async fn handle( || req.name.chars().count() > 64 || req.name.chars().any(char::is_control) { - return error(ctx, "invalid name").await; + return error(ctx, &request_id, ErrorCode::InvalidPacket, "invalid name").await; } if !matches!( (req.direction.as_str(), req.provider.as_str()), ("incoming", "generic" | "github") | ("outgoing", "generic") ) { - return error(ctx, "unsupported webhook type").await; + return error( + ctx, + &request_id, + ErrorCode::InvalidPacket, + "unsupported webhook type", + ) + .await; } if req.direction == "outgoing" && policy::endpoint(&req.endpoint).is_err() { return error( ctx, + &request_id, + ErrorCode::InvalidPacket, "HTTPS public endpoint required; no credentials/query/fragment", ) .await; @@ -110,7 +144,13 @@ pub async fn handle( secret = secrets::new_secret(); let sealed = if req.direction == "outgoing" || req.provider == "github" { let Some(key) = ctx.state.webhooks.key() else { - return error(ctx, "webhook master key not configured").await; + return error( + ctx, + &request_id, + ErrorCode::Internal, + "webhook master key not configured", + ) + .await; }; secrets::seal(key, &id, &secret)? } else { @@ -135,11 +175,24 @@ pub async fn handle( revoked_at: None, suspended_reason: None, }; - ctx.state.storage.insert_hook(&h).await?; + if let Err(problem) = ctx.state.storage.insert_hook(&h).await { + let (code, message) = if problem.to_string() == "channel webhook limit reached" { + (ErrorCode::RateLimited, "channel webhook limit reached") + } else { + (ErrorCode::Internal, "webhook creation failed") + }; + return error(ctx, &request_id, code, message).await; + } h } else { let Some(mut h) = existing.filter(|h| h.revoked_at.is_none()) else { - return error(ctx, "webhook not found").await; + return error( + ctx, + &request_id, + ErrorCode::InvalidPacket, + "webhook not found", + ) + .await; }; if pid == PacketId::WebhookRevoke { ctx.state.storage.revoke_hook(&h.id).await?; @@ -148,7 +201,13 @@ pub async fn handle( secret = secrets::new_secret(); let sealed = if h.direction == "outgoing" || h.provider == "github" { let Some(key) = ctx.state.webhooks.key() else { - return error(ctx, "webhook master key not configured").await; + return error( + ctx, + &request_id, + ErrorCode::Internal, + "webhook master key not configured", + ) + .await; }; secrets::seal(key, &h.id, &secret)? } else { @@ -169,18 +228,25 @@ pub async fn handle( &to_payload(&WebhookResult { hook: Some(info(&hook)), secret, + request_id, }), ctx.crypto, ) .await } -async fn error(ctx: &mut Ctx<'_, S>, msg: &str) -> Result<()> { +async fn error( + ctx: &mut Ctx<'_, S>, + request_id: &str, + code: ErrorCode, + msg: &str, +) -> Result<()> { io::send_encrypted( ctx.stream, - PacketId::Error, + PacketId::WebhookErrorResult, ctx.seq, - &to_payload(&ErrorPayload { - code: ErrorCode::PermissionDenied as u32, + &to_payload(&WebhookErrorResult { + request_id: request_id.into(), + code: code as u32, message: msg.into(), }), ctx.crypto, diff --git a/gateway/src/webhooks/tests.rs b/gateway/src/webhooks/tests.rs index 7b14a46..1d99dd0 100644 --- a/gateway/src/webhooks/tests.rs +++ b/gateway/src/webhooks/tests.rs @@ -336,9 +336,10 @@ async fn lnex_management_rejects_stranger_and_creates_only_for_owner() { direction: "incoming".into(), provider: "generic".into(), endpoint: String::new(), + request_id: "request-123".into(), }; for (user, expected) in [ - ("stranger", PacketId::Error), + ("stranger", PacketId::WebhookErrorResult), ("owner", PacketId::WebhookResult), ] { let session = session::create(&s.sessions, user.into(), user.into()).await; diff --git a/protocol/lnex.proto b/protocol/lnex.proto index a74bd2e..3b18f62 100644 --- a/protocol/lnex.proto +++ b/protocol/lnex.proto @@ -10,6 +10,7 @@ message Hello { string node_name = 4; bytes server_eph_pubkey = 5; bool private_mode = 6; + bytes server_signature = 7; } message Auth { @@ -402,6 +403,7 @@ message WebhookRequest { string direction = 4; // incoming | outgoing string provider = 5; // generic | github (incoming only) string endpoint = 6; // outgoing HTTPS URL + string request_id = 7; } message WebhookInfo { string id = 1; @@ -414,5 +416,46 @@ message WebhookInfo { bool revoked = 8; string suspended_reason = 9; } -message WebhookResult { WebhookInfo hook = 1; string secret = 2; } -message WebhookListResult { repeated WebhookInfo hooks = 1; } +message WebhookResult { WebhookInfo hook = 1; string secret = 2; string request_id = 3; } +message WebhookListResult { repeated WebhookInfo hooks = 1; string request_id = 2; } +message WebhookErrorResult { string request_id = 1; uint32 code = 2; string message = 3; } + +// Authenticated signalling only; media uses DTLS/SRTP peer connections. +message MediaControl { + uint32 action = 1; // START1 STOP2 WATCH3 UNWATCH4 OFFER5 ANSWER6 ICE7 + string channel_id = 2; + string share_id = 3; + string target_session_id = 4; + string body = 5; + uint32 mline_index = 6; + bool application_audio = 7; + bool microphone = 8; +} +message MediaEvent { + uint32 action = 1; + string channel_id = 2; + string share_id = 3; + string target_session_id = 4; + string body = 5; + uint32 mline_index = 6; + bool application_audio = 7; + bool microphone = 8; + string sender_session_id = 9; + string publisher_user_id = 10; +} + +// Fresh credentials delivered only over the authenticated encrypted control session. +message VoiceSession { + bytes route_id = 1; + bytes c2s_key = 2; + bytes s2c_key = 3; + string channel_id = 4; +} +message VoiceFrame { + uint32 voice_seq = 1; + uint32 timestamp = 2; + string channel_id = 3; + string sender_session_id = 4; + bytes opus = 5; + string sender_user_id = 6; +} diff --git a/voice-node/Cargo.toml b/voice-node/Cargo.toml index d922709..29907ed 100644 --- a/voice-node/Cargo.toml +++ b/voice-node/Cargo.toml @@ -24,3 +24,10 @@ anyhow.workspace = true toml.workspace = true serde.workspace = true serde_json.workspace = true + +chacha20poly1305.workspace = true +hex.workspace = true +prost.workspace = true + +[build-dependencies] +prost-build.workspace = true diff --git a/voice-node/build.rs b/voice-node/build.rs new file mode 100644 index 0000000..987138c --- /dev/null +++ b/voice-node/build.rs @@ -0,0 +1,4 @@ +fn main() { + println!("cargo:rerun-if-changed=../protocol/lnex.proto"); + prost_build::compile_protos(&["../protocol/lnex.proto"], &["../protocol/"]).unwrap(); +} diff --git a/voice-node/src/lib.rs b/voice-node/src/lib.rs index 25343b2..73e52f5 100644 --- a/voice-node/src/lib.rs +++ b/voice-node/src/lib.rs @@ -1,3 +1,7 @@ +pub mod secure; +pub mod wire { + include!(concat!(env!("OUT_DIR"), "/lnex.rs")); +} pub mod jitter; pub mod relay; pub mod runner; diff --git a/voice-node/src/runner.rs b/voice-node/src/runner.rs index 04d4632..6a7b00f 100644 --- a/voice-node/src/runner.rs +++ b/voice-node/src/runner.rs @@ -1,141 +1,33 @@ -use std::net::SocketAddr; -use std::sync::Arc; -use std::time::{Duration, Instant}; -use tokio::net::UdpSocket; -use tokio::sync::broadcast; -use tracing::{debug, error, info, warn}; - -use crate::relay; -use crate::{ - Config, MAX_UDP_PACKET, PLAYOUT_INTERVAL_MS, VOICE_HDR_SIZE, VOICE_PACKET_ID, VoiceHeader, -}; +use crate::{Config, MAX_UDP_PACKET, secure::Relay}; +use tokio::{net::UdpSocket, sync::broadcast}; +use tracing::info; pub async fn run(config: Config) -> anyhow::Result<()> { - let (_, rx) = broadcast::channel(1); + let (_tx, rx) = broadcast::channel(1); run_bind(&config.node.name, &config.voice.bind, rx).await } - +/// Receives credentials only over the in-process gateway bridge. Standalone mode is fail-closed. pub async fn run_bind( node_name: &str, bind: &str, - mut voice_member_rx: broadcast::Receiver, + mut events: broadcast::Receiver, ) -> anyhow::Result<()> { - info!("VNOX Voice Node starting — node: {node_name}"); - info!("UDP bind: {bind}"); - let socket = UdpSocket::bind(bind).await?; - info!("voice node listening on {bind}"); - - let channels = relay::new_channel_map(); - let user_map = relay::new_user_map(); - - let channels_cleanup = channels.clone(); - tokio::spawn(async move { - let mut interval = tokio::time::interval(Duration::from_secs(15)); - loop { - interval.tick().await; - relay::cleanup_stale(&channels_cleanup, Duration::from_secs(30)).await; - } - }); - - let channels_events = channels.clone(); - let user_map_events = user_map.clone(); - tokio::spawn(async move { - while let Ok(event_str) = voice_member_rx.recv().await { - if let Ok(event) = serde_json::from_str::(&event_str) { - let event_type = event["type"].as_str().unwrap_or(""); - let channel_id = event["channel_id"].as_str().unwrap_or(""); - let user_id = event["user_id"].as_str().unwrap_or(""); - match event_type { - "join" => { - let endpoint_str = match event["endpoint"].as_str() { - Some(s) => s, - None => continue, - }; - let addr = match endpoint_str.parse::() { - Ok(a) => a, - Err(_) => continue, - }; - relay::add_user_mapping(&user_map_events, user_id.to_string(), addr).await; - if let Ok(ch) = channel_id.parse::() { - relay::touch_member(&channels_events, ch, addr).await; - } - } - "leave" => { - if let Some(addr) = - relay::remove_user_mapping(&user_map_events, user_id).await - { - relay::remove_member_from_all(&channels_events, &addr).await; - } - } - _ => {} - } - } - } - }); - - let socket = Arc::new(socket); - let socket_relay = socket.clone(); - let channels_playout = channels.clone(); - let epoch = Instant::now(); - tokio::spawn(async move { - let mut interval = tokio::time::interval(Duration::from_millis(PLAYOUT_INTERVAL_MS)); - loop { - interval.tick().await; - let now_ms = epoch.elapsed().as_millis() as u64; - relay::pop_and_relay(socket_relay.as_ref(), &channels_playout, now_ms).await; - } - }); - - let mut buf = vec![0u8; MAX_UDP_PACKET]; - + info!(node=node_name,address=%socket.local_addr()?,"authenticated UDP voice listening"); + let mut relay = Relay::default(); + let mut buffer = [0u8; MAX_UDP_PACKET + 1]; + let mut bridge_open = true; loop { - let (len, src) = match socket.recv_from(&mut buf).await { - Ok(r) => r, - Err(e) => { - error!("UDP recv error: {e}"); - continue; - } - }; - - let data = &buf[..len]; - - let hdr = match VoiceHeader::parse(data) { - Some(h) => h, - None => { - warn!("short packet from {src} ({len} bytes), dropping"); - continue; - } - }; - - if hdr.packet_id != VOICE_PACKET_ID { - debug!( - "non-voice packet 0x{:04X} from {src}, dropping", - hdr.packet_id - ); - continue; + tokio::select! { + event=events.recv(),if bridge_open=>match event { + Ok(value)=>if let Ok(event)=serde_json::from_str(&value){relay.event(&event);}, + Err(broadcast::error::RecvError::Lagged(_))=>relay.clear(), + Err(broadcast::error::RecvError::Closed)=>{relay.clear();bridge_open=false;}, + }, + result=socket.recv_from(&mut buffer)=>{ + let (len,src)=result?; + for (addr,packet) in relay.receive(&buffer[..len],src) {let _=socket.send_to(&packet,addr).await;} + } } - - relay::touch_member(&channels, hdr.channel_id, src).await; - - let arrived_at = epoch.elapsed().as_millis() as u64; - - debug!( - "voice seq={} ch={} from {src} ({} bytes opus)", - hdr.voice_seq, - hdr.channel_id, - len - VOICE_HDR_SIZE, - ); - - relay::push_packet( - &channels, - hdr.channel_id, - src, - hdr.voice_seq, - hdr.timestamp, - data, - arrived_at, - ) - .await; } } diff --git a/voice-node/src/secure.rs b/voice-node/src/secure.rs new file mode 100644 index 0000000..1dfb974 --- /dev/null +++ b/voice-node/src/secure.rs @@ -0,0 +1,294 @@ +//! Authenticated per-session UDP transport. No address or room is learned from plaintext. +use crate::wire::VoiceFrame; +use chacha20poly1305::{ + ChaCha20Poly1305, KeyInit, Nonce, + aead::{Aead, Payload}, +}; +use prost::Message; +use std::{ + collections::HashMap, + net::SocketAddr, + time::{Duration, Instant}, +}; +const HEADER: usize = 28; +const MAX_SESSIONS: usize = 4096; +#[derive(Default)] +struct Replay { + highest: Option, + seen: u128, +} +impl Replay { + fn accept(&mut self, seq: u64) -> bool { + match self.highest { + None => { + self.highest = Some(seq); + self.seen = 1; + true + } + Some(high) if seq > high => { + let gap = seq - high; + self.seen = if gap >= 128 { + 1 + } else { + (self.seen << gap) | 1 + }; + self.highest = Some(seq); + true + } + Some(high) => { + let gap = high - seq; + if gap >= 128 || self.seen & (1u128 << gap) != 0 { + return false; + } + self.seen |= 1u128 << gap; + true + } + } + } +} +struct Member { + session: String, + user: String, + channel: String, + c2s: [u8; 32], + s2c: [u8; 32], + addr: Option, + replay: Replay, + out_seq: u64, + window: Instant, + count: u32, + last: Instant, +} +impl Drop for Member { + fn drop(&mut self) { + self.c2s.fill(0); + self.s2c.fill(0); + } +} +#[derive(Default)] +pub struct Relay { + members: HashMap<[u8; 16], Member>, +} +fn bytes(event: &serde_json::Value, key: &str) -> Option<[u8; N]> { + hex::decode(event[key].as_str()?).ok()?.try_into().ok() +} +fn nonce(seq: u64) -> [u8; 12] { + let mut n = [0u8; 12]; + n[4..].copy_from_slice(&seq.to_be_bytes()); + n +} +fn encrypt(route: &[u8; 16], key: &[u8; 32], seq: u64, body: &[u8]) -> Option> { + let mut header = [0u8; HEADER]; + header[..2].copy_from_slice(&0x0010u16.to_be_bytes()); + header[2..4].copy_from_slice(&1u16.to_be_bytes()); + header[4..20].copy_from_slice(route); + header[20..].copy_from_slice(&seq.to_be_bytes()); + let cipher = ChaCha20Poly1305::new_from_slice(key).ok()?; + let n = Nonce::from(nonce(seq)); + let body = cipher + .encrypt( + &n, + Payload { + msg: body, + aad: &header, + }, + ) + .ok()?; + let mut packet = header.to_vec(); + packet.extend_from_slice(&body); + Some(packet) +} +impl Relay { + pub fn clear(&mut self) { + self.members.clear(); + } + pub fn event(&mut self, event: &serde_json::Value) { + let Some(session) = event["session_id"] + .as_str() + .filter(|s| !s.is_empty() && s.len() <= 128) + else { + return; + }; + match event["type"].as_str() { + Some("leave") => { + self.members.retain(|_, m| m.session != session); + } + Some("join") => { + let (Some(route), Some(c2s), Some(s2c), Some(channel), Some(user)) = ( + bytes(event, "route_id"), + bytes(event, "c2s_key"), + bytes(event, "s2c_key"), + event["channel_id"].as_str(), + event["user_id"].as_str(), + ) else { + return; + }; + if channel.is_empty() || channel.len() > 128 || user.len() > 128 { + return; + } + self.members.retain(|_, m| m.session != session); + if self.members.len() >= MAX_SESSIONS { + return; + } + self.members.insert( + route, + Member { + session: session.into(), + user: user.into(), + channel: channel.into(), + c2s, + s2c, + addr: None, + replay: Replay::default(), + out_seq: 0, + window: Instant::now(), + count: 0, + last: Instant::now(), + }, + ); + } + _ => {} + } + } + /// Verify before updating replay state, endpoint or source attribution. + pub fn receive(&mut self, packet: &[u8], src: SocketAddr) -> Vec<(SocketAddr, Vec)> { + if packet.len() < HEADER + 16 + || packet.len() > crate::MAX_UDP_PACKET + || packet[..4] != [0, 0x10, 0, 1] + { + return vec![]; + } + let route: [u8; 16] = packet[4..20].try_into().unwrap(); + let seq = u64::from_be_bytes(packet[20..28].try_into().unwrap()); + let Some(member) = self.members.get_mut(&route) else { + return vec![]; + }; + if member.window.elapsed() >= Duration::from_secs(1) { + member.window = Instant::now(); + member.count = 0; + } + if member.count >= 120 { + return vec![]; + } + + let cipher = ChaCha20Poly1305::new_from_slice(&member.c2s).expect("key length"); + let n = Nonce::from(nonce(seq)); + let Ok(body) = cipher.decrypt( + &n, + Payload { + msg: &packet[HEADER..], + aad: &packet[..HEADER], + }, + ) else { + return vec![]; + }; + let Ok(mut frame) = VoiceFrame::decode(body.as_slice()) else { + return vec![]; + }; + if frame.channel_id != member.channel + || !frame.sender_session_id.is_empty() + || !frame.sender_user_id.is_empty() + || frame.opus.len() > 1275 + || seq == u64::MAX + || !member.replay.accept(seq) + { + return vec![]; + } + member.count += 1; + member.addr = Some(src); + member.last = Instant::now(); + if frame.opus.is_empty() { + return vec![]; + } + frame.sender_session_id = member.session.clone(); + frame.sender_user_id = member.user.clone(); + let channel = member.channel.clone(); + let body = frame.encode_to_vec(); + let mut output = Vec::new(); + for (target_route, target) in &mut self.members { + if *target_route == route + || target.channel != channel + || target.last.elapsed() > Duration::from_secs(30) + || target.out_seq == u64::MAX + { + continue; + } + if let Some(addr) = target.addr + && let Some(packet) = encrypt(target_route, &target.s2c, target.out_seq, &body) + { + target.out_seq += 1; + if packet.len() <= crate::MAX_UDP_PACKET { + output.push((addr, packet)); + } + } + } + output + } +} +#[cfg(test)] +mod tests { + use super::*; + fn event(session: &str, user: &str, route: u8, key: u8, channel: &str) -> serde_json::Value { + serde_json::json!({"type":"join","session_id":session,"user_id":user,"route_id":hex::encode([route;16]),"c2s_key":hex::encode([key;32]),"s2c_key":hex::encode([key+1;32]),"channel_id":channel}) + } + fn packet(route: u8, key: u8, seq: u64, opus: &[u8]) -> Vec { + encrypt( + &[route; 16], + &[key; 32], + seq, + &VoiceFrame { + voice_seq: seq as u32, + timestamp: 0, + channel_id: "voice-uuid".into(), + sender_session_id: String::new(), + sender_user_id: String::new(), + opus: opus.into(), + } + .encode_to_vec(), + ) + .unwrap() + } + #[test] + fn relay_authenticates_reencrypts_stamps_rejects_replay_and_revokes() { + let mut relay = Relay::default(); + relay.event(&event("a", "alice", 1, 10, "voice-uuid")); + relay.event(&event("b", "bob", 2, 20, "voice-uuid")); + relay.event(&event("c", "other", 3, 30, "elsewhere")); + let a = "127.0.0.1:10001".parse().unwrap(); + let b = "127.0.0.1:10002".parse().unwrap(); + assert!(relay.receive(&packet(2, 20, 0, &[]), b).is_empty()); + assert!(relay.receive(&packet(1, 11, 0, b"bad key"), a).is_empty()); + let good = packet(1, 10, 0, b"opus"); + let out = relay.receive(&good, a); + assert_eq!(out.len(), 1); + assert_eq!(out[0].0, b); + let n = Nonce::from(nonce(0)); + let clear = ChaCha20Poly1305::new_from_slice(&[21; 32]) + .unwrap() + .decrypt( + &n, + Payload { + msg: &out[0].1[HEADER..], + aad: &out[0].1[..HEADER], + }, + ) + .unwrap(); + let frame = VoiceFrame::decode(clear.as_slice()).unwrap(); + assert_eq!(frame.sender_session_id, "a"); + assert_eq!(frame.sender_user_id, "alice"); + assert_eq!(frame.opus, b"opus"); + assert!(relay.receive(&good, a).is_empty()); + relay.event(&serde_json::json!({"type":"leave","session_id":"a"})); + assert!(relay.receive(&packet(1, 10, 1, b"opus"), a).is_empty()); + } + #[test] + fn replay_window_allows_reordering_but_never_duplicates_or_old_packets() { + let mut r = Replay::default(); + assert!(r.accept(100)); + assert!(r.accept(99)); + assert!(!r.accept(99)); + assert!(r.accept(200)); + assert!(!r.accept(1)); + assert!(r.accept(199)); + } +}