From 6f7b9ca06aa11abdab0eac76e176427babfc9e76 Mon Sep 17 00:00:00 2001 From: Keivan-sf Date: Sat, 26 Jul 2025 13:46:08 +0330 Subject: [PATCH] Improve config type and add authority This makes the parser take a more passive approach, no unnecessary defaults or fileds --- src/config_models/mod.rs | 31 +++---- src/parser/vless/mod.rs | 172 ++++++++++++++++++------------------- src/parser/vless/models.rs | 39 +++++---- 3 files changed, 118 insertions(+), 124 deletions(-) diff --git a/src/config_models/mod.rs b/src/config_models/mod.rs index 98d95ff..71d05aa 100644 --- a/src/config_models/mod.rs +++ b/src/config_models/mod.rs @@ -4,8 +4,8 @@ use serde::{Deserialize, Serialize}; pub struct VlessUser { pub id: String, pub encryption: String, - pub flow: String, - pub level: u8, + pub flow: Option, + pub level: Option, } #[derive(Serialize, Deserialize)] @@ -28,37 +28,38 @@ pub enum OutboundSettings { #[derive(Serialize, Deserialize)] pub struct NonHeaderObject { - pub r#type: String, + pub r#type: Option, } #[allow(non_snake_case)] #[derive(Serialize, Deserialize)] pub struct QuicSettings { pub header: Option, - pub security: String, - pub key: String, + pub security: Option, + pub key: Option, } #[allow(non_snake_case)] #[derive(Serialize, Deserialize)] pub struct GRPCSettings { - pub multiMode: bool, - pub serviceName: String, + pub authority: Option, + pub multiMode: Option, + pub serviceName: Option, } #[allow(non_snake_case)] #[derive(Serialize, Deserialize)] pub struct RealitySettings { - pub fingerprint: String, - pub serverName: String, - pub publicKey: String, - pub shortId: String, - pub spiderX: String, + pub fingerprint: Option, + pub serverName: Option, + pub publicKey: Option, + pub shortId: Option, + pub spiderX: Option, } #[derive(Serialize, Deserialize)] pub struct TCPHeader { - pub r#type: String, + pub r#type: Option, } #[allow(non_snake_case)] @@ -101,8 +102,8 @@ pub struct TlsSettings { #[allow(non_snake_case)] #[derive(Serialize, Deserialize)] pub struct StreamSettings { - pub network: String, - pub security: String, + pub network: Option, + pub security: Option, pub tlsSettings: Option, pub wsSettings: Option, pub tcpSettings: Option, diff --git a/src/parser/vless/mod.rs b/src/parser/vless/mod.rs index ec00125..d017274 100644 --- a/src/parser/vless/mod.rs +++ b/src/parser/vless/mod.rs @@ -5,19 +5,16 @@ use http::Uri; use std::process::exit; pub fn create_outbound_object(data: models::VlessData) -> Outbound { + let network_type = data.query.r#type.clone().unwrap_or(String::from("")); return Outbound { protocol: String::from("vless"), tag: String::from("proxy"), streamSettings: StreamSettings { network: data.query.r#type.clone(), security: data.query.security.clone(), - tlsSettings: if data.query.security == String::from("tls") { + tlsSettings: if network_type == String::from("tls") { Some(TlsSettings { - alpn: if data.query.alpn.len() > 1 { - Some(vec![data.query.alpn]) - } else { - None - }, + alpn: data.query.alpn.map(|alpn| vec![alpn]), rejectUnknownSni: None, enableSessionResumption: None, minVersion: None, @@ -25,66 +22,59 @@ pub fn create_outbound_object(data: models::VlessData) -> Outbound { cipherSuites: None, disableSystemRoot: None, preferServerCipherSuites: None, - fingerprint: Some(data.query.fp.clone()), - serverName: Some(data.query.sni.clone()), + fingerprint: data.query.fp.clone(), + serverName: data.query.sni.clone(), allowInsecure: Some(false), }) } else { None }, - wsSettings: if data.query.r#type == String::from("ws") { + wsSettings: if network_type == String::from("ws") { Some(WsSettings { - Host: Some(data.query.host), - path: Some( - urlencoding::decode(data.query.path.as_str()) - .unwrap() - .into_owned(), - ), + Host: data.query.host, + path: data.query.path, acceptProxyProtocol: None, }) } else { None }, - tcpSettings: if data.query.r#type == String::from("tcp") { + tcpSettings: if network_type == String::from("tcp") { Some(TCPSettings { header: Some(TCPHeader { - r#type: if data.query.header_type.len() > 1 { - data.query.header_type - } else { - String::from("none") - }, + r#type: Some(data.query.header_type.unwrap_or(String::from("none"))), }), acceptProxyProtocol: None, }) } else { None }, - realitySettings: if data.query.security == String::from("reality") { + realitySettings: if network_type == String::from("reality") { Some(RealitySettings { publicKey: data.query.pbk, serverName: data.query.sni.clone(), shortId: data.query.sid, - spiderX: String::from(""), - fingerprint: data.query.fp, + spiderX: Some(String::from("")), + fingerprint: data.query.fp.clone(), }) } else { None }, - grpcSettings: if data.query.r#type == String::from("grpc") { + grpcSettings: if network_type == String::from("grpc") { Some(GRPCSettings { - multiMode: false, + authority: data.query.authority, + multiMode: Some(false), serviceName: data.query.service_name, }) } else { None }, - quicSettings: if data.query.r#type == String::from("quic") { + quicSettings: if network_type == String::from("quic") { Some(QuicSettings { header: Some(NonHeaderObject { - r#type: String::from("none"), + r#type: Some(String::from("none")), }), - security: String::from("none"), - key: String::from(""), + security: Some(String::from("none")), + key: Some(String::from("")), }) } else { None @@ -97,12 +87,8 @@ pub fn create_outbound_object(data: models::VlessData) -> Outbound { users: vec![VlessUser { id: data.address_data.uuid, flow: data.query.flow, - encryption: if data.query.encryption.len() > 0 { - data.query.encryption - } else { - String::from("none") - }, - level: 0, + encryption: data.query.encryption.unwrap_or(String::from("none")), + level: Some(0), }], }], }), @@ -147,12 +133,21 @@ fn parse_vless_query(raw_query: &str) -> models::VlessQuery { let query: Vec<(&str, &str)> = querystring::querify(raw_query); let a = models::VlessQuery { - alpn: urlencoding::decode(get_parameter_value(&query, "alpn").as_str()) - .unwrap() - .into_owned(), - path: urlencoding::decode(get_parameter_value(&query, "path").as_str()) - .unwrap() - .into_owned(), + alpn: get_parameter_value(&query, "alpn").and_then(|s| { + urlencoding::decode(&s) + .ok() + .map(|decoded| decoded.into_owned()) + }), + path: get_parameter_value(&query, "path").and_then(|s| { + urlencoding::decode(&s) + .ok() + .map(|decoded| decoded.into_owned()) + }), + authority: get_parameter_value(&query, "authority").and_then(|s| { + urlencoding::decode(&s) + .ok() + .map(|decoded| decoded.into_owned()) + }), pbk: get_parameter_value(&query, "pbk"), security: get_parameter_value(&query, "security"), sid: get_parameter_value(&query, "sid"), @@ -174,13 +169,11 @@ fn parse_vless_query(raw_query: &str) -> models::VlessQuery { return a; } -fn get_parameter_value(query: &Vec<(&str, &str)>, param: &str) -> String { +fn get_parameter_value(query: &Vec<(&str, &str)>, param: &str) -> Option { return query .iter() .find(|q| String::from(q.0) == String::from(param)) - .unwrap_or(&("", "")) - .1 - .to_string(); + .map(|q| q.1.to_string()); } #[cfg(test)] @@ -198,7 +191,7 @@ mod tests { .header .unwrap() .r#type, - "http" + Some(String::from("http")) ) } @@ -209,8 +202,8 @@ mod tests { assert_eq!(data.address_data.address, "nwarne.fast-ip.com"); assert_eq!(data.address_data.uuid, "2dc56709-sdfs-sdfs-2234-128904"); assert_eq!(data.address_data.port, 80); - assert_eq!(data.query.encryption, "none"); - assert_eq!(data.query.r#type, "ws"); + assert_eq!(data.query.encryption.unwrap(), "none"); + assert_eq!(data.query.r#type.unwrap(), "ws"); } #[test] @@ -223,61 +216,61 @@ mod tests { "4d2c3e35-749d-52e3-bdb6-3f3f4950c183" ); assert_eq!(data.address_data.port, 2053); - assert_eq!(data.query.flow, "xtls-rprx-vision"); - assert_eq!(data.query.security, "reality"); - assert_eq!(data.query.r#type, "tcp"); + assert_eq!(data.query.flow.unwrap(), "xtls-rprx-vision"); + assert_eq!(data.query.security.unwrap(), "reality"); + assert_eq!(data.query.r#type.unwrap(), "tcp"); } #[test] fn parse_vless_query_data() { let query = "security=reality&sni=bench.sh&fp=chrome&pbk=7xhH4b_VkliBxGulljcyPOH-bYUA2dl-XAdZAsfhk04&sid=6ba85179e30d4fc2&type=tcp&flow=xtls-rprx-vision&alpn=http%2F1.1&path=/"; let parsed_query = parse_vless_query(query); - assert_eq!(parsed_query.sni, "bench.sh"); - assert_eq!(parsed_query.security, "reality"); - assert_eq!(parsed_query.fp, "chrome"); + assert_eq!(parsed_query.sni.unwrap(), "bench.sh"); + assert_eq!(parsed_query.security.unwrap(), "reality"); + assert_eq!(parsed_query.fp.unwrap(), "chrome"); assert_eq!( - parsed_query.pbk, + parsed_query.pbk.unwrap(), "7xhH4b_VkliBxGulljcyPOH-bYUA2dl-XAdZAsfhk04" ); - assert_eq!(parsed_query.sid, "6ba85179e30d4fc2"); - assert_eq!(parsed_query.r#type, "tcp"); - assert_eq!(parsed_query.flow, "xtls-rprx-vision"); - assert_eq!(parsed_query.alpn, "http/1.1"); - assert_eq!(parsed_query.path, "/"); - assert_eq!(parsed_query.encryption, ""); - assert_eq!(parsed_query.header_type, ""); - assert_eq!(parsed_query.host, ""); - assert_eq!(parsed_query.seed, ""); - assert_eq!(parsed_query.quic_security, ""); - assert_eq!(parsed_query.key, ""); - assert_eq!(parsed_query.mode, ""); - assert_eq!(parsed_query.service_name, ""); - assert_eq!(parsed_query.slpn, ""); - assert_eq!(parsed_query.spx, ""); + assert_eq!(parsed_query.sid.unwrap(), "6ba85179e30d4fc2"); + assert_eq!(parsed_query.r#type.unwrap(), "tcp"); + assert_eq!(parsed_query.flow.unwrap(), "xtls-rprx-vision"); + assert_eq!(parsed_query.alpn.unwrap(), "http/1.1"); + assert_eq!(parsed_query.path.unwrap(), "/"); + assert_eq!(parsed_query.encryption, None); + assert_eq!(parsed_query.header_type, None); + assert_eq!(parsed_query.host, None); + assert_eq!(parsed_query.seed, None); + assert_eq!(parsed_query.quic_security, None); + assert_eq!(parsed_query.key, None); + assert_eq!(parsed_query.mode, None); + assert_eq!(parsed_query.service_name, None); + assert_eq!(parsed_query.slpn, None); + assert_eq!(parsed_query.spx, None); } #[test] fn parse_vless_query_with_defaults() { let query = ""; let parsed_query = parse_vless_query(query); - assert_eq!(parsed_query.sni, ""); - assert_eq!(parsed_query.security, ""); - assert_eq!(parsed_query.fp, ""); - assert_eq!(parsed_query.pbk, ""); - assert_eq!(parsed_query.sid, ""); - assert_eq!(parsed_query.r#type, ""); - assert_eq!(parsed_query.r#flow, ""); - assert_eq!(parsed_query.path, ""); - assert_eq!(parsed_query.encryption, ""); - assert_eq!(parsed_query.header_type, ""); - assert_eq!(parsed_query.host, ""); - assert_eq!(parsed_query.seed, ""); - assert_eq!(parsed_query.quic_security, ""); - assert_eq!(parsed_query.key, ""); - assert_eq!(parsed_query.mode, ""); - assert_eq!(parsed_query.service_name, ""); - assert_eq!(parsed_query.slpn, ""); - assert_eq!(parsed_query.spx, ""); + assert_eq!(parsed_query.sni, None); + assert_eq!(parsed_query.security, None); + assert_eq!(parsed_query.fp, None); + assert_eq!(parsed_query.pbk, None); + assert_eq!(parsed_query.sid, None); + assert_eq!(parsed_query.r#type, None); + assert_eq!(parsed_query.r#flow, None); + assert_eq!(parsed_query.path, None); + assert_eq!(parsed_query.encryption, None); + assert_eq!(parsed_query.header_type, None); + assert_eq!(parsed_query.host, None); + assert_eq!(parsed_query.seed, None); + assert_eq!(parsed_query.quic_security, None); + assert_eq!(parsed_query.key, None); + assert_eq!(parsed_query.mode, None); + assert_eq!(parsed_query.service_name, None); + assert_eq!(parsed_query.slpn, None); + assert_eq!(parsed_query.spx, None); } #[test] @@ -291,7 +284,6 @@ mod tests { #[test] fn parse_vless_ipv6_host() { - let v = "vless://4d91916f-a7fd-419b-8b90-640bb8d1b9f4@[2a06:98c1:3120::1]:443?path=%2FPSZPkYG71g6bn84o%2FMTQxLjE0OC4yMDMuNg&security=tls&alpn=http%2F1.1&encryption=none&host=titantablomanahamrah.ir&fp=randomized&type=ws&sni=TITanTabLOmaNAHaMRaH.IR#"; let raw_host = "uu0id@[2a06:98c1:3120::1]:443"; let parsed = parse_vless_address(raw_host); assert_eq!(parsed.port, 443); diff --git a/src/parser/vless/models.rs b/src/parser/vless/models.rs index 16a6e38..767cd3b 100644 --- a/src/parser/vless/models.rs +++ b/src/parser/vless/models.rs @@ -1,23 +1,24 @@ pub struct VlessQuery { - pub security: String, - pub sni: String, - pub fp: String, - pub pbk: String, - pub sid: String, - pub r#type: String, - pub flow: String, - pub path: String, - pub encryption: String, - pub header_type: String, - pub host: String, - pub seed: String, - pub quic_security: String, - pub r#key: String, - pub mode: String, - pub service_name: String, - pub slpn: String, - pub spx: String, - pub alpn: String, + pub security: Option, + pub sni: Option, + pub fp: Option, + pub pbk: Option, + pub sid: Option, + pub r#type: Option, + pub flow: Option, + pub path: Option, + pub encryption: Option, + pub header_type: Option, + pub host: Option, + pub seed: Option, + pub quic_security: Option, + pub r#key: Option, + pub mode: Option, + pub service_name: Option, + pub authority: Option, + pub slpn: Option, + pub spx: Option, + pub alpn: Option, } pub struct VlessAddress {