feat: prepare 3.0.0 release

This commit is contained in:
Kevin Yue committed 2026-10-09 18:21:44 +08:00
1 parent e98fd7894a
commit b7b708e9cd
252 files changed
+26210 -7457

No files matched your search

+188 -45
View File
@@ -1,15 +1,41 @@
use std::collections::HashMap;
use std::{collections::HashMap, fmt};
use serde::{Deserialize, Serialize};
use specta::Type;
use zeroize::Zeroize;
use crate::{
gateway::Gateway,
os_profile::{ClientOs, OsProfile},
hip::HipSource,
os_profile::{ClientOs, HostIdentity, OsProfile},
session::ConnectionPlan,
};
use super::vpn_state::ConnectInfo;
pub const MAX_CLIENT_IDENTITY_DATA: usize = 32 * 1024;
#[derive(Debug, Deserialize, Serialize)]
pub struct StoreEditedHipReportChunkRequest {
pub upload_id: Option<String>,
pub offset: usize,
pub xml: String,
pub complete: bool,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct PreviewHipReportRequest {
pub source: HipSource,
pub client_os: ClientOs,
pub client_version: String,
pub host_id: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ReadHipPreviewChunkRequest {
pub preview_id: String,
pub offset: usize,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct LaunchGuiRequest {
user: String,
@@ -30,10 +56,11 @@ impl LaunchGuiRequest {
}
}
#[derive(Debug, Deserialize, Serialize, Type, Clone)]
#[derive(Deserialize, Serialize, Type, Clone)]
pub struct ConnectArgs {
cookie: String,
vpnc_script: Option<String>,
host_identity: Option<HostIdentity>,
ignore_tls_errors: bool,
user_agent: Option<String>,
os: Option<ClientOs>,
@@ -43,11 +70,11 @@ pub struct ConnectArgs {
certificate: Option<String>,
sslkey: Option<String>,
certificate_data: Option<String>,
sslkey_data: Option<String>,
key_password: Option<String>,
hip: bool,
csd_uid: u32,
csd_wrapper: Option<String>,
hip_source: HipSource,
reconnect_timeout: u32,
mtu: u32,
@@ -61,10 +88,11 @@ pub struct ConnectArgs {
}
impl ConnectArgs {
pub fn new(cookie: String) -> Self {
fn new() -> Self {
Self {
cookie,
vpnc_script: None,
host_identity: None,
ignore_tls_errors: false,
user_agent: None,
os: None,
os_version: None,
@@ -72,10 +100,10 @@ impl ConnectArgs {
host_id: None,
certificate: None,
sslkey: None,
certificate_data: None,
sslkey_data: None,
key_password: None,
hip: false,
csd_uid: 0,
csd_wrapper: None,
hip_source: HipSource::Disabled,
reconnect_timeout: 300,
mtu: 0,
disable_ipv6: false,
@@ -87,8 +115,12 @@ impl ConnectArgs {
}
}
pub fn cookie(&self) -> &str {
&self.cookie
pub fn host_identity(&self) -> Option<&HostIdentity> {
self.host_identity.as_ref()
}
pub fn ignore_tls_errors(&self) -> bool {
self.ignore_tls_errors
}
pub fn vpnc_script(&self) -> Option<String> {
@@ -127,20 +159,28 @@ impl ConnectArgs {
self.sslkey.clone()
}
pub fn certificate_data(&self) -> anyhow::Result<Option<Vec<u8>>> {
self
.certificate_data
.as_deref()
.map(crate::utils::base64::decode_to_vec)
.transpose()
}
pub fn sslkey_data(&self) -> anyhow::Result<Option<Vec<u8>>> {
self
.sslkey_data
.as_deref()
.map(crate::utils::base64::decode_to_vec)
.transpose()
}
pub fn key_password(&self) -> Option<String> {
self.key_password.clone()
}
pub fn hip(&self) -> bool {
self.hip
}
pub fn csd_uid(&self) -> u32 {
self.csd_uid
}
pub fn csd_wrapper(&self) -> Option<String> {
self.csd_wrapper.clone()
pub fn hip_source(&self) -> &HipSource {
&self.hip_source
}
pub fn reconnect_timeout(&self) -> u32 {
@@ -176,17 +216,49 @@ impl ConnectArgs {
}
}
impl fmt::Debug for ConnectArgs {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ConnectArgs")
.field("vpnc_script", &self.vpnc_script)
.field(
"client_auth_path",
&(self.certificate.is_some() || self.sslkey.is_some()),
)
.field(
"client_auth_data",
&(self.certificate_data.is_some() || self.sslkey_data.is_some()),
)
.field("hip_source", &self.hip_source)
.field("reconnect_timeout", &self.reconnect_timeout)
.field("mtu", &self.mtu)
.field("disable_ipv6", &self.disable_ipv6)
.field("no_dtls", &self.no_dtls)
.field("allow_extend_session", &self.allow_extend_session)
.finish_non_exhaustive()
}
}
impl Drop for ConnectArgs {
fn drop(&mut self) {
self.key_password.zeroize();
self.certificate_data.zeroize();
self.sslkey_data.zeroize();
}
}
#[derive(Debug, Deserialize, Serialize, Type, Clone)]
pub struct ConnectRequest {
info: ConnectInfo,
plan: ConnectionPlan,
args: ConnectArgs,
}
impl ConnectRequest {
pub fn new(info: ConnectInfo, cookie: String) -> Self {
pub fn new(info: ConnectInfo, plan: ConnectionPlan) -> Self {
Self {
info,
args: ConnectArgs::new(cookie),
plan,
args: ConnectArgs::new(),
}
}
@@ -195,22 +267,13 @@ impl ConnectRequest {
self
}
pub fn with_hip(mut self, hip: bool) -> Self {
self.args.hip = hip;
self
}
pub fn with_csd_uid(mut self, csd_uid: u32) -> Self {
self.args.csd_uid = csd_uid;
self
}
pub fn with_csd_wrapper<T: Into<Option<String>>>(mut self, csd_wrapper: T) -> Self {
self.args.csd_wrapper = csd_wrapper.into();
pub fn with_hip_source(mut self, hip_source: HipSource) -> Self {
self.args.hip_source = hip_source;
self
}
pub fn with_os_profile(mut self, profile: &OsProfile) -> Self {
self.args.host_identity = Some(profile.host_identity().clone());
self.args.os = Some(profile.client_os());
self.args.os_version = Some(profile.os_version().to_string());
self.args.client_version = Some(profile.client_version().to_string());
@@ -219,6 +282,11 @@ impl ConnectRequest {
self
}
pub fn with_ignore_tls_errors(mut self, ignore_tls_errors: bool) -> Self {
self.args.ignore_tls_errors = ignore_tls_errors;
self
}
pub fn with_certificate<T: Into<Option<String>>>(mut self, certificate: T) -> Self {
self.args.certificate = certificate.into();
self
@@ -229,6 +297,16 @@ impl ConnectRequest {
self
}
pub fn with_certificate_data(mut self, certificate: Option<Vec<u8>>) -> Self {
self.args.certificate_data = certificate.map(encode_secret);
self
}
pub fn with_sslkey_data(mut self, sslkey: Option<Vec<u8>>) -> Self {
self.args.sslkey_data = sslkey.map(encode_secret);
self
}
pub fn with_key_password<T: Into<Option<String>>>(mut self, key_password: T) -> Self {
self.args.key_password = key_password.into();
self
@@ -274,8 +352,8 @@ impl ConnectRequest {
self
}
pub fn gateway(&self) -> &Gateway {
self.info.gateway()
pub fn plan(&self) -> &ConnectionPlan {
&self.plan
}
pub fn info(&self) -> &ConnectInfo {
@@ -287,6 +365,12 @@ impl ConnectRequest {
}
}
fn encode_secret(mut data: Vec<u8>) -> String {
let encoded = crate::utils::base64::encode(&data);
data.zeroize();
encoded
}
#[derive(Debug, Deserialize, Serialize, Type)]
pub struct DisconnectRequest;
@@ -298,10 +382,19 @@ pub struct UpdateLogLevelRequest(pub String);
pub enum WsRequest {
Connect(Box<ConnectRequest>),
Disconnect(DisconnectRequest),
StopNonTunnelAttachment { connection_id: uuid::Uuid },
StoreEditedHipReportChunk(StoreEditedHipReportChunkRequest),
PreviewHipReport(PreviewHipReportRequest),
GetHipApprovalStatus { approval_id: String },
ReadHipPreviewChunk(ReadHipPreviewChunkRequest),
GetLastSubmittedHipReport,
UpdateLogLevel(UpdateLogLevelRequest),
RestartGui,
UpdateGui(UpdateGuiRequest),
GetVpncScriptMetadata,
}
#[derive(Debug, Deserialize, Serialize)]
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct UpdateGuiRequest {
pub path: String,
pub checksum: String,
@@ -313,17 +406,52 @@ mod tests {
use super::*;
use crate::os_profile::OsProfileBuilder;
use crate::{
gateway::Gateway,
session::{AuthenticatedGateway, GatewayAuthentication, InternalSessionPolicy},
};
fn test_request(info: ConnectInfo) -> ConnectRequest {
let plan = ConnectionPlan::new(
vec![AuthenticatedGateway {
gateway: info.gateway().clone(),
binding: Some(crate::session::network::test_binding()),
authentication: GatewayAuthentication::new("authcookie=secret-cookie&user=user".into(), "tunnel".into())
.unwrap(),
}],
vec![],
InternalSessionPolicy::default(),
)
.unwrap();
ConnectRequest::new(info, plan)
}
fn test_connect_info() -> ConnectInfo {
let gateway = Gateway::new("Gateway".to_string(), "vpn.example.com".to_string());
ConnectInfo::new("portal.example.com".to_string(), gateway.clone(), vec![gateway])
}
#[test]
fn connect_request_round_trips_a_validated_plan_and_rejects_cookie_only_wire_input() {
let request = test_request(test_connect_info());
let mut value = serde_json::to_value(&request).unwrap();
assert!(value["args"].get("cookie").is_none());
let decoded: ConnectRequest = serde_json::from_value(value.clone()).unwrap();
assert_eq!(decoded.plan().members().len(), 1);
assert_eq!(decoded.plan().members()[0].authentication.connection_type(), "tunnel");
value["plan"]["members"] = json!([]);
assert!(serde_json::from_value::<ConnectRequest>(value).is_err());
let mut legacy = serde_json::to_value(&request).unwrap();
legacy.as_object_mut().unwrap().remove("plan");
legacy["args"]["cookie"] = json!("authcookie=secret-cookie&user=user");
assert!(serde_json::from_value::<ConnectRequest>(legacy).is_err());
}
#[test]
fn connect_request_serializes_allow_extend_session() {
let gateway = Gateway::new("Gateway".to_string(), "vpn.example.com".to_string());
let info = ConnectInfo::new("portal.example.com".to_string(), gateway.clone(), vec![gateway]);
let req = ConnectRequest::new(info, "authcookie=AUTH".to_string()).with_allow_extend_session(true);
let req = test_request(info).with_allow_extend_session(true);
let value = serde_json::to_value(req).unwrap();
assert_eq!(value["args"]["allowExtendSession"], json!(true));
@@ -333,7 +461,7 @@ mod tests {
fn with_os_profile_sets_user_agent_from_profile() {
let profile = OsProfileBuilder::new(ClientOs::Linux).client_version("6.0.0").build();
let req = ConnectRequest::new(test_connect_info(), "cookie".to_string()).with_os_profile(&profile);
let req = test_request(test_connect_info()).with_os_profile(&profile);
assert_eq!(req.args().user_agent(), Some(profile.user_agent().to_string()));
}
@@ -342,11 +470,26 @@ mod tests {
fn with_os_profile_sets_host_id_from_profile_runtime_identity() {
let profile = OsProfileBuilder::new(ClientOs::Linux).build();
let req = ConnectRequest::new(test_connect_info(), "cookie".to_string()).with_os_profile(&profile);
let req = test_request(test_connect_info()).with_os_profile(&profile);
assert_eq!(
req.args().host_id(),
Some(profile.host_identity().host_id().to_string())
);
}
#[test]
fn client_identity_data_round_trips_without_debug_disclosure() {
let req = test_request(test_connect_info())
.with_certificate_data(Some(b"certificate".to_vec()))
.with_sslkey_data(Some(b"private-key".to_vec()));
let encoded = serde_json::to_vec(&req).unwrap();
let decoded: ConnectRequest = serde_json::from_slice(&encoded).unwrap();
assert_eq!(decoded.args().certificate_data().unwrap().unwrap(), b"certificate");
assert_eq!(decoded.args().sslkey_data().unwrap().unwrap(), b"private-key");
let debug = format!("{decoded:?}");
assert!(!debug.contains("secret-cookie"));
assert!(!debug.contains("private-key"));
}
}