#![forbid(unsafe_code)]
use base64::Engine as _;
use ring::hmac;
use serde::de::{Error as DeError, MapAccess, Visitor};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::value::RawValue;
use std::collections::{BTreeMap, BTreeSet};
use std::fmt;
use std::num::NonZeroU16;
use std::str::FromStr;
use thiserror::Error;
use zeroize::Zeroize;
pub const PROTOCOL_VERSION: u16 = 1;
pub const MAX_FRAME_BYTES: usize = 64 * 1024;
pub mod message_type {
pub const HELLO: &str = "hello";
pub const WELCOME: &str = "welcome";
pub const REGISTER_SERVICES: &str = "register_services";
pub const REGISTER_SERVICES_RESULT: &str = "register_services_result";
pub const EXPOSE_PORT: &str = "expose_port";
pub const EXPOSE_PORT_RESULT: &str = "expose_port_result";
pub const PREPARE_SERVICE: &str = "prepare_service";
pub const PREPARE_SERVICE_RESULT: &str = "prepare_service_result";
pub const UNREGISTER_SERVICES: &str = "unregister_services";
pub const UNREGISTER_SERVICES_RESULT: &str = "unregister_services_result";
pub const CONNECT_STREAM: &str = "connect_stream";
pub const CONNECT_STREAM_RESULT: &str = "connect_stream_result";
pub const OPEN_STREAM: &str = "open_stream";
pub const OPEN_STREAM_RESULT: &str = "open_stream_result";
pub const DATA_HELLO: &str = "data_hello";
pub const DATA_READY: &str = "data_ready";
pub const SERVICE_STATUS: &str = "service_status";
pub const PING: &str = "ping";
pub const PONG: &str = "pong";
pub const STREAM_CLOSED: &str = "stream_closed";
pub const ERROR: &str = "error";
}
pub mod service_protocol {
pub const TCP: &str = "tcp";
}
pub mod service_status {
pub const READY: &str = "ready";
pub const UNREACHABLE: &str = "unreachable";
pub const DEGRADED: &str = "degraded";
pub const REMOVED: &str = "removed";
}
pub mod open_stream_status {
pub const CONNECTING: &str = "connecting";
pub const REJECTED: &str = "rejected";
}
pub mod expose_port_status {
pub const ACCEPTED: &str = "accepted";
pub const REJECTED: &str = "rejected";
}
pub mod connect_stream_status {
pub const CONNECTED: &str = "connected";
pub const REJECTED: &str = "rejected";
}
pub mod prepare_service_status {
pub const READY: &str = "ready";
pub const FAILED: &str = "failed";
pub const REJECTED: &str = "rejected";
}
pub mod error_code {
pub const BAD_FRAME: &str = "bad_frame";
pub const UNSUPPORTED_VERSION: &str = "unsupported_version";
pub const UNKNOWN_MESSAGE_TYPE: &str = "unknown_message_type";
pub const AUTH_FAILED: &str = "auth_failed";
pub const SHARE_NOT_AUTHORIZED: &str = "share_not_authorized";
pub const SERVICE_NOT_ALLOWED: &str = "service_not_allowed";
pub const TARGET_NOT_ALLOWED: &str = "target_not_allowed";
pub const UNKNOWN_SERVICE: &str = "unknown_service";
pub const UNKNOWN_STREAM: &str = "unknown_stream";
pub const STREAM_TIMEOUT: &str = "stream_timeout";
pub const SIGNATURE_INVALID: &str = "signature_invalid";
pub const NONCE_REUSED: &str = "nonce_reused";
pub const CAPACITY_EXCEEDED: &str = "capacity_exceeded";
pub const LOCAL_CONNECT_FAILED: &str = "local_connect_failed";
pub const BUFFER_LIMIT_EXCEEDED: &str = "buffer_limit_exceeded";
pub const PREPARE_FAILED: &str = "prepare_failed";
}
#[derive(Debug, Error)]
pub enum ProtocolError {
#[error("JSON parse error: {0}")]
Json(#[from] serde_json::Error),
#[error("unsupported protocol version: {version}")]
UnsupportedVersion { version: u16 },
#[error("unknown message type: {0}")]
UnknownMessageType(Token),
#[error("invalid token in {field}: {reason}")]
InvalidToken {
field: &'static str,
reason: &'static str,
},
#[error("invalid field {field}: {message}")]
InvalidField {
field: &'static str,
message: String,
},
#[error("frame needs more bytes")]
NeedMore,
#[error("frame too large: {len} > {max}")]
FrameTooLarge { len: usize, max: usize },
}
impl ProtocolError {
pub fn code(&self) -> &'static str {
match self {
Self::UnsupportedVersion { .. } => error_code::UNSUPPORTED_VERSION,
Self::UnknownMessageType(_) => error_code::UNKNOWN_MESSAGE_TYPE,
_ => error_code::BAD_FRAME,
}
}
}
pub type Result<T> = std::result::Result<T, ProtocolError>;
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Token(String);
impl Token {
pub const MAX_LEN: usize = 256;
pub fn new(value: impl Into<String>) -> Result<Self> {
let value = value.into();
validate_token("token", &value)?;
Ok(Self(value))
}
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Debug for Token {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Token").field(&self.0).finish()
}
}
impl fmt::Display for Token {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.0)
}
}
impl FromStr for Token {
type Err = ProtocolError;
fn from_str(value: &str) -> Result<Self> {
Self::new(value)
}
}
impl TryFrom<String> for Token {
type Error = ProtocolError;
fn try_from(value: String) -> Result<Self> {
Self::new(value)
}
}
impl Serialize for Token {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(&self.0)
}
}
impl<'de> Deserialize<'de> for Token {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value = String::deserialize(deserializer)?;
Token::new(value).map_err(D::Error::custom)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Signature(String);
impl Signature {
pub const HEX_SHA256_LEN: usize = 64;
pub const BASE64URL_SHA256_LEN: usize = 43;
pub fn new(value: impl Into<String>) -> Result<Self> {
let value = value.into();
validate_signature(&value)?;
Ok(Self(value))
}
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Display for Signature {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.0)
}
}
impl FromStr for Signature {
type Err = ProtocolError;
fn from_str(value: &str) -> Result<Self> {
Self::new(value)
}
}
impl TryFrom<String> for Signature {
type Error = ProtocolError;
fn try_from(value: String) -> Result<Self> {
Self::new(value)
}
}
impl Serialize for Signature {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(&self.0)
}
}
impl<'de> Deserialize<'de> for Signature {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value = String::deserialize(deserializer)?;
Signature::new(value).map_err(D::Error::custom)
}
}
#[derive(Clone, PartialEq, Eq, Zeroize)]
#[zeroize(drop)]
pub struct Secret(String);
impl Secret {
pub const MAX_LEN: usize = 4096;
pub fn new(value: impl Into<String>) -> Result<Self> {
let value = value.into();
validate_bounded_string("secret", &value, Self::MAX_LEN, false)?;
Ok(Self(value))
}
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Debug for Secret {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("Secret([redacted])")
}
}
impl Serialize for Secret {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(&self.0)
}
}
impl<'de> Deserialize<'de> for Secret {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value = String::deserialize(deserializer)?;
Secret::new(value).map_err(D::Error::custom)
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
pub struct Text(String);
impl Text {
pub const MAX_LEN: usize = 4096;
pub fn new(value: impl Into<String>) -> Result<Self> {
let value = value.into();
validate_bounded_string("text", &value, Self::MAX_LEN, false)?;
Ok(Self(value))
}
pub fn as_str(&self) -> &str {
&self.0
}
}
impl FromStr for Text {
type Err = ProtocolError;
fn from_str(value: &str) -> Result<Self> {
Self::new(value)
}
}
impl<'de> Deserialize<'de> for Text {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value = String::deserialize(deserializer)?;
Text::new(value).map_err(D::Error::custom)
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)]
pub struct StringMap(BTreeMap<Token, Text>);
impl StringMap {
pub fn new() -> Self {
Self::default()
}
pub fn insert(&mut self, key: Token, value: Text) -> Option<Text> {
self.0.insert(key, value)
}
pub fn get(&self, key: &Token) -> Option<&Text> {
self.0.get(key)
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
pub fn iter(&self) -> impl Iterator<Item = (&Token, &Text)> {
self.0.iter()
}
}
impl<'de> Deserialize<'de> for StringMap {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct MapVisitor;
impl<'de> Visitor<'de> for MapVisitor {
type Value = StringMap;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("a map of protocol-token keys to text values")
}
fn visit_map<A>(self, mut access: A) -> std::result::Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut map = BTreeMap::new();
while let Some((key, value)) = access.next_entry::<Token, Text>()? {
if map.insert(key.clone(), value).is_some() {
return Err(A::Error::custom(format!("duplicate map key: {key}")));
}
}
Ok(StringMap(map))
}
}
deserializer.deserialize_map(MapVisitor)
}
}
pub type Extensions = StringMap;
pub type Metadata = StringMap;
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Agent {
pub name: Token,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub version: Option<Token>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub platform: Option<Token>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Auth {
pub method: Token,
pub api_key: Secret,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Account {
pub account_id: Token,
pub plan: Token,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Target {
pub host: Text,
pub port: NonZeroU16,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Service {
pub service_id: Token,
pub name: Text,
pub protocol: Token,
pub target: Target,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub metadata: Metadata,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ErrorDetail {
pub code: Token,
pub message: Text,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AcceptedService {
pub service_id: Token,
pub route_id: Token,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RejectedService {
pub service_id: Token,
pub error: ErrorDetail,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Hello {
pub client_id: Token,
pub agent: Agent,
pub auth: Auth,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resume_session_id: Option<Token>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub features: Vec<Token>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub requested_entitlements: Vec<Token>,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Welcome {
pub session_id: Token,
pub session_secret: Secret,
pub account: Account,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub entitlements: Vec<Token>,
pub heartbeat_interval_ms: u32,
pub data_connect_timeout_ms: u32,
pub max_concurrent_streams: u32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub server_time: Option<Text>,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RegisterServices {
pub share_id: Token,
pub services: Vec<Service>,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RegisterServicesResult {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub accepted: Vec<AcceptedService>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub rejected: Vec<RejectedService>,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ExposePort {
pub share_id: Token,
pub service_id: Token,
pub name: Text,
pub protocol: Token,
pub target: Target,
pub reason: Token,
pub requested_by: Token,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub metadata: Metadata,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ExposePortResult {
pub status: Token,
pub service_id: Token,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<ErrorDetail>,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PrepareService {
pub service_id: Token,
pub reason: Token,
pub requested_by: Token,
pub timeout_ms: u32,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub metadata: Metadata,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PrepareServiceResult {
pub service_id: Token,
pub status: Token,
pub elapsed_ms: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<ErrorDetail>,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UnregisterServices {
pub share_id: Token,
pub service_ids: Vec<Token>,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct UnregisterServicesResult {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub removed: Vec<Token>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub not_found: Vec<Token>,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ConnectStream {
pub client_id: Token,
pub auth: Auth,
pub share_id: Token,
pub service_id: Token,
pub reason: Token,
pub connect_timeout_ms: u32,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub metadata: Metadata,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ConnectStreamResult {
pub stream_id: Token,
pub status: Token,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<ErrorDetail>,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct OpenStream {
pub share_id: Token,
pub stream_id: Token,
pub service_id: Token,
pub reason: Token,
pub connect_timeout_ms: u32,
pub nonce: Token,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct OpenStreamResult {
pub stream_id: Token,
pub status: Token,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<ErrorDetail>,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DataHello {
pub client_id: Token,
pub session_id: Token,
pub share_id: Token,
pub stream_id: Token,
pub service_id: Token,
pub nonce: Token,
pub signature: Signature,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DataReady {
pub stream_id: Token,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ServiceStatus {
pub share_id: Token,
pub service_id: Token,
pub status: Token,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<ErrorDetail>,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Ping {
pub time: Text,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Pong {
pub time: Text,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StreamClosed {
pub share_id: Token,
pub service_id: Token,
pub stream_id: Token,
pub reason: Token,
pub bytes_in: u64,
pub bytes_out: u64,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ErrorBody {
pub code: Token,
pub message: Text,
#[serde(default, skip_serializing_if = "StringMap::is_empty")]
pub extensions: Extensions,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Message {
Hello(Hello),
Welcome(Welcome),
RegisterServices(RegisterServices),
RegisterServicesResult(RegisterServicesResult),
ExposePort(ExposePort),
ExposePortResult(ExposePortResult),
PrepareService(PrepareService),
PrepareServiceResult(PrepareServiceResult),
UnregisterServices(UnregisterServices),
UnregisterServicesResult(UnregisterServicesResult),
ConnectStream(ConnectStream),
ConnectStreamResult(ConnectStreamResult),
OpenStream(OpenStream),
OpenStreamResult(OpenStreamResult),
DataHello(DataHello),
DataReady(DataReady),
ServiceStatus(ServiceStatus),
Ping(Ping),
Pong(Pong),
StreamClosed(StreamClosed),
Error(ErrorBody),
}
impl Message {
pub fn kind(&self) -> &'static str {
match self {
Self::Hello(_) => message_type::HELLO,
Self::Welcome(_) => message_type::WELCOME,
Self::RegisterServices(_) => message_type::REGISTER_SERVICES,
Self::RegisterServicesResult(_) => message_type::REGISTER_SERVICES_RESULT,
Self::ExposePort(_) => message_type::EXPOSE_PORT,
Self::ExposePortResult(_) => message_type::EXPOSE_PORT_RESULT,
Self::PrepareService(_) => message_type::PREPARE_SERVICE,
Self::PrepareServiceResult(_) => message_type::PREPARE_SERVICE_RESULT,
Self::UnregisterServices(_) => message_type::UNREGISTER_SERVICES,
Self::UnregisterServicesResult(_) => message_type::UNREGISTER_SERVICES_RESULT,
Self::ConnectStream(_) => message_type::CONNECT_STREAM,
Self::ConnectStreamResult(_) => message_type::CONNECT_STREAM_RESULT,
Self::OpenStream(_) => message_type::OPEN_STREAM,
Self::OpenStreamResult(_) => message_type::OPEN_STREAM_RESULT,
Self::DataHello(_) => message_type::DATA_HELLO,
Self::DataReady(_) => message_type::DATA_READY,
Self::ServiceStatus(_) => message_type::SERVICE_STATUS,
Self::Ping(_) => message_type::PING,
Self::Pong(_) => message_type::PONG,
Self::StreamClosed(_) => message_type::STREAM_CLOSED,
Self::Error(_) => message_type::ERROR,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ProtocolMessage {
pub request_id: Option<Token>,
pub message: Message,
pub extensions: Extensions,
}
impl ProtocolMessage {
pub fn new(message: Message) -> Self {
Self {
request_id: None,
message,
extensions: Extensions::new(),
}
}
pub fn with_request_id(mut self, request_id: Token) -> Self {
self.request_id = Some(request_id);
self
}
pub fn kind(&self) -> &'static str {
self.message.kind()
}
}
#[derive(Serialize)]
struct WireEnvelopeOut {
#[serde(rename = "type")]
kind: &'static str,
version: u16,
#[serde(skip_serializing_if = "Option::is_none")]
request_id: Option<Token>,
body: serde_json::Value,
#[serde(skip_serializing_if = "StringMap::is_empty")]
extensions: Extensions,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct WireEnvelopeIn {
#[serde(rename = "type")]
kind: Token,
version: u16,
#[serde(default)]
request_id: Option<Token>,
body: Box<RawValue>,
#[serde(default)]
extensions: Extensions,
}
pub fn to_json(message: &ProtocolMessage) -> Result<String> {
validate_message(message)?;
let body = body_to_value(&message.message)?;
let envelope = WireEnvelopeOut {
kind: message.kind(),
version: PROTOCOL_VERSION,
request_id: message.request_id.clone(),
body,
extensions: message.extensions.clone(),
};
Ok(serde_json::to_string(&envelope)?)
}
pub fn from_json(json: &str) -> Result<ProtocolMessage> {
let envelope: WireEnvelopeIn = serde_json::from_str(json)?;
if envelope.version != PROTOCOL_VERSION {
return Err(ProtocolError::UnsupportedVersion {
version: envelope.version,
});
}
let message = match envelope.kind.as_str() {
message_type::HELLO => Message::Hello(parse_body(&envelope.body)?),
message_type::WELCOME => Message::Welcome(parse_body(&envelope.body)?),
message_type::REGISTER_SERVICES => Message::RegisterServices(parse_body(&envelope.body)?),
message_type::REGISTER_SERVICES_RESULT => {
Message::RegisterServicesResult(parse_body(&envelope.body)?)
}
message_type::EXPOSE_PORT => Message::ExposePort(parse_body(&envelope.body)?),
message_type::EXPOSE_PORT_RESULT => Message::ExposePortResult(parse_body(&envelope.body)?),
message_type::PREPARE_SERVICE => Message::PrepareService(parse_body(&envelope.body)?),
message_type::PREPARE_SERVICE_RESULT => {
Message::PrepareServiceResult(parse_body(&envelope.body)?)
}
message_type::UNREGISTER_SERVICES => {
Message::UnregisterServices(parse_body(&envelope.body)?)
}
message_type::UNREGISTER_SERVICES_RESULT => {
Message::UnregisterServicesResult(parse_body(&envelope.body)?)
}
message_type::CONNECT_STREAM => Message::ConnectStream(parse_body(&envelope.body)?),
message_type::CONNECT_STREAM_RESULT => {
Message::ConnectStreamResult(parse_body(&envelope.body)?)
}
message_type::OPEN_STREAM => Message::OpenStream(parse_body(&envelope.body)?),
message_type::OPEN_STREAM_RESULT => Message::OpenStreamResult(parse_body(&envelope.body)?),
message_type::DATA_HELLO => Message::DataHello(parse_body(&envelope.body)?),
message_type::DATA_READY => Message::DataReady(parse_body(&envelope.body)?),
message_type::SERVICE_STATUS => Message::ServiceStatus(parse_body(&envelope.body)?),
message_type::PING => Message::Ping(parse_body(&envelope.body)?),
message_type::PONG => Message::Pong(parse_body(&envelope.body)?),
message_type::STREAM_CLOSED => Message::StreamClosed(parse_body(&envelope.body)?),
message_type::ERROR => Message::Error(parse_body(&envelope.body)?),
_ => return Err(ProtocolError::UnknownMessageType(envelope.kind)),
};
let message = ProtocolMessage {
request_id: envelope.request_id,
message,
extensions: envelope.extensions,
};
validate_message(&message)?;
Ok(message)
}
fn parse_body<T>(raw: &RawValue) -> Result<T>
where
T: for<'de> Deserialize<'de>,
{
Ok(serde_json::from_str(raw.get())?)
}
fn body_to_value(message: &Message) -> Result<serde_json::Value> {
match message {
Message::Hello(body) => Ok(serde_json::to_value(body)?),
Message::Welcome(body) => Ok(serde_json::to_value(body)?),
Message::RegisterServices(body) => Ok(serde_json::to_value(body)?),
Message::RegisterServicesResult(body) => Ok(serde_json::to_value(body)?),
Message::ExposePort(body) => Ok(serde_json::to_value(body)?),
Message::ExposePortResult(body) => Ok(serde_json::to_value(body)?),
Message::PrepareService(body) => Ok(serde_json::to_value(body)?),
Message::PrepareServiceResult(body) => Ok(serde_json::to_value(body)?),
Message::UnregisterServices(body) => Ok(serde_json::to_value(body)?),
Message::UnregisterServicesResult(body) => Ok(serde_json::to_value(body)?),
Message::ConnectStream(body) => Ok(serde_json::to_value(body)?),
Message::ConnectStreamResult(body) => Ok(serde_json::to_value(body)?),
Message::OpenStream(body) => Ok(serde_json::to_value(body)?),
Message::OpenStreamResult(body) => Ok(serde_json::to_value(body)?),
Message::DataHello(body) => Ok(serde_json::to_value(body)?),
Message::DataReady(body) => Ok(serde_json::to_value(body)?),
Message::ServiceStatus(body) => Ok(serde_json::to_value(body)?),
Message::Ping(body) => Ok(serde_json::to_value(body)?),
Message::Pong(body) => Ok(serde_json::to_value(body)?),
Message::StreamClosed(body) => Ok(serde_json::to_value(body)?),
Message::Error(body) => Ok(serde_json::to_value(body)?),
}
}
pub struct DecodedFrame {
pub payload: Vec<u8>,
pub consumed: usize,
}
pub fn encode_frame(payload: &[u8]) -> Result<Vec<u8>> {
if payload.len() > MAX_FRAME_BYTES {
return Err(ProtocolError::FrameTooLarge {
len: payload.len(),
max: MAX_FRAME_BYTES,
});
}
let len = payload.len() as u32;
let mut out = Vec::with_capacity(4 + payload.len());
out.extend_from_slice(&len.to_be_bytes());
out.extend_from_slice(payload);
Ok(out)
}
pub fn try_decode_frame(buffer: &[u8]) -> Result<Option<DecodedFrame>> {
if buffer.len() < 4 {
return Ok(None);
}
let len = u32::from_be_bytes([buffer[0], buffer[1], buffer[2], buffer[3]]) as usize;
if len > MAX_FRAME_BYTES {
return Err(ProtocolError::FrameTooLarge {
len,
max: MAX_FRAME_BYTES,
});
}
let needed = 4 + len;
if buffer.len() < needed {
return Ok(None);
}
Ok(Some(DecodedFrame {
payload: buffer[4..needed].to_vec(),
consumed: needed,
}))
}
pub fn canonical_data_signature_input(data: &DataHello) -> Vec<u8> {
canonical_data_signature_input_parts(
&data.session_id,
&data.share_id,
&data.stream_id,
&data.service_id,
&data.nonce,
)
}
pub fn canonical_data_signature_input_parts(
session_id: &Token,
share_id: &Token,
stream_id: &Token,
service_id: &Token,
nonce: &Token,
) -> Vec<u8> {
let mut out = b"nexer-data-v1\0".to_vec();
append_len_prefixed(&mut out, session_id.as_str().as_bytes());
append_len_prefixed(&mut out, share_id.as_str().as_bytes());
append_len_prefixed(&mut out, stream_id.as_str().as_bytes());
append_len_prefixed(&mut out, service_id.as_str().as_bytes());
append_len_prefixed(&mut out, nonce.as_str().as_bytes());
out
}
pub fn data_signature_hex(
secret: &Secret,
session_id: &Token,
share_id: &Token,
stream_id: &Token,
service_id: &Token,
nonce: &Token,
) -> Signature {
let key = hmac::Key::new(hmac::HMAC_SHA256, secret.as_str().as_bytes());
let input =
canonical_data_signature_input_parts(session_id, share_id, stream_id, service_id, nonce);
let tag = hmac::sign(&key, &input);
Signature::new(hex_lower(tag.as_ref())).expect("HMAC-SHA256 hex output is a valid signature")
}
pub fn verify_data_signature(secret: &Secret, data: &DataHello) -> bool {
let Some(signature) = decode_signature(data.signature.as_str()) else {
return false;
};
let key = hmac::Key::new(hmac::HMAC_SHA256, secret.as_str().as_bytes());
let input = canonical_data_signature_input(data);
hmac::verify(&key, &input, &signature).is_ok()
}
fn decode_signature(value: &str) -> Option<Vec<u8>> {
if value.len() == Signature::HEX_SHA256_LEN {
return decode_hex(value);
}
if value.len() == Signature::BASE64URL_SHA256_LEN {
return base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(value)
.ok();
}
None
}
fn decode_hex(value: &str) -> Option<Vec<u8>> {
let mut out = Vec::with_capacity(value.len() / 2);
for chunk in value.as_bytes().chunks_exact(2) {
let high = hex_value(chunk[0])?;
let low = hex_value(chunk[1])?;
out.push((high << 4) | low);
}
Some(out)
}
fn hex_value(byte: u8) -> Option<u8> {
match byte {
b'0'..=b'9' => Some(byte - b'0'),
b'a'..=b'f' => Some(byte - b'a' + 10),
_ => None,
}
}
fn hex_lower(bytes: &[u8]) -> String {
const HEX: &[u8; 16] = b"0123456789abcdef";
let mut out = String::with_capacity(bytes.len() * 2);
for byte in bytes {
out.push(HEX[(byte >> 4) as usize] as char);
out.push(HEX[(byte & 0x0f) as usize] as char);
}
out
}
fn append_len_prefixed(out: &mut Vec<u8>, value: &[u8]) {
let len = value.len() as u32;
out.extend_from_slice(&len.to_be_bytes());
out.extend_from_slice(value);
}
pub fn is_default_allowed_target(target: &Target) -> bool {
is_loopback_host(target.host.as_str())
}
pub fn is_loopback_host(host: &str) -> bool {
host.eq_ignore_ascii_case("localhost")
|| host == "::1"
|| host == "[::1]"
|| is_ipv4_loopback_literal(host)
}
fn is_ipv4_loopback_literal(host: &str) -> bool {
let mut octets = [0_u8; 4];
let mut count = 0_usize;
for part in host.split('.') {
if count == 4 || part.is_empty() || part.len() > 3 {
return false;
}
if !part.bytes().all(|b| b.is_ascii_digit()) {
return false;
}
let Ok(value) = part.parse::<u8>() else {
return false;
};
octets[count] = value;
count += 1;
}
count == 4 && octets[0] == 127
}
fn validate_message(message: &ProtocolMessage) -> Result<()> {
if message.extensions.0.len() > 64 {
return Err(ProtocolError::InvalidField {
field: "extensions",
message: "too many extension entries".to_string(),
});
}
match &message.message {
Message::Hello(body) => {
validate_unique_tokens("features", &body.features)?;
validate_unique_tokens("requested_entitlements", &body.requested_entitlements)?;
}
Message::RegisterServices(body) => {
validate_non_empty_vec("services", &body.services)?;
if body.services.len() > 128 {
return Err(ProtocolError::InvalidField {
field: "services",
message: "too many services".to_string(),
});
}
let mut seen = BTreeSet::new();
for service in &body.services {
if !seen.insert(&service.service_id) {
return Err(ProtocolError::InvalidField {
field: "services",
message: format!("duplicate service_id: {}", service.service_id),
});
}
}
}
Message::RegisterServicesResult(body) => {
validate_unique_service_results(&body.accepted, &body.rejected)?;
}
Message::ExposePortResult(body) => {
if body.status.as_str() == expose_port_status::REJECTED && body.error.is_none() {
return Err(ProtocolError::InvalidField {
field: "error",
message: "rejected expose_port_result requires error".to_string(),
});
}
}
Message::PrepareService(body) => {
if body.timeout_ms == 0 {
return Err(ProtocolError::InvalidField {
field: "timeout_ms",
message: "must be non-zero".to_string(),
});
}
}
Message::PrepareServiceResult(body) => {
if body.status.as_str() != prepare_service_status::READY && body.error.is_none() {
return Err(ProtocolError::InvalidField {
field: "error",
message: "non-ready prepare_service_result requires error".to_string(),
});
}
}
Message::ConnectStream(body) => {
if body.connect_timeout_ms == 0 {
return Err(ProtocolError::InvalidField {
field: "connect_timeout_ms",
message: "must be non-zero".to_string(),
});
}
}
Message::ConnectStreamResult(body) => {
if body.status.as_str() == connect_stream_status::REJECTED && body.error.is_none() {
return Err(ProtocolError::InvalidField {
field: "error",
message: "rejected connect_stream_result requires error".to_string(),
});
}
}
Message::UnregisterServices(body) => {
validate_non_empty_vec("service_ids", &body.service_ids)?;
validate_unique_tokens("service_ids", &body.service_ids)?;
}
Message::OpenStreamResult(body) => {
if body.status.as_str() == open_stream_status::REJECTED && body.error.is_none() {
return Err(ProtocolError::InvalidField {
field: "error",
message: "rejected open_stream_result requires error".to_string(),
});
}
}
Message::Welcome(body) => {
if body.heartbeat_interval_ms == 0
|| body.data_connect_timeout_ms == 0
|| body.max_concurrent_streams == 0
{
return Err(ProtocolError::InvalidField {
field: "welcome",
message: "timeout and capacity fields must be non-zero".to_string(),
});
}
validate_unique_tokens("entitlements", &body.entitlements)?;
}
_ => {}
}
Ok(())
}
fn validate_unique_tokens(field: &'static str, tokens: &[Token]) -> Result<()> {
let mut seen = BTreeSet::new();
for token in tokens {
if !seen.insert(token) {
return Err(ProtocolError::InvalidField {
field,
message: format!("duplicate token: {token}"),
});
}
}
Ok(())
}
fn validate_non_empty_vec<T>(field: &'static str, values: &[T]) -> Result<()> {
if values.is_empty() {
return Err(ProtocolError::InvalidField {
field,
message: "must not be empty".to_string(),
});
}
Ok(())
}
fn validate_unique_service_results(
accepted: &[AcceptedService],
rejected: &[RejectedService],
) -> Result<()> {
let mut seen = BTreeSet::new();
for service in accepted {
if !seen.insert(&service.service_id) {
return Err(ProtocolError::InvalidField {
field: "accepted",
message: format!("duplicate service_id: {}", service.service_id),
});
}
}
for service in rejected {
if !seen.insert(&service.service_id) {
return Err(ProtocolError::InvalidField {
field: "rejected",
message: format!("duplicate service_id: {}", service.service_id),
});
}
}
Ok(())
}
fn validate_token(field: &'static str, value: &str) -> Result<()> {
if value.is_empty() {
return Err(ProtocolError::InvalidToken {
field,
reason: "must not be empty",
});
}
if value.len() > Token::MAX_LEN {
return Err(ProtocolError::InvalidToken {
field,
reason: "too long",
});
}
if !value.bytes().all(is_token_byte) {
return Err(ProtocolError::InvalidToken {
field,
reason: "contains a byte outside [A-Za-z0-9._:-]",
});
}
Ok(())
}
fn validate_signature(value: &str) -> Result<()> {
if value.len() == Signature::HEX_SHA256_LEN
&& value
.bytes()
.all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
{
return Ok(());
}
if value.len() == Signature::BASE64URL_SHA256_LEN
&& value
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_'))
{
return Ok(());
}
Err(ProtocolError::InvalidField {
field: "signature",
message: "must be lowercase hex sha256 or unpadded base64url sha256".to_string(),
})
}
fn is_token_byte(byte: u8) -> bool {
byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b':' | b'-')
}
fn validate_bounded_string(
field: &'static str,
value: &str,
max_len: usize,
allow_empty: bool,
) -> Result<()> {
if !allow_empty && value.is_empty() {
return Err(ProtocolError::InvalidField {
field,
message: "must not be empty".to_string(),
});
}
if value.len() > max_len {
return Err(ProtocolError::InvalidField {
field,
message: "too long".to_string(),
});
}
if value.chars().any(char::is_control) {
return Err(ProtocolError::InvalidField {
field,
message: "must not contain control characters".to_string(),
});
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn token(value: &str) -> Token {
Token::new(value).unwrap()
}
fn text(value: &str) -> Text {
Text::new(value).unwrap()
}
fn secret(value: &str) -> Secret {
Secret::new(value).unwrap()
}
fn signature(value: &str) -> Signature {
Signature::new(value).unwrap()
}
fn hello_message() -> ProtocolMessage {
ProtocolMessage::new(Message::Hello(Hello {
client_id: token("client-1"),
agent: Agent {
name: token("nexer"),
version: Some(token("0.1.0")),
platform: Some(token("darwin-arm64")),
},
auth: Auth {
method: token("api_key"),
api_key: secret("nexer_live_test"),
},
resume_session_id: None,
features: vec![token("data-conn-v1"), token("dynamic-services-v1")],
requested_entitlements: vec![token("tcp-forward-v1")],
extensions: Extensions::new(),
}))
}
#[test]
fn envelope_round_trip() {
let message = hello_message();
let json = to_json(&message).unwrap();
assert!(json.contains("\"type\":\"hello\""));
assert!(json.contains("\"version\":1"));
assert!(json.contains("\"body\""));
let parsed = from_json(&json).unwrap();
assert_eq!(parsed, message);
}
#[test]
fn request_id_lives_in_envelope() {
let message = ProtocolMessage::new(Message::Ping(Ping {
time: text("2026-07-13T00:00:00Z"),
extensions: Extensions::new(),
}))
.with_request_id(token("req-1"));
let json = to_json(&message).unwrap();
assert!(json.contains("\"request_id\":\"req-1\""));
let parsed = from_json(&json).unwrap();
assert_eq!(parsed.request_id.unwrap().as_str(), "req-1");
}
#[test]
fn expose_port_round_trip() {
let message = ProtocolMessage::new(Message::ExposePort(ExposePort {
share_id: token("share-1"),
service_id: token("tcp-local"),
name: text("local-tcp"),
protocol: token(service_protocol::TCP),
target: Target {
host: text("127.0.0.1"),
port: NonZeroU16::new(7000).unwrap(),
},
reason: token("user-request"),
requested_by: token("user-2"),
metadata: Metadata::new(),
extensions: Extensions::new(),
}))
.with_request_id(token("req-expose-1"));
let json = to_json(&message).unwrap();
assert!(json.contains("\"type\":\"expose_port\""));
let parsed = from_json(&json).unwrap();
assert_eq!(parsed, message);
}
#[test]
fn connect_stream_round_trip() {
let message = ProtocolMessage::new(Message::ConnectStream(ConnectStream {
client_id: token("app-proxy-1"),
auth: Auth {
method: token("api_key"),
api_key: secret("nexer_live_test"),
},
share_id: token("share-1"),
service_id: token("tcp-local"),
reason: token("app-connect"),
connect_timeout_ms: 10_000,
metadata: Metadata::new(),
extensions: Extensions::new(),
}))
.with_request_id(token("req-connect-1"));
let json = to_json(&message).unwrap();
assert!(json.contains("\"type\":\"connect_stream\""));
let parsed = from_json(&json).unwrap();
assert_eq!(parsed, message);
}
#[test]
fn prepare_service_round_trip() {
let message = ProtocolMessage::new(Message::PrepareService(PrepareService {
service_id: token("service-123"),
reason: token("debug-session"),
requested_by: token("user-2"),
timeout_ms: 180_000,
metadata: Metadata::new(),
extensions: Extensions::new(),
}))
.with_request_id(token("req-prepare-1"));
let json = to_json(&message).unwrap();
assert!(json.contains("\"type\":\"prepare_service\""));
let parsed = from_json(&json).unwrap();
assert_eq!(parsed, message);
}
#[test]
fn rejects_unknown_top_level_fields() {
let err = from_json(r#"{"type":"ping","version":1,"body":{"time":"now"},"extra":true}"#)
.unwrap_err();
assert_eq!(err.code(), error_code::BAD_FRAME);
}
#[test]
fn rejects_duplicate_known_fields() {
let err =
from_json(r#"{"type":"ping","version":1,"body":{"time":"a","time":"b"}}"#).unwrap_err();
assert_eq!(err.code(), error_code::BAD_FRAME);
}
#[test]
fn rejects_duplicate_envelope_fields() {
let err = from_json(r#"{"type":"ping","type":"pong","version":1,"body":{"time":"now"}}"#)
.unwrap_err();
assert_eq!(err.code(), error_code::BAD_FRAME);
}
#[test]
fn rejects_duplicate_map_keys() {
let err = from_json(
r#"{"type":"register_services","version":1,"request_id":"req-1","body":{"share_id":"share-1","services":[{"service_id":"tcp-local","name":"local-tcp","protocol":"tcp","target":{"host":"127.0.0.1","port":7000},"metadata":{"label":"a","label":"b"}}]}}"#,
)
.unwrap_err();
assert_eq!(err.code(), error_code::BAD_FRAME);
}
#[test]
fn rejects_bad_tokens_at_decode_boundary() {
let err = from_json(
r#"{"type":"ping","version":1,"request_id":"bad token","body":{"time":"now"}}"#,
)
.unwrap_err();
assert_eq!(err.code(), error_code::BAD_FRAME);
}
#[test]
fn unsupported_version_has_machine_code() {
let err = from_json(r#"{"type":"ping","version":2,"body":{"time":"now"}}"#).unwrap_err();
assert_eq!(err.code(), error_code::UNSUPPORTED_VERSION);
}
#[test]
fn unknown_message_type_is_distinct() {
let err = from_json(r#"{"type":"future_message","version":1,"body":{}}"#).unwrap_err();
assert_eq!(err.code(), error_code::UNKNOWN_MESSAGE_TYPE);
}
#[test]
fn open_stream_rejection_requires_error() {
let message = ProtocolMessage::new(Message::OpenStreamResult(OpenStreamResult {
stream_id: token("stream-1"),
status: token(open_stream_status::REJECTED),
error: None,
extensions: Extensions::new(),
}))
.with_request_id(token("req-1"));
let err = to_json(&message).unwrap_err();
assert_eq!(err.code(), error_code::BAD_FRAME);
}
#[test]
fn expose_port_rejection_requires_error() {
let message = ProtocolMessage::new(Message::ExposePortResult(ExposePortResult {
status: token(expose_port_status::REJECTED),
service_id: token("tcp-local"),
error: None,
extensions: Extensions::new(),
}))
.with_request_id(token("req-expose-1"));
let err = to_json(&message).unwrap_err();
assert_eq!(err.code(), error_code::BAD_FRAME);
}
#[test]
fn connect_stream_rejection_requires_error() {
let message = ProtocolMessage::new(Message::ConnectStreamResult(ConnectStreamResult {
stream_id: token("stream-1"),
status: token(connect_stream_status::REJECTED),
error: None,
extensions: Extensions::new(),
}))
.with_request_id(token("req-connect-1"));
let err = to_json(&message).unwrap_err();
assert_eq!(err.code(), error_code::BAD_FRAME);
}
#[test]
fn prepare_service_failure_requires_error() {
let message = ProtocolMessage::new(Message::PrepareServiceResult(PrepareServiceResult {
service_id: token("service-123"),
status: token(prepare_service_status::FAILED),
elapsed_ms: 100,
error: None,
extensions: Extensions::new(),
}))
.with_request_id(token("req-prepare-1"));
let err = to_json(&message).unwrap_err();
assert_eq!(err.code(), error_code::BAD_FRAME);
}
#[test]
fn data_hello_accepts_strict_signature_encodings() {
let hex = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
assert_eq!(signature(hex).as_str(), hex);
let base64url = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopq";
assert_eq!(signature(base64url).as_str(), base64url);
}
#[test]
fn data_hello_rejects_padded_or_standard_base64_signatures() {
assert!(Signature::new("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop=").is_err());
assert!(Signature::new("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop+").is_err());
assert!(Signature::new("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop/").is_err());
let err = from_json(
r#"{"type":"data_hello","version":1,"body":{"client_id":"client-1","session_id":"session-1","share_id":"share-1","stream_id":"stream-1","service_id":"tcp-local","nonce":"nonce-1","signature":"bad+signature"}}"#,
)
.unwrap_err();
assert_eq!(err.code(), error_code::BAD_FRAME);
}
#[test]
fn register_services_rejects_duplicate_service_ids() {
let service = |id: &str| Service {
service_id: token(id),
name: text("local-tcp"),
protocol: token(service_protocol::TCP),
target: Target {
host: text("127.0.0.1"),
port: NonZeroU16::new(7000).unwrap(),
},
metadata: Metadata::new(),
extensions: Extensions::new(),
};
let message = ProtocolMessage::new(Message::RegisterServices(RegisterServices {
share_id: token("share-1"),
services: vec![service("tcp-local"), service("tcp-local")],
extensions: Extensions::new(),
}))
.with_request_id(token("req-register-1"));
let err = to_json(&message).unwrap_err();
assert_eq!(err.code(), error_code::BAD_FRAME);
}
#[test]
fn register_services_rejects_duplicate_service_ids_from_json() {
let err = from_json(
r#"{"type":"register_services","version":1,"request_id":"req-register-1","body":{"share_id":"share-1","services":[{"service_id":"tcp-local","name":"local-tcp","protocol":"tcp","target":{"host":"127.0.0.1","port":7000}},{"service_id":"tcp-local","name":"local-tcp","protocol":"tcp","target":{"host":"127.0.0.1","port":7001}}]}}"#,
)
.unwrap_err();
assert_eq!(err.code(), error_code::BAD_FRAME);
}
#[test]
fn frame_round_trip_and_limits() {
let payload = br#"{"type":"ping","version":1,"body":{"time":"now"}}"#;
let frame = encode_frame(payload).unwrap();
let partial = try_decode_frame(&frame[..3]).unwrap();
assert!(partial.is_none());
let decoded = try_decode_frame(&frame).unwrap().unwrap();
assert_eq!(decoded.payload, payload);
assert_eq!(decoded.consumed, frame.len());
let too_large = vec![b'x'; MAX_FRAME_BYTES + 1];
let err = encode_frame(&too_large).unwrap_err();
assert_eq!(err.code(), error_code::BAD_FRAME);
}
#[test]
fn loopback_policy_is_numeric_not_prefix_based() {
let target = Target {
host: text("127.0.0.1"),
port: NonZeroU16::new(6379).unwrap(),
};
assert!(is_default_allowed_target(&target));
assert!(is_loopback_host("127.1.2.3"));
assert!(is_loopback_host("localhost"));
assert!(is_loopback_host("::1"));
assert!(!is_loopback_host("127.0.0.1.attacker.com"));
assert!(!is_loopback_host("127.evil.com"));
assert!(!is_loopback_host("127.0.0.256"));
assert!(!is_loopback_host("10.0.0.1"));
}
#[test]
fn canonical_signature_input_is_length_prefixed() {
let a = canonical_data_signature_input_parts(
&token("session"),
&token("share"),
&token("stream"),
&token("a"),
&token("bc"),
);
let b = canonical_data_signature_input_parts(
&token("session"),
&token("share"),
&token("stream"),
&token("ab"),
&token("c"),
);
assert_ne!(a, b);
assert!(a.starts_with(b"nexer-data-v1\0"));
}
#[test]
fn data_signature_helper_round_trips_hex_and_base64url() {
let secret = secret("secret-1");
let mut data = DataHello {
client_id: token("client-1"),
session_id: token("session-1"),
share_id: token("share-1"),
stream_id: token("stream-1"),
service_id: token("tcp-local"),
nonce: token("nonce-1"),
signature: data_signature_hex(
&secret,
&token("session-1"),
&token("share-1"),
&token("stream-1"),
&token("tcp-local"),
&token("nonce-1"),
),
extensions: Extensions::new(),
};
assert!(verify_data_signature(&secret, &data));
let raw = decode_signature(data.signature.as_str()).unwrap();
data.signature = signature(&base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(raw));
assert!(verify_data_signature(&secret, &data));
data.nonce = token("nonce-2");
assert!(!verify_data_signature(&secret, &data));
}
#[test]
fn secret_debug_is_redacted() {
let value = secret("nexer_live_test");
assert_eq!(format!("{value:?}"), "Secret([redacted])");
}
}