VNOX-Server/gateway/src/handler/guild/roles.rs
loki5512344 0d2af0ddd6
feat(gateway): TLS 1.3 only control plane and LNEx v3 channel-bound handshake
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
2026-10-24 22:05:30 +02:00

207 lines
5.2 KiB
Rust

use anyhow::Result;
use prost::Message;
use tokio::io::{AsyncRead, AsyncWrite};
use crate::{
domain::{permissions::Permissions, session},
net::{io, state::State},
proto::{PacketId, RoleCreatePayload, RoleDeletePayload, to_payload},
};
use super::send_err;
pub async fn handle_role_create(
stream: &mut (impl AsyncRead + AsyncWrite + Unpin),
seq: &mut u32,
session_id: &str,
payload: &[u8],
state: &State,
) -> Result<()> {
let req = RoleCreatePayload::decode(payload)?;
let sess = session::get(&state.sessions, session_id)
.await
.ok_or_else(|| anyhow::anyhow!("session not found"))?;
let access = state.access.write().await;
if !super::require_perm(
state,
&req.guild_id,
&sess.user_id,
Permissions::MANAGE_ROLES,
)
.await?
{
drop(access);
send_err(
stream,
seq,
crate::proto::ErrorCode::PermissionDenied,
"missing MANAGE_ROLES permission",
)
.await?;
return Ok(());
}
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",
)
.await?;
return Ok(());
}
let role_id = state
.storage
.create_role(&req.guild_id, &req.name, color, permissions, 1)
.await?;
state
.storage
.append_audit_log(
&req.guild_id,
&sess.user_id,
"ROLE_CREATE",
Some(&role_id),
Some("role"),
None,
)
.await?;
drop(access);
io::send_frame(
stream,
PacketId::RoleCreate,
seq,
&to_payload(&RoleCreatePayload {
guild_id: req.guild_id.clone(),
name: req.name.clone(),
color: req.color.clone(),
permissions: req.permissions,
id: role_id,
}),
)
.await?;
Ok(())
}
pub async fn handle_role_delete(
stream: &mut (impl AsyncRead + AsyncWrite + Unpin),
seq: &mut u32,
session_id: &str,
payload: &[u8],
state: &State,
) -> Result<()> {
let req = RoleDeletePayload::decode(payload)?;
let sess = session::get(&state.sessions, session_id)
.await
.ok_or_else(|| anyhow::anyhow!("session not found"))?;
let access = state.access.write().await;
if !super::require_perm(
state,
&req.guild_id,
&sess.user_id,
Permissions::MANAGE_ROLES,
)
.await?
{
drop(access);
send_err(
stream,
seq,
crate::proto::ErrorCode::PermissionDenied,
"missing MANAGE_ROLES permission",
)
.await?;
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",
)
.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",
)
.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(
&req.guild_id,
&sess.user_id,
"ROLE_DELETE",
Some(&req.role_id),
Some("role"),
None,
)
.await?;
drop(access);
io::send_frame(
stream,
PacketId::RoleDelete,
seq,
&to_payload(&RoleDeletePayload {
guild_id: req.guild_id.clone(),
role_id: req.role_id.clone(),
}),
)
.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))
}