refactor: authenticate service websocket transport

This commit is contained in:
Kevin Yue committed 2026-07-16 20:35:46 +08:00
1 parent 3817227942
commit ce97729984
31 files changed
+3304 -441

No files matched your search

-3
View File
@@ -17,6 +17,3 @@ pub mod logger;
#[cfg(feature = "clap")]
pub mod clap;
#[cfg(debug_assertions)]
pub const GP_API_KEY: &[u8; 32] = &[0; 32];
@@ -5,21 +5,21 @@ use common::binary_paths;
use log::info;
use tokio::{io::AsyncWriteExt, process::Command};
use crate::{process::command_traits::CommandExt, utils};
use crate::{process::command_traits::CommandExt, service::transport::SessionCredential};
pub struct GuiHelperLauncher<'a> {
program: PathBuf,
envs: Option<&'a HashMap<String, String>>,
api_key: &'a [u8],
credential: &'a SessionCredential,
gui_version: Option<&'a str>,
}
impl<'a> GuiHelperLauncher<'a> {
pub fn new(api_key: &'a [u8]) -> Self {
pub fn new(credential: &'a SessionCredential) -> Self {
Self {
program: binary_paths::gpgui_helper(),
envs: None,
api_key,
credential,
gui_version: None,
}
}
@@ -42,7 +42,7 @@ impl<'a> GuiHelperLauncher<'a> {
cmd.envs(envs);
}
cmd.arg("--api-key-on-stdin");
cmd.arg("--service-credential-on-stdin");
if let Some(gui_version) = self.gui_version {
cmd.arg("--gui-version").arg(gui_version);
@@ -60,13 +60,11 @@ impl<'a> GuiHelperLauncher<'a> {
bail!("Failed to open stdin");
};
let api_key = utils::base64::encode(self.api_key);
tokio::spawn(async move {
stdin.write_all(api_key.as_bytes()).await.unwrap();
drop(stdin);
});
let frame = self.credential.encode_frame()?;
stdin.write_all(&frame).await?;
let exit_status = child.wait().await?;
drop(stdin);
info!("gpgui-helper exited with: {}", exit_status);
Ok(())
+10 -11
View File
@@ -2,6 +2,7 @@ use std::{
collections::HashMap,
path::PathBuf,
process::{ExitStatus, Stdio},
sync::Arc,
};
use anyhow::bail;
@@ -9,24 +10,24 @@ use common::binary_paths;
use log::info;
use tokio::{io::AsyncWriteExt, process::Command};
use crate::{process::gui_helper_launcher::GuiHelperLauncher, utils::base64};
use crate::{process::gui_helper_launcher::GuiHelperLauncher, service::transport::SessionCredential};
use super::command_traits::CommandExt;
pub struct GuiLauncher<'a> {
version: &'a str,
program: PathBuf,
api_key: &'a [u8],
credential: Arc<SessionCredential>,
minimized: bool,
envs: Option<HashMap<String, String>>,
}
impl<'a> GuiLauncher<'a> {
pub fn new(version: &'a str, api_key: &'a [u8]) -> Self {
pub fn new(version: &'a str, credential: Arc<SessionCredential>) -> Self {
Self {
version,
program: binary_paths::gpgui(),
api_key,
credential,
minimized: false,
envs: None,
}
@@ -61,7 +62,7 @@ impl<'a> GuiLauncher<'a> {
cmd.envs(envs);
}
cmd.arg("--api-key-on-stdin");
cmd.arg("--service-credential-on-stdin");
if self.minimized {
cmd.arg("--minimized");
@@ -79,13 +80,11 @@ impl<'a> GuiLauncher<'a> {
bail!("Failed to open stdin");
};
let api_key = base64::encode(self.api_key);
tokio::spawn(async move {
stdin.write_all(api_key.as_bytes()).await.unwrap();
drop(stdin);
});
let frame = self.credential.encode_frame()?;
stdin.write_all(&frame).await?;
let exit_status = child.wait().await?;
drop(stdin);
Ok(exit_status)
}
@@ -109,7 +108,7 @@ impl<'a> GuiLauncher<'a> {
}
async fn download_program(&self) -> anyhow::Result<()> {
let gui_helper = GuiHelperLauncher::new(self.api_key);
let gui_helper = GuiHelperLauncher::new(&self.credential);
gui_helper
.envs(self.envs.as_ref())
+1
View File
@@ -1,4 +1,5 @@
pub mod event;
pub mod request;
pub mod transport;
pub mod vpn_env;
pub mod vpn_state;
+3 -4
View File
@@ -299,17 +299,16 @@ pub enum WsRequest {
Connect(Box<ConnectRequest>),
Disconnect(DisconnectRequest),
UpdateLogLevel(UpdateLogLevelRequest),
RestartGui,
UpdateGui(UpdateGuiRequest),
}
#[derive(Debug, Deserialize, Serialize)]
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct UpdateGuiRequest {
pub path: String,
pub checksum: String,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct RestartGuiRequest;
#[cfg(test)]
mod tests {
use serde_json::json;
@@ -0,0 +1,164 @@
use std::fmt;
use ::base64::{Engine, engine::general_purpose};
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use zeroize::Zeroizing;
use crate::utils::base64;
use super::{MAX_CREDENTIAL_FRAME, MAX_PRODUCT_VERSION, TransportError};
pub struct SessionCredential {
service_instance_id: Uuid,
session_id: Uuid,
secret: Zeroizing<[u8; 32]>,
product_version: String,
}
impl SessionCredential {
pub fn generate(service_instance_id: Uuid, product_version: &str) -> Result<Self, TransportError> {
if product_version.is_empty() || product_version.len() > MAX_PRODUCT_VERSION {
return Err(TransportError::InvalidCredential);
}
let mut secret = Zeroizing::new([0_u8; 32]);
getrandom::fill(secret.as_mut()).map_err(|_| TransportError::InvalidState)?;
Ok(Self {
service_instance_id,
session_id: Uuid::new_v4(),
secret,
product_version: product_version.to_owned(),
})
}
pub fn service_instance_id(&self) -> Uuid {
self.service_instance_id
}
pub fn session_id(&self) -> Uuid {
self.session_id
}
pub fn secret(&self) -> &[u8; 32] {
&self.secret
}
pub fn product_version(&self) -> &str {
&self.product_version
}
pub fn encode_frame(&self) -> Result<Zeroizing<Vec<u8>>, TransportError> {
let encoded_secret = Zeroizing::new(base64::encode(self.secret()));
let dto = CredentialDtoRef {
service_instance_id: self.service_instance_id,
session_id: self.session_id,
secret: encoded_secret.as_str(),
product_version: &self.product_version,
};
let payload = Zeroizing::new(serde_json::to_vec(&dto)?);
if payload.len() + 2 > MAX_CREDENTIAL_FRAME || payload.len() > u16::MAX as usize {
return Err(TransportError::MessageTooLarge);
}
let mut frame = Zeroizing::new(Vec::with_capacity(payload.len() + 2));
frame.extend_from_slice(&(payload.len() as u16).to_be_bytes());
frame.extend_from_slice(&payload);
Ok(frame)
}
pub fn decode_frame(frame: &[u8]) -> Result<Self, TransportError> {
if frame.len() < 2 || frame.len() > MAX_CREDENTIAL_FRAME {
return Err(TransportError::InvalidCredential);
}
let payload_len = u16::from_be_bytes([frame[0], frame[1]]) as usize;
if payload_len == 0 || payload_len + 2 != frame.len() {
return Err(TransportError::InvalidCredential);
}
let dto: CredentialDto = serde_json::from_slice(&frame[2..]).map_err(|_| TransportError::InvalidCredential)?;
let CredentialDto {
service_instance_id,
session_id,
secret,
product_version,
} = dto;
let encoded_secret = secret;
if product_version.is_empty() || product_version.len() > MAX_PRODUCT_VERSION {
return Err(TransportError::InvalidCredential);
}
let mut secret = Zeroizing::new([0_u8; 32]);
let decoded_len = general_purpose::STANDARD
.decode_slice(encoded_secret.as_bytes(), secret.as_mut())
.map_err(|_| TransportError::InvalidCredential)?;
if decoded_len != secret.len() {
return Err(TransportError::InvalidCredential);
}
Ok(Self {
service_instance_id,
session_id,
secret,
product_version,
})
}
}
impl fmt::Debug for SessionCredential {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SessionCredential")
.field("service_instance_id", &self.service_instance_id)
.field("session_id", &self.session_id)
.field("secret", &"[REDACTED]")
.field("product_version", &self.product_version)
.finish()
}
}
#[derive(Serialize)]
#[serde(deny_unknown_fields)]
struct CredentialDtoRef<'a> {
service_instance_id: Uuid,
session_id: Uuid,
secret: &'a str,
product_version: &'a str,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct CredentialDto {
service_instance_id: Uuid,
session_id: Uuid,
secret: Zeroizing<String>,
product_version: String,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn credential_round_trips_without_debugging_secret() {
let credential = SessionCredential::generate(Uuid::new_v4(), "2.6.4").unwrap();
let frame = credential.encode_frame().unwrap();
let decoded = SessionCredential::decode_frame(&frame).unwrap();
assert_eq!(decoded.service_instance_id(), credential.service_instance_id());
assert_eq!(decoded.session_id(), credential.session_id());
assert_eq!(decoded.secret(), credential.secret());
assert_eq!(decoded.product_version(), credential.product_version());
assert!(!format!("{credential:?}").contains(&base64::encode(credential.secret())));
}
#[test]
fn credential_rejects_malformed_lengths() {
assert!(SessionCredential::decode_frame(&[]).is_err());
assert!(SessionCredential::decode_frame(&[0, 0]).is_err());
assert!(SessionCredential::decode_frame(&[0, 2, b'{']).is_err());
assert!(SessionCredential::decode_frame(&vec![0; MAX_CREDENTIAL_FRAME + 1]).is_err());
}
}
+118
View File
@@ -0,0 +1,118 @@
use serde::{Deserialize, Serialize};
use thiserror::Error;
use uuid::Uuid;
#[derive(Debug, Error)]
pub enum TransportError {
#[error("invalid credential frame")]
InvalidCredential,
#[error("invalid transport state")]
InvalidState,
#[error("message exceeds transport limit")]
MessageTooLarge,
#[error("malformed transport message")]
MalformedMessage,
#[error("Noise operation failed")]
Noise(#[from] snow::Error),
#[error("transport serialization failed")]
Serialization(#[from] serde_json::Error),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase", deny_unknown_fields)]
pub enum HandshakeRejection {
VersionMismatch { client: String, service: String },
ServiceRestarted { service_instance_id: Uuid },
ReconnectSuperseded,
Unauthorized,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum ServiceErrorCode {
InvalidRequest,
Busy,
ChecksumFailed,
InstallFailed,
Internal,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CloseReason {
VersionMismatch,
Unauthorized,
SessionReplaced,
HandshakeFailed,
MalformedMessage,
MessageTooLarge,
AuthenticationFailed,
HandshakeTimeout,
ReconnectSuperseded,
InternalError,
ServiceRestarted,
HeartbeatTimeout,
}
impl CloseReason {
pub const fn code(self) -> u16 {
match self {
Self::VersionMismatch => 4001,
Self::Unauthorized => 4002,
Self::SessionReplaced => 4003,
Self::HandshakeFailed => 4004,
Self::MalformedMessage => 4005,
Self::MessageTooLarge => 4006,
Self::AuthenticationFailed => 4007,
Self::HandshakeTimeout => 4008,
Self::ReconnectSuperseded => 4009,
Self::InternalError => 4010,
Self::ServiceRestarted => 4011,
Self::HeartbeatTimeout => 4012,
}
}
pub const fn reason(self) -> &'static str {
match self {
Self::VersionMismatch => "VersionMismatch",
Self::Unauthorized => "Unauthorized",
Self::SessionReplaced => "SessionReplaced",
Self::HandshakeFailed => "HandshakeFailed",
Self::MalformedMessage => "MalformedMessage",
Self::MessageTooLarge => "MessageTooLarge",
Self::AuthenticationFailed => "AuthenticationFailed",
Self::HandshakeTimeout => "HandshakeTimeout",
Self::ReconnectSuperseded => "ReconnectSuperseded",
Self::InternalError => "InternalError",
Self::ServiceRestarted => "ServiceRestarted",
Self::HeartbeatTimeout => "HeartbeatTimeout",
}
}
}
#[cfg(test)]
mod tests {
use std::collections::HashSet;
use super::*;
#[test]
fn close_codes_are_unique_application_codes() {
let reasons = [
CloseReason::VersionMismatch,
CloseReason::Unauthorized,
CloseReason::SessionReplaced,
CloseReason::HandshakeFailed,
CloseReason::MalformedMessage,
CloseReason::MessageTooLarge,
CloseReason::AuthenticationFailed,
CloseReason::HandshakeTimeout,
CloseReason::ReconnectSuperseded,
CloseReason::InternalError,
CloseReason::ServiceRestarted,
CloseReason::HeartbeatTimeout,
];
let codes: HashSet<_> = reasons.iter().map(|reason| reason.code()).collect();
assert_eq!(codes.len(), reasons.len());
assert!(codes.iter().all(|code| (4000..5000).contains(code)));
}
}
@@ -0,0 +1,85 @@
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use super::{HandshakeRejection, MAX_PRELUDE, MAX_PRODUCT_VERSION, TransportError};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ClientPrelude {
pub product_version: String,
pub service_instance_id: Uuid,
pub session_id: Uuid,
}
impl ClientPrelude {
pub fn encode(&self) -> Result<Vec<u8>, TransportError> {
if self.product_version.is_empty() || self.product_version.len() > MAX_PRODUCT_VERSION {
return Err(TransportError::MalformedMessage);
}
let encoded = serde_json::to_vec(self)?;
if encoded.len() > MAX_PRELUDE {
return Err(TransportError::MessageTooLarge);
}
Ok(encoded)
}
pub fn decode(encoded: &[u8]) -> Result<Self, TransportError> {
if encoded.len() > MAX_PRELUDE {
return Err(TransportError::MessageTooLarge);
}
let prelude: Self = serde_json::from_slice(encoded)?;
if prelude.product_version.is_empty() || prelude.product_version.len() > MAX_PRODUCT_VERSION {
return Err(TransportError::MalformedMessage);
}
Ok(prelude)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "type", content = "data", rename_all = "camelCase", deny_unknown_fields)]
pub enum ServerPrelude {
Ready,
Rejected(HandshakeRejection),
}
impl ServerPrelude {
pub fn encode(&self) -> Result<Vec<u8>, TransportError> {
let encoded = serde_json::to_vec(self)?;
if encoded.len() > MAX_PRELUDE {
return Err(TransportError::MessageTooLarge);
}
Ok(encoded)
}
pub fn decode(encoded: &[u8]) -> Result<Self, TransportError> {
if encoded.len() > MAX_PRELUDE {
return Err(TransportError::MessageTooLarge);
}
Ok(serde_json::from_slice(encoded)?)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn preludes_reject_unknown_fields_and_invalid_versions() {
let instance = Uuid::new_v4();
let session = Uuid::new_v4();
let unknown = format!(
r#"{{"product_version":"2.6.4","service_instance_id":"{instance}","session_id":"{session}","extra":true}}"#
);
assert!(ClientPrelude::decode(unknown.as_bytes()).is_err());
assert!(
ClientPrelude {
product_version: String::new(),
service_instance_id: instance,
session_id: session,
}
.encode()
.is_err()
);
assert!(ClientPrelude::decode(&vec![b'x'; MAX_PRELUDE + 1]).is_err());
}
}
@@ -0,0 +1,140 @@
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use crate::service::{event::WsEvent, request::WsRequest, vpn_env::VpnEnv};
use super::{MAX_PLAINTEXT, MAX_SERVICE_MESSAGE, ServiceErrorCode, TransportError};
#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "type", content = "data", rename_all = "camelCase", deny_unknown_fields)]
pub enum ClientMessage {
Attach { last_event_revision: Option<u64> },
Request { id: Uuid, request: WsRequest },
Resync { last_event_revision: u64 },
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "type", content = "data", rename_all = "camelCase", deny_unknown_fields)]
pub enum ServerMessage {
Attached {
connection_id: Uuid,
current_revision: u64,
snapshot: VpnEnv,
},
Reply {
id: Uuid,
result: ServiceResult,
},
Event {
revision: u64,
event: WsEvent,
},
Snapshot {
current_revision: u64,
snapshot: VpnEnv,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "type", content = "data", rename_all = "camelCase", deny_unknown_fields)]
pub enum ServiceResult {
Accepted,
Rejected(ServiceRejection),
}
impl ServiceResult {
pub fn rejected(code: ServiceErrorCode, message: impl Into<String>) -> Self {
Self::Rejected(ServiceRejection::new(code, message))
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(try_from = "ServiceRejectionDto")]
pub struct ServiceRejection {
code: ServiceErrorCode,
message: String,
}
impl ServiceRejection {
fn new(code: ServiceErrorCode, message: impl Into<String>) -> Self {
let mut message = message.into();
if message.len() > MAX_SERVICE_MESSAGE {
let mut boundary = MAX_SERVICE_MESSAGE;
while !message.is_char_boundary(boundary) {
boundary -= 1;
}
message.truncate(boundary);
}
Self { code, message }
}
pub fn code(&self) -> ServiceErrorCode {
self.code
}
pub fn message(&self) -> &str {
&self.message
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ServiceRejectionDto {
code: ServiceErrorCode,
message: String,
}
impl TryFrom<ServiceRejectionDto> for ServiceRejection {
type Error = &'static str;
fn try_from(value: ServiceRejectionDto) -> Result<Self, Self::Error> {
if value.message.len() > MAX_SERVICE_MESSAGE {
return Err("service rejection message is too long");
}
Ok(Self {
code: value.code,
message: value.message,
})
}
}
pub(crate) fn encode<T: Serialize>(message: &T) -> Result<Vec<u8>, TransportError> {
let encoded = serde_json::to_vec(message)?;
if encoded.len() > MAX_PLAINTEXT {
return Err(TransportError::MessageTooLarge);
}
Ok(encoded)
}
pub(crate) fn decode<T: for<'de> Deserialize<'de>>(encoded: &[u8]) -> Result<T, TransportError> {
if encoded.len() > MAX_PLAINTEXT {
return Err(TransportError::MessageTooLarge);
}
Ok(serde_json::from_slice(encoded)?)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rejects_oversized_messages() {
assert!(encode(&"x".repeat(MAX_PLAINTEXT)).is_err());
assert!(decode::<String>(&vec![b'x'; MAX_PLAINTEXT + 1]).is_err());
}
#[test]
fn rejection_messages_are_utf8_safely_bounded() {
let ServiceResult::Rejected(rejection) = ServiceResult::rejected(ServiceErrorCode::Internal, "界".repeat(100))
else {
panic!("expected rejection");
};
assert!(rejection.message().len() <= MAX_SERVICE_MESSAGE);
let oversized = format!(
r#"{{"type":"rejected","data":{{"code":"internal","message":"{}"}}}}"#,
"x".repeat(MAX_SERVICE_MESSAGE + 1)
);
assert!(serde_json::from_str::<ServiceResult>(&oversized).is_err());
}
}
+18
View File
@@ -0,0 +1,18 @@
mod credential;
mod error;
mod handshake;
mod message;
mod noise;
pub use credential::SessionCredential;
pub use error::{CloseReason, HandshakeRejection, ServiceErrorCode, TransportError};
pub use handshake::{ClientPrelude, ServerPrelude};
pub use message::{ClientMessage, ServerMessage, ServiceRejection, ServiceResult};
pub use noise::{NoiseInitiator, NoiseResponder, NoiseTransport};
pub const MAX_CREDENTIAL_FRAME: usize = 512;
pub const MAX_PRELUDE: usize = 256;
pub const MAX_PRODUCT_VERSION: usize = 64;
pub const MAX_PLAINTEXT: usize = 60 * 1024;
pub const MAX_WS_MESSAGE: usize = u16::MAX as usize;
pub const MAX_SERVICE_MESSAGE: usize = 256;
+231
View File
@@ -0,0 +1,231 @@
use snow::{Builder, HandshakeState, TransportState, params::NoiseParams};
use zeroize::Zeroizing;
use super::{MAX_PLAINTEXT, MAX_PRODUCT_VERSION, MAX_WS_MESSAGE, TransportError};
const NOISE_PATTERN: &str = "Noise_NNpsk0_25519_ChaChaPoly_SHA256";
const NOISE_TAG_SIZE: usize = 16;
pub struct NoiseInitiator {
state: Option<HandshakeState>,
}
impl NoiseInitiator {
pub fn new(
product_version: &str,
service_instance_id: uuid::Uuid,
session_id: uuid::Uuid,
psk: &[u8; 32],
) -> Result<Self, TransportError> {
let params = noise_params()?;
let prologue = prologue(product_version, service_instance_id, session_id)?;
Ok(Self {
state: Some(
Builder::new(params)
.prologue(&prologue)?
.psk(0, psk)?
.build_initiator()?,
),
})
}
pub fn write_first(&mut self) -> Result<Vec<u8>, TransportError> {
let state = self.state.as_mut().ok_or(TransportError::InvalidState)?;
let mut output = vec![0_u8; 128];
let len = state.write_message(&[], &mut output)?;
output.truncate(len);
Ok(output)
}
pub fn read_response(mut self, message: &[u8]) -> Result<NoiseTransport, TransportError> {
if message.len() > MAX_WS_MESSAGE {
return Err(TransportError::MessageTooLarge);
}
let mut state = self.state.take().ok_or(TransportError::InvalidState)?;
let mut output = vec![0_u8; 128];
state.read_message(message, &mut output)?;
Ok(NoiseTransport::new(state.into_transport_mode()?))
}
}
pub struct NoiseResponder {
state: Option<HandshakeState>,
}
impl NoiseResponder {
pub fn new(
product_version: &str,
service_instance_id: uuid::Uuid,
session_id: uuid::Uuid,
psk: &[u8; 32],
) -> Result<Self, TransportError> {
let params = noise_params()?;
let prologue = prologue(product_version, service_instance_id, session_id)?;
Ok(Self {
state: Some(
Builder::new(params)
.prologue(&prologue)?
.psk(0, psk)?
.build_responder()?,
),
})
}
pub fn read_first(&mut self, message: &[u8]) -> Result<(), TransportError> {
if message.len() > MAX_WS_MESSAGE {
return Err(TransportError::MessageTooLarge);
}
let state = self.state.as_mut().ok_or(TransportError::InvalidState)?;
let mut output = vec![0_u8; 128];
state.read_message(message, &mut output)?;
Ok(())
}
pub fn write_response(mut self) -> Result<(Vec<u8>, NoiseTransport), TransportError> {
let mut state = self.state.take().ok_or(TransportError::InvalidState)?;
let mut output = vec![0_u8; 128];
let len = state.write_message(&[], &mut output)?;
output.truncate(len);
let transport = NoiseTransport::new(state.into_transport_mode()?);
Ok((output, transport))
}
}
pub struct NoiseTransport {
state: TransportState,
}
impl NoiseTransport {
fn new(state: TransportState) -> Self {
Self { state }
}
pub fn encrypt<T: serde::Serialize>(&mut self, message: &T) -> Result<Vec<u8>, TransportError> {
let plaintext = Zeroizing::new(super::message::encode(message)?);
let mut output = vec![0_u8; plaintext.len() + NOISE_TAG_SIZE];
let len = self.state.write_message(&plaintext, &mut output)?;
output.truncate(len);
Ok(output)
}
pub fn decrypt<T: for<'de> serde::Deserialize<'de>>(&mut self, message: &[u8]) -> Result<T, TransportError> {
if message.len() > MAX_WS_MESSAGE || message.len() < NOISE_TAG_SIZE {
return Err(if message.len() > MAX_WS_MESSAGE {
TransportError::MessageTooLarge
} else {
TransportError::MalformedMessage
});
}
let mut plaintext = Zeroizing::new(vec![0_u8; message.len()]);
let len = self.state.read_message(message, &mut plaintext)?;
plaintext.truncate(len);
if plaintext.len() > MAX_PLAINTEXT {
return Err(TransportError::MessageTooLarge);
}
super::message::decode(&plaintext)
}
}
fn noise_params() -> Result<NoiseParams, TransportError> {
NOISE_PATTERN.parse().map_err(|_| TransportError::InvalidState)
}
fn prologue(
product_version: &str,
service_instance_id: uuid::Uuid,
session_id: uuid::Uuid,
) -> Result<Vec<u8>, TransportError> {
if product_version.is_empty() || product_version.len() > MAX_PRODUCT_VERSION {
return Err(TransportError::MessageTooLarge);
}
let mut value = Vec::with_capacity(5 + 2 + product_version.len() + 32);
value.extend_from_slice(b"GPWS\0");
value.extend_from_slice(&(product_version.len() as u16).to_be_bytes());
value.extend_from_slice(product_version.as_bytes());
value.extend_from_slice(service_instance_id.as_bytes());
value.extend_from_slice(session_id.as_bytes());
Ok(value)
}
#[cfg(test)]
mod tests {
use super::*;
#[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
struct Payload(String);
#[test]
fn peers_exchange_directional_messages() {
let instance = uuid::Uuid::new_v4();
let session = uuid::Uuid::new_v4();
let psk = [7_u8; 32];
let mut initiator = NoiseInitiator::new("2.6.4", instance, session, &psk).unwrap();
let mut responder = NoiseResponder::new("2.6.4", instance, session, &psk).unwrap();
let first = initiator.write_first().unwrap();
responder.read_first(&first).unwrap();
let (response, mut server) = responder.write_response().unwrap();
let mut client = initiator.read_response(&response).unwrap();
let encrypted = client.encrypt(&Payload("hello".into())).unwrap();
assert_eq!(server.decrypt::<Payload>(&encrypted).unwrap(), Payload("hello".into()));
assert!(server.decrypt::<Payload>(&encrypted).is_err());
let response = server.encrypt(&Payload("world".into())).unwrap();
assert_eq!(client.decrypt::<Payload>(&response).unwrap(), Payload("world".into()));
}
#[test]
fn wrong_psk_fails_handshake() {
let instance = uuid::Uuid::new_v4();
let session = uuid::Uuid::new_v4();
let mut initiator = NoiseInitiator::new("2.6.4", instance, session, &[1; 32]).unwrap();
let mut responder = NoiseResponder::new("2.6.4", instance, session, &[2; 32]).unwrap();
let first = initiator.write_first().unwrap();
assert!(responder.read_first(&first).is_err());
}
#[test]
fn transcript_identity_mismatch_fails_handshake() {
let instance = uuid::Uuid::new_v4();
let session = uuid::Uuid::new_v4();
let psk = [3_u8; 32];
for mut responder in [
NoiseResponder::new("2.6.5", instance, session, &psk).unwrap(),
NoiseResponder::new("2.6.4", uuid::Uuid::new_v4(), session, &psk).unwrap(),
NoiseResponder::new("2.6.4", instance, uuid::Uuid::new_v4(), &psk).unwrap(),
] {
let mut initiator = NoiseInitiator::new("2.6.4", instance, session, &psk).unwrap();
let first = initiator.write_first().unwrap();
assert!(responder.read_first(&first).is_err());
}
}
#[test]
fn transport_rejects_tampering_truncation_and_reordering() {
let instance = uuid::Uuid::new_v4();
let session = uuid::Uuid::new_v4();
let psk = [9_u8; 32];
let mut initiator = NoiseInitiator::new("2.6.4", instance, session, &psk).unwrap();
let mut responder = NoiseResponder::new("2.6.4", instance, session, &psk).unwrap();
let first = initiator.write_first().unwrap();
responder.read_first(&first).unwrap();
let (response, mut server) = responder.write_response().unwrap();
let mut client = initiator.read_response(&response).unwrap();
let first = client.encrypt(&Payload("first".into())).unwrap();
let second = client.encrypt(&Payload("second".into())).unwrap();
assert!(server.decrypt::<Payload>(&second).is_err());
let mut initiator = NoiseInitiator::new("2.6.4", instance, session, &psk).unwrap();
let mut responder = NoiseResponder::new("2.6.4", instance, session, &psk).unwrap();
let handshake = initiator.write_first().unwrap();
responder.read_first(&handshake).unwrap();
let (response, mut server) = responder.write_response().unwrap();
let mut client = initiator.read_response(&response).unwrap();
let mut tampered = client.encrypt(&Payload("value".into())).unwrap();
tampered[0] ^= 1;
assert!(server.decrypt::<Payload>(&tampered).is_err());
assert!(server.decrypt::<Payload>(&first[..NOISE_TAG_SIZE - 1]).is_err());
}
}