feat(server): protocol v2 with signed handshake, secure voice relay, media broadcast and channel authorization
Revoke voice access on channel delete, kick and permission change, and acknowledge the sender's own chat messages.
This commit is contained in:
parent
bc5157046e
commit
3e7f5b22dc
44 changed files with 2825 additions and 386 deletions
|
|
@ -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<u8> {
|
||||
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<Self> {
|
||||
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::<std::io::Error>()
|
||||
.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();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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<String>,
|
||||
pub voice_channel_id: Option<String>,
|
||||
}
|
||||
|
||||
pub type SessionStore = Arc<RwLock<HashMap<String, Session>>>;
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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<P> = 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<P> = 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)
|
||||
|
|
|
|||
|
|
@ -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<ChannelListItem> = 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()
|
||||
|
|
|
|||
|
|
@ -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(())
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
});
|
||||
|
|
|
|||
|
|
@ -33,3 +33,274 @@ async fn set_channel(state: &State, session_id: &str, ch: Option<String>) {
|
|||
s.channel_id = ch;
|
||||
}
|
||||
}
|
||||
|
||||
async fn set_voice_channel(state: &State, session_id: &str, ch: Option<String>) {
|
||||
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<bool> {
|
||||
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<u8>,
|
||||
) -> 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))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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(())
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)),
|
||||
});
|
||||
|
|
|
|||
|
|
@ -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)),
|
||||
});
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ pub async fn dispatch<S: AsyncRead + AsyncWrite + Unpin>(
|
|||
addr: std::net::SocketAddr,
|
||||
) -> Result<()> {
|
||||
match pid {
|
||||
PacketId::MediaControl => crate::media::handle(ctx, session_id, payload).await?,
|
||||
PacketId::WebhookCreate
|
||||
| PacketId::WebhookList
|
||||
| PacketId::WebhookRotate
|
||||
|
|
|
|||
|
|
@ -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)),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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<GuildRoleInfoPayload> = rows
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<bool> {
|
||||
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<Option<u64>> {
|
||||
Ok(state
|
||||
.storage
|
||||
.list_guild_roles(guild)
|
||||
.await?
|
||||
.into_iter()
|
||||
.find(|r| r.id == role)
|
||||
.map(|r| r.permissions as u64))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,9 +25,10 @@ pub async fn run_session<S: AsyncRead + AsyncWrite + Unpin>(
|
|||
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,
|
||||
|
|
|
|||
|
|
@ -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<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(
|
|||
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<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(
|
|||
});
|
||||
}
|
||||
|
||||
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
|
||||
|
|
|
|||
524
gateway/src/media/mod.rs
Normal file
524
gateway/src/media/mod.rs
Normal file
|
|
@ -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<String>,
|
||||
audio: bool,
|
||||
mic: bool,
|
||||
}
|
||||
#[derive(Default)]
|
||||
pub struct Runtime {
|
||||
shares: Mutex<HashMap<String, Share>>,
|
||||
rates: Mutex<HashMap<String, SignalBudget>>,
|
||||
}
|
||||
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<String>,
|
||||
) -> Result<Vec<Route>> {
|
||||
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<Route>) {
|
||||
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<S: AsyncRead + AsyncWrite + Unpin>(
|
||||
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<Vec<Route>> {
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
|
@ -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(
|
||||
|
|
|
|||
|
|
@ -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<u8>,
|
||||
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<u8>)> {
|
||||
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<u8> {
|
||||
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()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,6 +15,8 @@ pub type VoiceMemberTx = tokio::sync::broadcast::Sender<String>;
|
|||
|
||||
#[derive(Clone)]
|
||||
pub struct State {
|
||||
pub access: Arc<tokio::sync::RwLock<()>>,
|
||||
pub media: Arc<crate::media::Runtime>,
|
||||
pub webhooks: Arc<crate::webhooks::Runtime>,
|
||||
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,
|
||||
|
|
|
|||
|
|
@ -15,6 +15,16 @@ pub(super) fn encrypt_with_key(
|
|||
cid: &[u8; 8],
|
||||
seq: u64,
|
||||
plaintext: &[u8],
|
||||
) -> Vec<u8> {
|
||||
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<u8> {
|
||||
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<Vec<u8>> {
|
||||
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<Vec<u8>> {
|
||||
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:?}"))
|
||||
|
|
|
|||
|
|
@ -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::<Sha256>::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<u8> {
|
||||
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<u8> {
|
||||
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<Vec<u8>> {
|
||||
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);
|
||||
|
|
|
|||
|
|
@ -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<Self> {
|
||||
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),
|
||||
|
|
|
|||
|
|
@ -48,13 +48,33 @@ pub async fn handle<S: AsyncRead + AsyncWrite + Unpin>(
|
|||
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<S: AsyncRead + AsyncWrite + Unpin>(
|
|||
.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<S: AsyncRead + AsyncWrite + Unpin>(
|
|||
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<S: AsyncRead + AsyncWrite + Unpin>(
|
|||
|| 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<S: AsyncRead + AsyncWrite + Unpin>(
|
|||
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<S: AsyncRead + AsyncWrite + Unpin>(
|
|||
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<S: AsyncRead + AsyncWrite + Unpin>(
|
|||
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<S: AsyncRead + AsyncWrite + Unpin>(
|
|||
&to_payload(&WebhookResult {
|
||||
hook: Some(info(&hook)),
|
||||
secret,
|
||||
request_id,
|
||||
}),
|
||||
ctx.crypto,
|
||||
)
|
||||
.await
|
||||
}
|
||||
async fn error<S: AsyncRead + AsyncWrite + Unpin>(ctx: &mut Ctx<'_, S>, msg: &str) -> Result<()> {
|
||||
async fn error<S: AsyncRead + AsyncWrite + Unpin>(
|
||||
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,
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue