Replace the X25519/HKDF/ChaCha20 TCP layer with rustls TLS 1.3 (ALPN vnox-lnex/3). Auto-generate a self-signed certificate keyed by the server identity or load an operator certificate, publish the SPKI fingerprint, bind HELLO and AUTH signatures to the TLS exporter, reject plaintext, TLS 1.2 and LNEx v2 peers with an explicit error. BREAKING: protocol v3. Claude-Session: https://claude.ai/code/session_01GDjxLvBcnJqniFQGUGb1V4
678 lines
19 KiB
Rust
678 lines
19 KiB
Rust
use super::*;
|
|
use std::sync::{Arc, atomic::AtomicUsize};
|
|
|
|
async fn fixture() -> (State, String) {
|
|
let storage = crate::domain::storage::Storage::connect_sqlite(":memory:")
|
|
.await
|
|
.unwrap();
|
|
let config = toml::from_str(include_str!("../../../../../dev/config.toml")).unwrap();
|
|
let identity_dir =
|
|
std::env::temp_dir().join(format!("vnox-join-test-{}", uuid::Uuid::new_v4()));
|
|
let identity =
|
|
crate::bootstrap::server_identity::ServerIdentity::load_or_generate(&identity_dir).unwrap();
|
|
std::fs::remove_file(identity_dir.join("server_identity.json")).unwrap();
|
|
std::fs::remove_dir(identity_dir).unwrap();
|
|
let (broadcast, _) = tokio::sync::broadcast::channel(16);
|
|
let state = State::new(
|
|
session::new_store(),
|
|
channels::new_store(),
|
|
Arc::new(storage),
|
|
Arc::new(config),
|
|
Arc::new(identity),
|
|
broadcast,
|
|
crate::admin::metrics::Metrics::new(),
|
|
Arc::new(AtomicUsize::new(0)),
|
|
Arc::new(AtomicUsize::new(0)),
|
|
None,
|
|
);
|
|
let sess = session::create(&state.sessions, "visitor".into(), "Visitor".into()).await;
|
|
channels::join(&state.channels, "general", &sess.session_id).await;
|
|
set_channel(&state, &sess.session_id, Some("general".into())).await;
|
|
(state, sess.session_id)
|
|
}
|
|
|
|
async fn attempt_join(state: &State, session_id: &str, channel_id: &str) {
|
|
let (mut stream, _peer) = tokio::io::duplex(65536);
|
|
join(
|
|
&mut stream,
|
|
&mut 0,
|
|
session_id,
|
|
channel_id,
|
|
state,
|
|
"127.0.0.1:12345".parse().unwrap(),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn missing_channel_keeps_previous_membership() {
|
|
let (state, sid) = fixture().await;
|
|
attempt_join(&state, &sid, "missing").await;
|
|
assert!(
|
|
channels::members(&state.channels, "general")
|
|
.await
|
|
.contains(&sid)
|
|
);
|
|
assert_eq!(
|
|
session::get(&state.sessions, &sid)
|
|
.await
|
|
.unwrap()
|
|
.channel_id
|
|
.as_deref(),
|
|
Some("general")
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn outsider_cannot_join_guild_channel_or_lose_previous_membership() {
|
|
let (state, sid) = fixture().await;
|
|
let guild_id = state
|
|
.storage
|
|
.create_guild("owner", "Private guild")
|
|
.await
|
|
.unwrap();
|
|
channels::create(
|
|
&state.channels,
|
|
"private",
|
|
"Private",
|
|
channels::ChannelKind::Text,
|
|
Some(guild_id),
|
|
)
|
|
.await;
|
|
attempt_join(&state, &sid, "private").await;
|
|
assert!(
|
|
!channels::members(&state.channels, "private")
|
|
.await
|
|
.contains(&sid)
|
|
);
|
|
assert!(
|
|
channels::members(&state.channels, "general")
|
|
.await
|
|
.contains(&sid)
|
|
);
|
|
assert_eq!(
|
|
session::get(&state.sessions, &sid)
|
|
.await
|
|
.unwrap()
|
|
.channel_id
|
|
.as_deref(),
|
|
Some("general")
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn guild_member_can_switch_channels() {
|
|
let (state, sid) = fixture().await;
|
|
let guild_id = state
|
|
.storage
|
|
.create_guild("owner", "Private guild")
|
|
.await
|
|
.unwrap();
|
|
state
|
|
.storage
|
|
.add_guild_member(&guild_id, "visitor")
|
|
.await
|
|
.unwrap();
|
|
channels::create(
|
|
&state.channels,
|
|
"private",
|
|
"Private",
|
|
channels::ChannelKind::Text,
|
|
Some(guild_id),
|
|
)
|
|
.await;
|
|
attempt_join(&state, &sid, "private").await;
|
|
assert!(
|
|
channels::members(&state.channels, "private")
|
|
.await
|
|
.contains(&sid)
|
|
);
|
|
assert!(
|
|
!channels::members(&state.channels, "general")
|
|
.await
|
|
.contains(&sid)
|
|
);
|
|
assert_eq!(
|
|
session::get(&state.sessions, &sid)
|
|
.await
|
|
.unwrap()
|
|
.channel_id
|
|
.as_deref(),
|
|
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", &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", &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);
|
|
crate::handler::channel::handle_channel_edit(
|
|
&mut stream,
|
|
&mut 0,
|
|
&sid,
|
|
&to_payload(&ChannelEditPayload {
|
|
channel_id: "managed".into(),
|
|
channel_name: "stolen".into(),
|
|
}),
|
|
&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(),
|
|
}),
|
|
&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(),
|
|
}),
|
|
&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);
|
|
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(),
|
|
}),
|
|
&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(),
|
|
}),
|
|
&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,
|
|
}),
|
|
&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,
|
|
}),
|
|
&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 (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),
|
|
&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(),
|
|
}),
|
|
&state,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
crate::handler::channel::handle_channel_delete(
|
|
&mut stream,
|
|
&mut 0,
|
|
&owner_sid,
|
|
&to_payload(&ChannelDeletePayload {
|
|
channel_id: creation.channel_id.clone(),
|
|
}),
|
|
&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 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_frame(
|
|
&mut stream,
|
|
&mut seq,
|
|
&sid,
|
|
&history("general"),
|
|
&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", &state)
|
|
.await
|
|
.unwrap();
|
|
let (mut stream, mut peer) = tokio::io::duplex(65536);
|
|
crate::handler::deliver::deliver_frame(
|
|
&mut stream,
|
|
&mut seq,
|
|
&sid,
|
|
&history("general"),
|
|
&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_frame(&mut stream, &mut seq, &sid, &queued, &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"
|
|
);
|
|
}
|