Christian Nennemann
a710037dde
Rename all crate directories, package names, binary names, proto package/module paths, ALPN strings, env var prefixes, config filenames, mDNS service names, and plugin ABI symbols from quicproquo/qpq to quicprochat/qpc.
525 lines
18 KiB
Rust
525 lines
18 KiB
Rust
//! Rich application-layer message format for MLS application payloads.
|
|
//!
|
|
//! The server sees only opaque ciphertext; structure lives in this client-defined
|
|
//! plaintext schema. All messages use: version byte (1) + message_type byte + type-specific payload.
|
|
//!
|
|
//! # Message ID
|
|
//!
|
|
//! `message_id` is assigned by the sender (16 random bytes) and included in the
|
|
//! serialized payload for Chat (and implied for Reply/Reaction/ReadReceipt via ref_msg_id).
|
|
//! Recipients can store message_ids to reference them in replies or reactions.
|
|
|
|
use crate::error::CoreError;
|
|
use rand::RngCore;
|
|
|
|
/// Current schema version.
|
|
pub const VERSION: u8 = 1;
|
|
|
|
/// Message type discriminant (one byte).
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
#[repr(u8)]
|
|
pub enum MessageType {
|
|
Chat = 0x01,
|
|
Reply = 0x02,
|
|
Reaction = 0x03,
|
|
ReadReceipt = 0x04,
|
|
Typing = 0x05,
|
|
Edit = 0x06,
|
|
Delete = 0x07,
|
|
FileRef = 0x08,
|
|
Dummy = 0x09,
|
|
}
|
|
|
|
impl MessageType {
|
|
fn from_byte(b: u8) -> Option<Self> {
|
|
match b {
|
|
0x01 => Some(MessageType::Chat),
|
|
0x02 => Some(MessageType::Reply),
|
|
0x03 => Some(MessageType::Reaction),
|
|
0x04 => Some(MessageType::ReadReceipt),
|
|
0x05 => Some(MessageType::Typing),
|
|
0x06 => Some(MessageType::Edit),
|
|
0x07 => Some(MessageType::Delete),
|
|
0x08 => Some(MessageType::FileRef),
|
|
0x09 => Some(MessageType::Dummy),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Parsed application message (one of the rich types).
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub enum AppMessage {
|
|
/// Plain chat: body (UTF-8). message_id is included so recipients can store and reference it.
|
|
Chat {
|
|
message_id: [u8; 16],
|
|
body: Vec<u8>,
|
|
},
|
|
Reply {
|
|
ref_msg_id: [u8; 16],
|
|
body: Vec<u8>,
|
|
},
|
|
Reaction {
|
|
ref_msg_id: [u8; 16],
|
|
emoji: Vec<u8>,
|
|
},
|
|
ReadReceipt {
|
|
msg_id: [u8; 16],
|
|
},
|
|
Typing {
|
|
/// 0 = stopped, 1 = typing
|
|
active: u8,
|
|
},
|
|
/// Edit a previously sent message (identified by ref_msg_id).
|
|
Edit {
|
|
ref_msg_id: [u8; 16],
|
|
body: Vec<u8>,
|
|
},
|
|
/// Delete a previously sent message (identified by ref_msg_id).
|
|
Delete {
|
|
ref_msg_id: [u8; 16],
|
|
},
|
|
/// File reference: metadata pointing to a blob stored on the server.
|
|
FileRef {
|
|
blob_id: [u8; 32],
|
|
filename: Vec<u8>,
|
|
file_size: u64,
|
|
mime_type: Vec<u8>,
|
|
},
|
|
/// Dummy message for traffic analysis resistance (no user-visible content).
|
|
Dummy,
|
|
}
|
|
|
|
/// Generate a new 16-byte message ID (e.g. for Chat/Reply so recipients can reference it).
|
|
pub fn generate_message_id() -> [u8; 16] {
|
|
let mut id = [0u8; 16];
|
|
rand::rngs::OsRng.fill_bytes(&mut id);
|
|
id
|
|
}
|
|
|
|
// ── Layout (minimal, no Cap'n Proto) ─────────────────────────────────────────
|
|
//
|
|
// All messages: [version: 1][type: 1][payload...]
|
|
//
|
|
// Chat: [msg_id: 16][body_len: 2 BE][body]
|
|
// Reply: [ref_msg_id: 16][body_len: 2 BE][body]
|
|
// Reaction: [ref_msg_id: 16][emoji_len: 1][emoji]
|
|
// ReadReceipt: [msg_id: 16]
|
|
// Typing: [active: 1] 0 = stopped, 1 = typing
|
|
// Edit: [ref_msg_id: 16][body_len: 2 BE][body]
|
|
// Delete: [ref_msg_id: 16]
|
|
// FileRef: [blob_id: 32][filename_len: 2 BE][filename][file_size: 8 BE][mime_len: 2 BE][mime_type]
|
|
|
|
/// Serialize a rich message into the application payload format.
|
|
pub fn serialize(msg_type: MessageType, payload: &[u8]) -> Vec<u8> {
|
|
let mut out = Vec::with_capacity(2 + payload.len());
|
|
out.push(VERSION);
|
|
out.push(msg_type as u8);
|
|
out.extend_from_slice(payload);
|
|
out
|
|
}
|
|
|
|
/// Serialize a Chat message (generates message_id internally; pass None to generate, or Some(id) when replying with a known id).
|
|
pub fn serialize_chat(body: &[u8], message_id: Option<[u8; 16]>) -> Result<Vec<u8>, CoreError> {
|
|
if body.len() > u16::MAX as usize {
|
|
return Err(CoreError::AppMessage("chat body exceeds maximum length (65535 bytes)".into()));
|
|
}
|
|
let id = message_id.unwrap_or_else(generate_message_id);
|
|
let mut payload = Vec::with_capacity(16 + 2 + body.len());
|
|
payload.extend_from_slice(&id);
|
|
payload.extend_from_slice(&(body.len() as u16).to_be_bytes());
|
|
payload.extend_from_slice(body);
|
|
Ok(serialize(MessageType::Chat, &payload))
|
|
}
|
|
|
|
/// Serialize a Reply message.
|
|
pub fn serialize_reply(ref_msg_id: [u8; 16], body: &[u8]) -> Result<Vec<u8>, CoreError> {
|
|
if body.len() > u16::MAX as usize {
|
|
return Err(CoreError::AppMessage("reply body exceeds maximum length (65535 bytes)".into()));
|
|
}
|
|
let mut payload = Vec::with_capacity(16 + 2 + body.len());
|
|
payload.extend_from_slice(&ref_msg_id);
|
|
payload.extend_from_slice(&(body.len() as u16).to_be_bytes());
|
|
payload.extend_from_slice(body);
|
|
Ok(serialize(MessageType::Reply, &payload))
|
|
}
|
|
|
|
/// Serialize a Reaction message.
|
|
pub fn serialize_reaction(ref_msg_id: [u8; 16], emoji: &[u8]) -> Result<Vec<u8>, CoreError> {
|
|
if emoji.len() > 255 {
|
|
return Err(CoreError::AppMessage("emoji length > 255".into()));
|
|
}
|
|
let mut payload = Vec::with_capacity(16 + 1 + emoji.len());
|
|
payload.extend_from_slice(&ref_msg_id);
|
|
payload.push(emoji.len() as u8);
|
|
payload.extend_from_slice(emoji);
|
|
Ok(serialize(MessageType::Reaction, &payload))
|
|
}
|
|
|
|
/// Serialize a ReadReceipt message.
|
|
pub fn serialize_read_receipt(msg_id: [u8; 16]) -> Vec<u8> {
|
|
serialize(MessageType::ReadReceipt, &msg_id)
|
|
}
|
|
|
|
/// Serialize a Typing message (active: 0 = stopped, 1 = typing).
|
|
pub fn serialize_typing(active: u8) -> Vec<u8> {
|
|
let payload = [active];
|
|
serialize(MessageType::Typing, &payload)
|
|
}
|
|
|
|
/// Serialize an Edit message (replaces body of a previously sent message).
|
|
pub fn serialize_edit(ref_msg_id: &[u8; 16], body: &[u8]) -> Result<Vec<u8>, CoreError> {
|
|
if body.len() > u16::MAX as usize {
|
|
return Err(CoreError::AppMessage("edit body exceeds maximum length (65535 bytes)".into()));
|
|
}
|
|
let mut payload = Vec::with_capacity(16 + 2 + body.len());
|
|
payload.extend_from_slice(ref_msg_id);
|
|
payload.extend_from_slice(&(body.len() as u16).to_be_bytes());
|
|
payload.extend_from_slice(body);
|
|
Ok(serialize(MessageType::Edit, &payload))
|
|
}
|
|
|
|
/// Serialize a Delete message (marks a previously sent message as deleted).
|
|
pub fn serialize_delete(ref_msg_id: &[u8; 16]) -> Vec<u8> {
|
|
serialize(MessageType::Delete, ref_msg_id)
|
|
}
|
|
|
|
/// Serialize a FileRef message (metadata pointing to a blob on the server).
|
|
pub fn serialize_file_ref(
|
|
blob_id: &[u8; 32],
|
|
filename: &[u8],
|
|
file_size: u64,
|
|
mime_type: &[u8],
|
|
) -> Result<Vec<u8>, CoreError> {
|
|
if filename.len() > u16::MAX as usize {
|
|
return Err(CoreError::AppMessage("filename exceeds maximum length".into()));
|
|
}
|
|
if mime_type.len() > u16::MAX as usize {
|
|
return Err(CoreError::AppMessage("mime_type exceeds maximum length".into()));
|
|
}
|
|
let mut payload = Vec::with_capacity(32 + 2 + filename.len() + 8 + 2 + mime_type.len());
|
|
payload.extend_from_slice(blob_id);
|
|
payload.extend_from_slice(&(filename.len() as u16).to_be_bytes());
|
|
payload.extend_from_slice(filename);
|
|
payload.extend_from_slice(&file_size.to_be_bytes());
|
|
payload.extend_from_slice(&(mime_type.len() as u16).to_be_bytes());
|
|
payload.extend_from_slice(mime_type);
|
|
Ok(serialize(MessageType::FileRef, &payload))
|
|
}
|
|
|
|
/// Serialize a Dummy message (traffic padding — no user content).
|
|
pub fn serialize_dummy() -> Vec<u8> {
|
|
serialize(MessageType::Dummy, &[])
|
|
}
|
|
|
|
/// Parse bytes into (MessageType, AppMessage). Fails if version/type unknown or payload too short.
|
|
pub fn parse(bytes: &[u8]) -> Result<(MessageType, AppMessage), CoreError> {
|
|
if bytes.len() < 2 {
|
|
return Err(CoreError::AppMessage("payload too short (need version + type)".into()));
|
|
}
|
|
let version = bytes[0];
|
|
if version != VERSION {
|
|
return Err(CoreError::AppMessage(format!("unsupported version {version}")));
|
|
}
|
|
let msg_type = MessageType::from_byte(bytes[1])
|
|
.ok_or_else(|| CoreError::AppMessage(format!("unknown message type {}", bytes[1])))?;
|
|
let payload = &bytes[2..];
|
|
|
|
let app = match msg_type {
|
|
MessageType::Chat => parse_chat(payload)?,
|
|
MessageType::Reply => parse_reply(payload)?,
|
|
MessageType::Reaction => parse_reaction(payload)?,
|
|
MessageType::ReadReceipt => parse_read_receipt(payload)?,
|
|
MessageType::Typing => parse_typing(payload)?,
|
|
MessageType::Edit => parse_edit(payload)?,
|
|
MessageType::Delete => parse_delete(payload)?,
|
|
MessageType::FileRef => parse_file_ref(payload)?,
|
|
MessageType::Dummy => AppMessage::Dummy,
|
|
};
|
|
Ok((msg_type, app))
|
|
}
|
|
|
|
fn parse_chat(payload: &[u8]) -> Result<AppMessage, CoreError> {
|
|
if payload.len() < 16 + 2 {
|
|
return Err(CoreError::AppMessage("Chat payload too short".into()));
|
|
}
|
|
let mut message_id = [0u8; 16];
|
|
message_id.copy_from_slice(&payload[..16]);
|
|
let body_len = u16::from_be_bytes([payload[16], payload[17]]) as usize;
|
|
if payload.len() < 18 + body_len {
|
|
return Err(CoreError::AppMessage("Chat body length exceeds payload".into()));
|
|
}
|
|
let body = payload[18..18 + body_len].to_vec();
|
|
Ok(AppMessage::Chat { message_id, body })
|
|
}
|
|
|
|
fn parse_reply(payload: &[u8]) -> Result<AppMessage, CoreError> {
|
|
if payload.len() < 16 + 2 {
|
|
return Err(CoreError::AppMessage("Reply payload too short".into()));
|
|
}
|
|
let mut ref_msg_id = [0u8; 16];
|
|
ref_msg_id.copy_from_slice(&payload[..16]);
|
|
let body_len = u16::from_be_bytes([payload[16], payload[17]]) as usize;
|
|
if payload.len() < 18 + body_len {
|
|
return Err(CoreError::AppMessage("Reply body length exceeds payload".into()));
|
|
}
|
|
let body = payload[18..18 + body_len].to_vec();
|
|
Ok(AppMessage::Reply { ref_msg_id, body })
|
|
}
|
|
|
|
fn parse_reaction(payload: &[u8]) -> Result<AppMessage, CoreError> {
|
|
if payload.len() < 16 + 1 {
|
|
return Err(CoreError::AppMessage("Reaction payload too short".into()));
|
|
}
|
|
let mut ref_msg_id = [0u8; 16];
|
|
ref_msg_id.copy_from_slice(&payload[..16]);
|
|
let emoji_len = payload[16] as usize;
|
|
if payload.len() < 17 + emoji_len {
|
|
return Err(CoreError::AppMessage("Reaction emoji length exceeds payload".into()));
|
|
}
|
|
let emoji = payload[17..17 + emoji_len].to_vec();
|
|
Ok(AppMessage::Reaction { ref_msg_id, emoji })
|
|
}
|
|
|
|
fn parse_read_receipt(payload: &[u8]) -> Result<AppMessage, CoreError> {
|
|
if payload.len() < 16 {
|
|
return Err(CoreError::AppMessage("ReadReceipt payload too short".into()));
|
|
}
|
|
let mut msg_id = [0u8; 16];
|
|
msg_id.copy_from_slice(&payload[..16]);
|
|
Ok(AppMessage::ReadReceipt { msg_id })
|
|
}
|
|
|
|
fn parse_typing(payload: &[u8]) -> Result<AppMessage, CoreError> {
|
|
if payload.is_empty() {
|
|
return Err(CoreError::AppMessage("Typing payload empty".into()));
|
|
}
|
|
Ok(AppMessage::Typing { active: payload[0] })
|
|
}
|
|
|
|
fn parse_edit(payload: &[u8]) -> Result<AppMessage, CoreError> {
|
|
if payload.len() < 16 + 2 {
|
|
return Err(CoreError::AppMessage("Edit payload too short".into()));
|
|
}
|
|
let mut ref_msg_id = [0u8; 16];
|
|
ref_msg_id.copy_from_slice(&payload[..16]);
|
|
let body_len = u16::from_be_bytes([payload[16], payload[17]]) as usize;
|
|
if payload.len() < 18 + body_len {
|
|
return Err(CoreError::AppMessage("Edit body length exceeds payload".into()));
|
|
}
|
|
let body = payload[18..18 + body_len].to_vec();
|
|
Ok(AppMessage::Edit { ref_msg_id, body })
|
|
}
|
|
|
|
fn parse_delete(payload: &[u8]) -> Result<AppMessage, CoreError> {
|
|
if payload.len() < 16 {
|
|
return Err(CoreError::AppMessage("Delete payload too short".into()));
|
|
}
|
|
let mut ref_msg_id = [0u8; 16];
|
|
ref_msg_id.copy_from_slice(&payload[..16]);
|
|
Ok(AppMessage::Delete { ref_msg_id })
|
|
}
|
|
|
|
fn parse_file_ref(payload: &[u8]) -> Result<AppMessage, CoreError> {
|
|
// blob_id(32) + filename_len(2) minimum
|
|
if payload.len() < 34 {
|
|
return Err(CoreError::AppMessage("FileRef payload too short".into()));
|
|
}
|
|
let mut blob_id = [0u8; 32];
|
|
blob_id.copy_from_slice(&payload[..32]);
|
|
let filename_len = u16::from_be_bytes([payload[32], payload[33]]) as usize;
|
|
let pos = 34;
|
|
if payload.len() < pos + filename_len + 8 + 2 {
|
|
return Err(CoreError::AppMessage("FileRef payload truncated after filename_len".into()));
|
|
}
|
|
let filename = payload[pos..pos + filename_len].to_vec();
|
|
let pos = pos + filename_len;
|
|
let file_size = u64::from_be_bytes([
|
|
payload[pos], payload[pos + 1], payload[pos + 2], payload[pos + 3],
|
|
payload[pos + 4], payload[pos + 5], payload[pos + 6], payload[pos + 7],
|
|
]);
|
|
let pos = pos + 8;
|
|
let mime_len = u16::from_be_bytes([payload[pos], payload[pos + 1]]) as usize;
|
|
let pos = pos + 2;
|
|
if payload.len() < pos + mime_len {
|
|
return Err(CoreError::AppMessage("FileRef payload truncated after mime_len".into()));
|
|
}
|
|
let mime_type = payload[pos..pos + mime_len].to_vec();
|
|
Ok(AppMessage::FileRef { blob_id, filename, file_size, mime_type })
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[allow(clippy::unwrap_used)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn roundtrip_chat() {
|
|
let body = b"hello";
|
|
let encoded = serialize_chat(body, None).unwrap();
|
|
let (t, msg) = parse(&encoded).unwrap();
|
|
assert_eq!(t, MessageType::Chat);
|
|
match &msg {
|
|
AppMessage::Chat { message_id: _, body: b } => assert_eq!(b.as_slice(), body),
|
|
_ => panic!("expected Chat"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn roundtrip_reply() {
|
|
let ref_id = [1u8; 16];
|
|
let body = b"reply text";
|
|
let encoded = serialize_reply(ref_id, body).unwrap();
|
|
let (t, msg) = parse(&encoded).unwrap();
|
|
assert_eq!(t, MessageType::Reply);
|
|
match &msg {
|
|
AppMessage::Reply { ref_msg_id, body: b } => {
|
|
assert_eq!(ref_msg_id, &ref_id);
|
|
assert_eq!(b.as_slice(), body);
|
|
}
|
|
_ => panic!("expected Reply"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn roundtrip_typing() {
|
|
let encoded = serialize_typing(1);
|
|
let (t, msg) = parse(&encoded).unwrap();
|
|
assert_eq!(t, MessageType::Typing);
|
|
match &msg {
|
|
AppMessage::Typing { active } => assert_eq!(*active, 1),
|
|
_ => panic!("expected Typing"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn roundtrip_reaction() {
|
|
let ref_id = [2u8; 16];
|
|
let emoji = "\u{1f44d}".as_bytes();
|
|
let encoded = serialize_reaction(ref_id, emoji).unwrap();
|
|
let (t, msg) = parse(&encoded).unwrap();
|
|
assert_eq!(t, MessageType::Reaction);
|
|
match &msg {
|
|
AppMessage::Reaction { ref_msg_id, emoji: e } => {
|
|
assert_eq!(ref_msg_id, &ref_id);
|
|
assert_eq!(e.as_slice(), emoji);
|
|
}
|
|
_ => panic!("expected Reaction"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn roundtrip_read_receipt() {
|
|
let msg_id = [3u8; 16];
|
|
let encoded = serialize_read_receipt(msg_id);
|
|
let (t, msg) = parse(&encoded).unwrap();
|
|
assert_eq!(t, MessageType::ReadReceipt);
|
|
match &msg {
|
|
AppMessage::ReadReceipt { msg_id: id } => assert_eq!(id, &msg_id),
|
|
_ => panic!("expected ReadReceipt"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn roundtrip_edit() {
|
|
let ref_id = [4u8; 16];
|
|
let body = b"edited text";
|
|
let encoded = serialize_edit(&ref_id, body).unwrap();
|
|
let (t, msg) = parse(&encoded).unwrap();
|
|
assert_eq!(t, MessageType::Edit);
|
|
match &msg {
|
|
AppMessage::Edit { ref_msg_id, body: b } => {
|
|
assert_eq!(ref_msg_id, &ref_id);
|
|
assert_eq!(b.as_slice(), body);
|
|
}
|
|
_ => panic!("expected Edit"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn roundtrip_delete() {
|
|
let ref_id = [5u8; 16];
|
|
let encoded = serialize_delete(&ref_id);
|
|
let (t, msg) = parse(&encoded).unwrap();
|
|
assert_eq!(t, MessageType::Delete);
|
|
match &msg {
|
|
AppMessage::Delete { ref_msg_id } => assert_eq!(ref_msg_id, &ref_id),
|
|
_ => panic!("expected Delete"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn edit_body_too_long() {
|
|
let body = vec![0u8; 65536];
|
|
assert!(serialize_edit(&[0; 16], &body).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn parse_empty_fails() {
|
|
assert!(parse(&[]).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn parse_bad_version_fails() {
|
|
assert!(parse(&[99, 0x01]).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn parse_bad_type_fails() {
|
|
assert!(parse(&[1, 0xFF]).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn chat_body_too_long() {
|
|
let body = vec![0u8; 65536]; // exceeds u16::MAX
|
|
assert!(serialize_chat(&body, None).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn reaction_emoji_too_long() {
|
|
let emoji = vec![0u8; 256];
|
|
assert!(serialize_reaction([0; 16], &emoji).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn parse_truncated_chat_payload() {
|
|
// Version + type + only 10 bytes of payload (needs 18 minimum for chat)
|
|
let mut data = vec![1, 0x01];
|
|
data.extend_from_slice(&[0u8; 10]);
|
|
assert!(parse(&data).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn roundtrip_file_ref() {
|
|
let blob_id = [7u8; 32];
|
|
let filename = b"report.pdf";
|
|
let file_size = 123456u64;
|
|
let mime_type = b"application/pdf";
|
|
let encoded = serialize_file_ref(&blob_id, filename, file_size, mime_type).unwrap();
|
|
let (t, msg) = parse(&encoded).unwrap();
|
|
assert_eq!(t, MessageType::FileRef);
|
|
match &msg {
|
|
AppMessage::FileRef {
|
|
blob_id: bid,
|
|
filename: fname,
|
|
file_size: fsize,
|
|
mime_type: mtype,
|
|
} => {
|
|
assert_eq!(bid, &blob_id);
|
|
assert_eq!(fname.as_slice(), filename);
|
|
assert_eq!(*fsize, file_size);
|
|
assert_eq!(mtype.as_slice(), mime_type);
|
|
}
|
|
_ => panic!("expected FileRef"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn roundtrip_dummy() {
|
|
let encoded = serialize_dummy();
|
|
let (t, msg) = parse(&encoded).unwrap();
|
|
assert_eq!(t, MessageType::Dummy);
|
|
assert_eq!(msg, AppMessage::Dummy);
|
|
}
|
|
}
|