From 4c0cddda3ff5dddbfa7ae51c1974145de0478371 Mon Sep 17 00:00:00 2001 From: Keivan-sf Date: Wed, 23 Jul 2025 20:03:51 +0330 Subject: [PATCH 01/11] Use fingerprints in tls settings --- src/parser/vless/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/parser/vless/mod.rs b/src/parser/vless/mod.rs index 30dbce1..95baf52 100644 --- a/src/parser/vless/mod.rs +++ b/src/parser/vless/mod.rs @@ -20,7 +20,7 @@ pub fn create_outbound_object(data: models::VlessData) -> Outbound { cipherSuites: None, disableSystemRoot: None, preferServerCipherSuites: None, - fingerprint: Some(String::from("")), + fingerprint: Some(data.query.fp.clone()), serverName: Some(data.query.sni.clone()), allowInsecure: Some(false), }) From 9b73b4c6edb945a65ba0930087ca236646c5e1b8 Mon Sep 17 00:00:00 2001 From: Keivan-sf Date: Wed, 23 Jul 2025 21:00:07 +0330 Subject: [PATCH 02/11] Parse vless header type --- src/config_models/mod.rs | 7 ++++++- src/parser/vless/mod.rs | 20 ++++++++++++++++++-- 2 files changed, 24 insertions(+), 3 deletions(-) diff --git a/src/config_models/mod.rs b/src/config_models/mod.rs index 7353b25..95efe72 100644 --- a/src/config_models/mod.rs +++ b/src/config_models/mod.rs @@ -56,10 +56,15 @@ pub struct RealitySettings { pub spiderX: String, } +#[derive(Serialize, Deserialize)] +pub struct TCPHeader { + pub r#type: String, +} + #[allow(non_snake_case)] #[derive(Serialize, Deserialize)] pub struct TCPSettings { - pub header: Option, + pub header: Option, pub acceptProxyProtocol: Option, } diff --git a/src/parser/vless/mod.rs b/src/parser/vless/mod.rs index 95baf52..fa2a810 100644 --- a/src/parser/vless/mod.rs +++ b/src/parser/vless/mod.rs @@ -44,8 +44,8 @@ pub fn create_outbound_object(data: models::VlessData) -> Outbound { }, tcpSettings: if data.query.r#type == String::from("tcp") { Some(TCPSettings { - header: Some(NonHeaderObject { - r#type: String::from("none"), + header: Some(TCPHeader { + r#type: data.query.header_type.clone(), }), acceptProxyProtocol: None, }) @@ -174,6 +174,22 @@ fn get_parameter_value(query: &Vec<(&str, &str)>, param: &str) -> String { #[cfg(test)] mod tests { use super::*; + + #[test] + fn vless_tcp_header_test() { + let v = "vless://1010501a-ca9a-479c-84d0-1308d97789b5@104.21.25.109:443?security=reality&alpn=http%2F1.1&encryption=none&pbk=testpub&host=mehr14-n.gowow31220.workers.dev&headerType=http&fp=chrome&spx=spideex&type=tcp&flow=xtls-rprx-vision&sni=mehr14-iran-mehr14-iran-mehr14-iran-mehr14-iran-mehr14-iran.gowow31220.workers.dev&sid=testshort#%E2%AD%90%EF%B8%8F%20Telegram%20%3D%20%40z_v2ray"; + let data = create_outbound_object(get_vless_data(v)); + assert_eq!( + data.streamSettings + .tcpSettings + .unwrap() + .header + .unwrap() + .r#type, + "http" + ) + } + #[test] fn vless_test_2() { let v = "vless://2dc56709-sdfs-sdfs-2234-128904@nwarne.fast-ip.com:80/?type=ws&encryption=none&host=Shuposipet.com&path=%2Fde%3Fed%3D1048#[test]@test"; From cd0b282c6e1e50a4800965789bc3944841883b4f Mon Sep 17 00:00:00 2001 From: Keivan-sf Date: Sat, 26 Jul 2025 11:58:01 +0330 Subject: [PATCH 03/11] Parse alpn --- src/config_models/mod.rs | 1 + src/parser/vless/mod.rs | 15 +++++++++++++-- src/parser/vless/models.rs | 1 + 3 files changed, 15 insertions(+), 2 deletions(-) diff --git a/src/config_models/mod.rs b/src/config_models/mod.rs index 95efe72..0514567 100644 --- a/src/config_models/mod.rs +++ b/src/config_models/mod.rs @@ -85,6 +85,7 @@ pub struct WsSettings { #[allow(non_snake_case)] #[derive(Serialize, Deserialize)] pub struct TlsSettings { + pub alpn: Option>, pub allowInsecure: Option, pub serverName: Option, pub enableSessionResumption: Option, diff --git a/src/parser/vless/mod.rs b/src/parser/vless/mod.rs index fa2a810..daa40bb 100644 --- a/src/parser/vless/mod.rs +++ b/src/parser/vless/mod.rs @@ -13,6 +13,11 @@ pub fn create_outbound_object(data: models::VlessData) -> Outbound { security: data.query.security.clone(), tlsSettings: if data.query.security == String::from("tls") { Some(TlsSettings { + alpn: if data.query.alpn.len() > 1 { + Some(vec![data.query.alpn]) + } else { + None + }, rejectUnknownSni: None, enableSessionResumption: None, minVersion: None, @@ -140,7 +145,12 @@ fn parse_vless_query(raw_query: &str) -> models::VlessQuery { let query: Vec<(&str, &str)> = querystring::querify(raw_query); let a = models::VlessQuery { - path: get_parameter_value(&query, "path"), + 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(), pbk: get_parameter_value(&query, "pbk"), security: get_parameter_value(&query, "security"), sid: get_parameter_value(&query, "sid"), @@ -218,7 +228,7 @@ mod tests { #[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&path=/"; + 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"); @@ -230,6 +240,7 @@ mod tests { 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, ""); diff --git a/src/parser/vless/models.rs b/src/parser/vless/models.rs index 0a9205d..16a6e38 100644 --- a/src/parser/vless/models.rs +++ b/src/parser/vless/models.rs @@ -17,6 +17,7 @@ pub struct VlessQuery { pub service_name: String, pub slpn: String, pub spx: String, + pub alpn: String, } pub struct VlessAddress { From 5e594c115626af021f6cc13e95dc44b35aacec76 Mon Sep 17 00:00:00 2001 From: Keivan-sf Date: Sat, 26 Jul 2025 12:14:39 +0330 Subject: [PATCH 04/11] Use the new host field in websockets --- src/config_models/mod.rs | 2 +- src/parser/vless/mod.rs | 4 +--- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/src/config_models/mod.rs b/src/config_models/mod.rs index 0514567..98d95ff 100644 --- a/src/config_models/mod.rs +++ b/src/config_models/mod.rs @@ -78,7 +78,7 @@ pub struct HeaderSetting { #[derive(Serialize, Deserialize)] pub struct WsSettings { pub path: Option, - pub headers: Option, + pub Host: Option, pub acceptProxyProtocol: Option, } diff --git a/src/parser/vless/mod.rs b/src/parser/vless/mod.rs index daa40bb..bfe39fd 100644 --- a/src/parser/vless/mod.rs +++ b/src/parser/vless/mod.rs @@ -34,9 +34,7 @@ pub fn create_outbound_object(data: models::VlessData) -> Outbound { }, wsSettings: if data.query.r#type == String::from("ws") { Some(WsSettings { - headers: Some(HeaderSetting { - Host: Some(data.query.host), - }), + Host: Some(data.query.host), path: Some( urlencoding::decode(data.query.path.as_str()) .unwrap() From 0e813911a36e470aae7fabf3bd02b26fa3e8f61c Mon Sep 17 00:00:00 2001 From: Keivan-sf Date: Sat, 26 Jul 2025 12:21:12 +0330 Subject: [PATCH 05/11] Resolve tcp wrong header type --- src/parser/vless/mod.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/parser/vless/mod.rs b/src/parser/vless/mod.rs index bfe39fd..87a6080 100644 --- a/src/parser/vless/mod.rs +++ b/src/parser/vless/mod.rs @@ -48,7 +48,11 @@ pub fn create_outbound_object(data: models::VlessData) -> Outbound { tcpSettings: if data.query.r#type == String::from("tcp") { Some(TCPSettings { header: Some(TCPHeader { - r#type: data.query.header_type.clone(), + r#type: if data.query.header_type.len() > 1 { + data.query.header_type + } else { + String::from("none") + }, }), acceptProxyProtocol: None, }) From 4656489c4014482177cd3b3c4dfc2d1b21292641 Mon Sep 17 00:00:00 2001 From: Keivan-sf Date: Sat, 26 Jul 2025 12:30:32 +0330 Subject: [PATCH 06/11] Remove json test --- src/parser/vless/mod.rs | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/src/parser/vless/mod.rs b/src/parser/vless/mod.rs index 87a6080..ec00125 100644 --- a/src/parser/vless/mod.rs +++ b/src/parser/vless/mod.rs @@ -298,17 +298,4 @@ mod tests { assert_eq!(parsed.address, "[2a06:98c1:3120::1]"); assert_eq!(parsed.uuid, "uu0id"); } - - #[test] - fn create_outbound_for_tcp_reality() { - let v = "vless://3d2c2r05-y739-51e3-bd86-3f3f4950c183@tr.deet23ngdell.com:1818?security=reality&encryption=none&pbk=7xhH8b_VkliBxgulljcyPOH-bYoA2dl-XAdZAsfhk04&headerType=none&fp=chrome&type=tcp&flow=xtls-rprx-vision&sni=bench.sh&sid=6bt85979e30d4fc2#%F0%9F%87%B9%F0%9F%87%B7+H"; - let data = get_vless_data(v); - let outbound_object = create_outbound_object(data); - let serialized = serde_json::to_string(&outbound_object).unwrap(); - - assert_eq!( - serialized, - r#"{"settings":{"vnext":[{"address":"tr.deet23ngdell.com","port":1818,"users":[{"id":"3d2c2r05-y739-51e3-bd86-3f3f4950c183","encryption":"none","flow":"xtls-rprx-vision","level":0}]}]},"streamSettings":{"network":"tcp","security":"reality","tlsSettings":null,"wsSettings":null,"tcpSettings":{"header":{"type":"none"},"acceptProxyProtocol":null},"realitySettings":{"fingerprint":"chrome","serverName":"bench.sh","publicKey":"7xhH8b_VkliBxgulljcyPOH-bYoA2dl-XAdZAsfhk04","shortId":"6bt85979e30d4fc2","spiderX":""},"grpcSettings":null,"quicSettings":null},"protocol":"vless","tag":"proxy"}"# - ); - } } From 6f7b9ca06aa11abdab0eac76e176427babfc9e76 Mon Sep 17 00:00:00 2001 From: Keivan-sf Date: Sat, 26 Jul 2025 13:46:08 +0330 Subject: [PATCH 07/11] 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 { From 714e5afe7099aebf3791c24e36fa580985c6f0d4 Mon Sep 17 00:00:00 2001 From: Keivan-sf Date: Sat, 26 Jul 2025 16:05:38 +0330 Subject: [PATCH 08/11] Decode necessary query params #7 --- src/parser/vless/mod.rs | 44 +++++++++++++++++++---------------------- 1 file changed, 20 insertions(+), 24 deletions(-) diff --git a/src/parser/vless/mod.rs b/src/parser/vless/mod.rs index d017274..e9128bb 100644 --- a/src/parser/vless/mod.rs +++ b/src/parser/vless/mod.rs @@ -123,7 +123,7 @@ fn parse_vless_address(raw_data: &str) -> models::VlessAddress { let parsed = address_wo_slash.parse::().unwrap(); return models::VlessAddress { - uuid, + uuid: url_decode(Some(uuid)).unwrap(), address: parsed.host().unwrap().to_string(), port: parsed.port().unwrap().as_u16(), }; @@ -133,42 +133,38 @@ fn parse_vless_query(raw_query: &str) -> models::VlessQuery { let query: Vec<(&str, &str)> = querystring::querify(raw_query); let a = models::VlessQuery { - 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"), + alpn: url_decode(get_parameter_value(&query, "alpn")), + path: url_decode(get_parameter_value(&query, "path")), + authority: url_decode(get_parameter_value(&query, "authority")), + pbk: url_decode(get_parameter_value(&query, "pbk")), security: get_parameter_value(&query, "security"), - sid: get_parameter_value(&query, "sid"), + sid: url_decode(get_parameter_value(&query, "sid")), flow: get_parameter_value(&query, "flow"), sni: get_parameter_value(&query, "sni"), - fp: get_parameter_value(&query, "fp"), + fp: url_decode(get_parameter_value(&query, "fp")), r#type: get_parameter_value(&query, "type"), encryption: get_parameter_value(&query, "encryption"), header_type: get_parameter_value(&query, "headerType"), - host: get_parameter_value(&query, "host"), - seed: get_parameter_value(&query, "seed"), + host: url_decode(get_parameter_value(&query, "host")), + seed: url_decode(get_parameter_value(&query, "seed")), quic_security: get_parameter_value(&query, "quicSecurity"), key: get_parameter_value(&query, "key"), - mode: get_parameter_value(&query, "mode"), - service_name: get_parameter_value(&query, "serviceName"), + mode: url_decode(get_parameter_value(&query, "mode")), + service_name: url_decode(get_parameter_value(&query, "serviceName")), slpn: get_parameter_value(&query, "slpn"), - spx: get_parameter_value(&query, "spx"), + spx: url_decode(get_parameter_value(&query, "spx")), }; return a; } +fn url_decode(value: Option) -> Option { + return value.and_then(|s| { + urlencoding::decode(&s) + .ok() + .map(|decoded| decoded.into_owned()) + }); +} + fn get_parameter_value(query: &Vec<(&str, &str)>, param: &str) -> Option { return query .iter() From 763169e04b7e601631be63836ed36f696ce12c49 Mon Sep 17 00:00:00 2001 From: Keivan-sf Date: Sat, 26 Jul 2025 16:08:27 +0330 Subject: [PATCH 09/11] Support kcp stream --- src/config_models/mod.rs | 14 ++++++++++++++ src/parser/vless/mod.rs | 14 ++++++++++++++ 2 files changed, 28 insertions(+) diff --git a/src/config_models/mod.rs b/src/config_models/mod.rs index 71d05aa..7a4acae 100644 --- a/src/config_models/mod.rs +++ b/src/config_models/mod.rs @@ -47,6 +47,19 @@ pub struct GRPCSettings { pub serviceName: Option, } +#[allow(non_snake_case)] +#[derive(Serialize, Deserialize)] +pub struct KCPSettings { + pub mtu: Option, + pub tti: Option, + pub uplinkCapacity: Option, + pub downlinkCapacity: Option, + pub congestion: Option, + pub readBufferSize: Option, + pub writeBufferSize: Option, + pub seed: Option, +} + #[allow(non_snake_case)] #[derive(Serialize, Deserialize)] pub struct RealitySettings { @@ -110,6 +123,7 @@ pub struct StreamSettings { pub realitySettings: Option, pub grpcSettings: Option, pub quicSettings: Option, + pub kcpSettings: Option, } #[allow(non_snake_case)] diff --git a/src/parser/vless/mod.rs b/src/parser/vless/mod.rs index e9128bb..1e1355a 100644 --- a/src/parser/vless/mod.rs +++ b/src/parser/vless/mod.rs @@ -79,6 +79,20 @@ pub fn create_outbound_object(data: models::VlessData) -> Outbound { } else { None }, + kcpSettings: if network_type == String::from("kcp") { + Some(KCPSettings { + mtu: None, + tti: None, + congestion: None, + uplinkCapacity: None, + readBufferSize: None, + writeBufferSize: None, + downlinkCapacity: None, + seed: data.query.seed, + }) + } else { + None + }, }, settings: OutboundSettings::Vless(VlessOutboundSettings { vnext: vec![VlessServerObject { From ae36a180f79fcbd2e1922f6d014f376cc4f5983e Mon Sep 17 00:00:00 2001 From: Keivan-sf Date: Sat, 26 Jul 2025 16:32:53 +0330 Subject: [PATCH 10/11] Support xhttp --- src/config_models/mod.rs | 10 ++++++++++ src/parser/vless/mod.rs | 24 ++++++++++++++++++++++-- src/parser/vless/models.rs | 1 + 3 files changed, 33 insertions(+), 2 deletions(-) diff --git a/src/config_models/mod.rs b/src/config_models/mod.rs index 7a4acae..ce2ad9c 100644 --- a/src/config_models/mod.rs +++ b/src/config_models/mod.rs @@ -60,6 +60,15 @@ pub struct KCPSettings { pub seed: Option, } +#[allow(non_snake_case)] +#[derive(Serialize, Deserialize)] +pub struct XHTTPSettings { + pub host: Option, + pub path: Option, + pub mode: Option, + pub extra: Option, +} + #[allow(non_snake_case)] #[derive(Serialize, Deserialize)] pub struct RealitySettings { @@ -124,6 +133,7 @@ pub struct StreamSettings { pub grpcSettings: Option, pub quicSettings: Option, pub kcpSettings: Option, + pub xhttpSettings: Option, } #[allow(non_snake_case)] diff --git a/src/parser/vless/mod.rs b/src/parser/vless/mod.rs index 1e1355a..51daefa 100644 --- a/src/parser/vless/mod.rs +++ b/src/parser/vless/mod.rs @@ -31,8 +31,8 @@ pub fn create_outbound_object(data: models::VlessData) -> Outbound { }, wsSettings: if network_type == String::from("ws") { Some(WsSettings { - Host: data.query.host, - path: data.query.path, + Host: data.query.host.clone(), + path: data.query.path.clone(), acceptProxyProtocol: None, }) } else { @@ -93,6 +93,16 @@ pub fn create_outbound_object(data: models::VlessData) -> Outbound { } else { None }, + xhttpSettings: if network_type == String::from("xhttp") { + Some(XHTTPSettings { + host: data.query.host.clone(), + path: data.query.path.clone(), + mode: data.query.mode, + extra: data.query.extra.and_then(|e| parse_raw_json(e.as_str())), + }) + } else { + None + }, }, settings: OutboundSettings::Vless(VlessOutboundSettings { vnext: vec![VlessServerObject { @@ -167,6 +177,7 @@ fn parse_vless_query(raw_query: &str) -> models::VlessQuery { service_name: url_decode(get_parameter_value(&query, "serviceName")), slpn: get_parameter_value(&query, "slpn"), spx: url_decode(get_parameter_value(&query, "spx")), + extra: url_decode(get_parameter_value(&query, "extra")), }; return a; } @@ -179,6 +190,15 @@ fn url_decode(value: Option) -> Option { }); } +fn parse_raw_json(input: &str) -> Option { + serde_json::from_str::(input) + .ok() + .and_then(|v| match v { + serde_json::Value::Object(_) => Some(v), + _ => None, + }) +} + fn get_parameter_value(query: &Vec<(&str, &str)>, param: &str) -> Option { return query .iter() diff --git a/src/parser/vless/models.rs b/src/parser/vless/models.rs index 767cd3b..c287a3f 100644 --- a/src/parser/vless/models.rs +++ b/src/parser/vless/models.rs @@ -19,6 +19,7 @@ pub struct VlessQuery { pub slpn: Option, pub spx: Option, pub alpn: Option, + pub extra: Option, } pub struct VlessAddress { From d56482a5c1ffe61d50f9cb11bca551e000d84cf6 Mon Sep 17 00:00:00 2001 From: Keivan-sf Date: Sat, 26 Jul 2025 16:49:47 +0330 Subject: [PATCH 11/11] Move utils to different modules --- src/parser/mod.rs | 2 +- src/parser/vless/data.rs | 183 ++++++++++++++++++++++++++++++++++ src/parser/vless/mod.rs | 209 +-------------------------------------- src/utils/mod.rs | 24 +++++ 4 files changed, 210 insertions(+), 208 deletions(-) create mode 100644 src/parser/vless/data.rs diff --git a/src/parser/mod.rs b/src/parser/mod.rs index 07a61fa..d4fb81d 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -28,7 +28,7 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound { let protocol = uri_identifier::get_uri_protocol(uri); match protocol { Some(uri_identifier::Protocols::Vless) => { - let vless_data = vless::get_vless_data(uri); + let vless_data = vless::data::get_data(uri); let outbound_object = vless::create_outbound_object(vless_data); return outbound_object; } diff --git a/src/parser/vless/data.rs b/src/parser/vless/data.rs new file mode 100644 index 0000000..bd03a36 --- /dev/null +++ b/src/parser/vless/data.rs @@ -0,0 +1,183 @@ +use crate::parser::vless::models; +use crate::utils::{get_parameter_value, url_decode}; +use http::Uri; + +pub fn get_data(uri: &str) -> models::VlessData { + let data = uri.split_once("vless://").unwrap().1; + let query_and_name = uri.split_once("?").unwrap().1; + let query = query_and_name + .split_once("#") + .unwrap_or((query_and_name, "")) + .0; + let parsed_query = parse_vless_query(query); + let parsed_address = parse_vless_address(data.split_once("?").unwrap().0); + return models::VlessData { + query: parsed_query, + address_data: parsed_address, + }; +} + +fn parse_vless_address(raw_data: &str) -> models::VlessAddress { + let (uuid, raw_address): (String, &str) = match raw_data.split_once("@") { + None => { + panic!("Wrong vless format, no `@` found in the address"); + } + Some(data) => (String::from(data.0), data.1), + }; + let address_wo_slash = raw_address.strip_suffix("/").unwrap_or(raw_address); + + let parsed = address_wo_slash.parse::().unwrap(); + + return models::VlessAddress { + uuid: url_decode(Some(uuid)).unwrap(), + address: parsed.host().unwrap().to_string(), + port: parsed.port().unwrap().as_u16(), + }; +} + +fn parse_vless_query(raw_query: &str) -> models::VlessQuery { + let query: Vec<(&str, &str)> = querystring::querify(raw_query); + + let a = models::VlessQuery { + alpn: url_decode(get_parameter_value(&query, "alpn")), + path: url_decode(get_parameter_value(&query, "path")), + authority: url_decode(get_parameter_value(&query, "authority")), + pbk: url_decode(get_parameter_value(&query, "pbk")), + security: get_parameter_value(&query, "security"), + sid: url_decode(get_parameter_value(&query, "sid")), + flow: get_parameter_value(&query, "flow"), + sni: get_parameter_value(&query, "sni"), + fp: url_decode(get_parameter_value(&query, "fp")), + r#type: get_parameter_value(&query, "type"), + encryption: get_parameter_value(&query, "encryption"), + header_type: get_parameter_value(&query, "headerType"), + host: url_decode(get_parameter_value(&query, "host")), + seed: url_decode(get_parameter_value(&query, "seed")), + quic_security: get_parameter_value(&query, "quicSecurity"), + key: get_parameter_value(&query, "key"), + mode: url_decode(get_parameter_value(&query, "mode")), + service_name: url_decode(get_parameter_value(&query, "serviceName")), + slpn: get_parameter_value(&query, "slpn"), + spx: url_decode(get_parameter_value(&query, "spx")), + extra: url_decode(get_parameter_value(&query, "extra")), + }; + return a; +} + +#[cfg(test)] +mod tests { + use crate::parser::vless::create_outbound_object; + + use super::*; + + #[test] + fn vless_tcp_header_test() { + let v = "vless://1010501a-ca9a-479c-84d0-1308d97789b5@104.21.25.109:443?security=reality&alpn=http%2F1.1&encryption=none&pbk=testpub&host=mehr14-n.gowow31220.workers.dev&headerType=http&fp=chrome&spx=spideex&type=tcp&flow=xtls-rprx-vision&sni=mehr14-iran-mehr14-iran-mehr14-iran-mehr14-iran-mehr14-iran.gowow31220.workers.dev&sid=testshort#%E2%AD%90%EF%B8%8F%20Telegram%20%3D%20%40z_v2ray"; + let data = create_outbound_object(get_data(v)); + assert_eq!( + data.streamSettings + .tcpSettings + .unwrap() + .header + .unwrap() + .r#type, + Some(String::from("http")) + ) + } + + #[test] + fn vless_test_2() { + let v = "vless://2dc56709-sdfs-sdfs-2234-128904@nwarne.fast-ip.com:80/?type=ws&encryption=none&host=Shuposipet.com&path=%2Fde%3Fed%3D1048#[test]@test"; + let data = get_data(v); + 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.unwrap(), "none"); + assert_eq!(data.query.r#type.unwrap(), "ws"); + } + + #[test] + fn vless_test() { + let v = "vless://4d2c3e35-749d-52e3-bdb6-3f3f4950c183@tre.test.one:2053?security=reality&type=tcp&flow=xtls-rprx-vision#test-name"; + let data = get_data(v); + assert_eq!(data.address_data.address, "tre.test.one"); + assert_eq!( + data.address_data.uuid, + "4d2c3e35-749d-52e3-bdb6-3f3f4950c183" + ); + assert_eq!(data.address_data.port, 2053); + 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.unwrap(), "bench.sh"); + assert_eq!(parsed_query.security.unwrap(), "reality"); + assert_eq!(parsed_query.fp.unwrap(), "chrome"); + assert_eq!( + parsed_query.pbk.unwrap(), + "7xhH4b_VkliBxGulljcyPOH-bYUA2dl-XAdZAsfhk04" + ); + 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, 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] + fn parse_vless_host() { + let raw_host = "uu0id@127.0.0.1:3012"; + let parsed = parse_vless_address(raw_host); + assert_eq!(parsed.address, "127.0.0.1"); + assert_eq!(parsed.port, 3012); + assert_eq!(parsed.uuid, "uu0id"); + } + + #[test] + fn parse_vless_ipv6_host() { + let raw_host = "uu0id@[2a06:98c1:3120::1]:443"; + let parsed = parse_vless_address(raw_host); + assert_eq!(parsed.port, 443); + assert_eq!(parsed.address, "[2a06:98c1:3120::1]"); + assert_eq!(parsed.uuid, "uu0id"); + } +} diff --git a/src/parser/vless/mod.rs b/src/parser/vless/mod.rs index 51daefa..1ac1b00 100644 --- a/src/parser/vless/mod.rs +++ b/src/parser/vless/mod.rs @@ -1,8 +1,6 @@ -use querystring; +pub mod data; mod models; -use crate::config_models::*; -use http::Uri; -use std::process::exit; +use crate::{config_models::*, utils::parse_raw_json}; pub fn create_outbound_object(data: models::VlessData) -> Outbound { let network_type = data.query.r#type.clone().unwrap_or(String::from("")); @@ -118,206 +116,3 @@ pub fn create_outbound_object(data: models::VlessData) -> Outbound { }), }; } - -pub fn get_vless_data(uri: &str) -> models::VlessData { - let data = uri.split_once("vless://").unwrap().1; - let query_and_name = uri.split_once("?").unwrap().1; - let query = query_and_name - .split_once("#") - .unwrap_or((query_and_name, "")) - .0; - let parsed_query = parse_vless_query(query); - let parsed_address = parse_vless_address(data.split_once("?").unwrap().0); - return models::VlessData { - query: parsed_query, - address_data: parsed_address, - }; -} - -fn parse_vless_address(raw_data: &str) -> models::VlessAddress { - let (uuid, raw_address): (String, &str) = match raw_data.split_once("@") { - None => { - println!("Wrong vless format, no `@` found in the address"); - exit(0); - } - Some(data) => (String::from(data.0), data.1), - }; - let address_wo_slash = raw_address.strip_suffix("/").unwrap_or(raw_address); - - let parsed = address_wo_slash.parse::().unwrap(); - - return models::VlessAddress { - uuid: url_decode(Some(uuid)).unwrap(), - address: parsed.host().unwrap().to_string(), - port: parsed.port().unwrap().as_u16(), - }; -} - -fn parse_vless_query(raw_query: &str) -> models::VlessQuery { - let query: Vec<(&str, &str)> = querystring::querify(raw_query); - - let a = models::VlessQuery { - alpn: url_decode(get_parameter_value(&query, "alpn")), - path: url_decode(get_parameter_value(&query, "path")), - authority: url_decode(get_parameter_value(&query, "authority")), - pbk: url_decode(get_parameter_value(&query, "pbk")), - security: get_parameter_value(&query, "security"), - sid: url_decode(get_parameter_value(&query, "sid")), - flow: get_parameter_value(&query, "flow"), - sni: get_parameter_value(&query, "sni"), - fp: url_decode(get_parameter_value(&query, "fp")), - r#type: get_parameter_value(&query, "type"), - encryption: get_parameter_value(&query, "encryption"), - header_type: get_parameter_value(&query, "headerType"), - host: url_decode(get_parameter_value(&query, "host")), - seed: url_decode(get_parameter_value(&query, "seed")), - quic_security: get_parameter_value(&query, "quicSecurity"), - key: get_parameter_value(&query, "key"), - mode: url_decode(get_parameter_value(&query, "mode")), - service_name: url_decode(get_parameter_value(&query, "serviceName")), - slpn: get_parameter_value(&query, "slpn"), - spx: url_decode(get_parameter_value(&query, "spx")), - extra: url_decode(get_parameter_value(&query, "extra")), - }; - return a; -} - -fn url_decode(value: Option) -> Option { - return value.and_then(|s| { - urlencoding::decode(&s) - .ok() - .map(|decoded| decoded.into_owned()) - }); -} - -fn parse_raw_json(input: &str) -> Option { - serde_json::from_str::(input) - .ok() - .and_then(|v| match v { - serde_json::Value::Object(_) => Some(v), - _ => None, - }) -} - -fn get_parameter_value(query: &Vec<(&str, &str)>, param: &str) -> Option { - return query - .iter() - .find(|q| String::from(q.0) == String::from(param)) - .map(|q| q.1.to_string()); -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn vless_tcp_header_test() { - let v = "vless://1010501a-ca9a-479c-84d0-1308d97789b5@104.21.25.109:443?security=reality&alpn=http%2F1.1&encryption=none&pbk=testpub&host=mehr14-n.gowow31220.workers.dev&headerType=http&fp=chrome&spx=spideex&type=tcp&flow=xtls-rprx-vision&sni=mehr14-iran-mehr14-iran-mehr14-iran-mehr14-iran-mehr14-iran.gowow31220.workers.dev&sid=testshort#%E2%AD%90%EF%B8%8F%20Telegram%20%3D%20%40z_v2ray"; - let data = create_outbound_object(get_vless_data(v)); - assert_eq!( - data.streamSettings - .tcpSettings - .unwrap() - .header - .unwrap() - .r#type, - Some(String::from("http")) - ) - } - - #[test] - fn vless_test_2() { - let v = "vless://2dc56709-sdfs-sdfs-2234-128904@nwarne.fast-ip.com:80/?type=ws&encryption=none&host=Shuposipet.com&path=%2Fde%3Fed%3D1048#[test]@test"; - let data = get_vless_data(v); - 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.unwrap(), "none"); - assert_eq!(data.query.r#type.unwrap(), "ws"); - } - - #[test] - fn vless_test() { - let v = "vless://4d2c3e35-749d-52e3-bdb6-3f3f4950c183@tre.test.one:2053?security=reality&type=tcp&flow=xtls-rprx-vision#test-name"; - let data = get_vless_data(v); - assert_eq!(data.address_data.address, "tre.test.one"); - assert_eq!( - data.address_data.uuid, - "4d2c3e35-749d-52e3-bdb6-3f3f4950c183" - ); - assert_eq!(data.address_data.port, 2053); - 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.unwrap(), "bench.sh"); - assert_eq!(parsed_query.security.unwrap(), "reality"); - assert_eq!(parsed_query.fp.unwrap(), "chrome"); - assert_eq!( - parsed_query.pbk.unwrap(), - "7xhH4b_VkliBxGulljcyPOH-bYUA2dl-XAdZAsfhk04" - ); - 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, 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] - fn parse_vless_host() { - let raw_host = "uu0id@127.0.0.1:3012"; - let parsed = parse_vless_address(raw_host); - assert_eq!(parsed.address, "127.0.0.1"); - assert_eq!(parsed.port, 3012); - assert_eq!(parsed.uuid, "uu0id"); - } - - #[test] - fn parse_vless_ipv6_host() { - let raw_host = "uu0id@[2a06:98c1:3120::1]:443"; - let parsed = parse_vless_address(raw_host); - assert_eq!(parsed.port, 443); - assert_eq!(parsed.address, "[2a06:98c1:3120::1]"); - assert_eq!(parsed.uuid, "uu0id"); - } -} diff --git a/src/utils/mod.rs b/src/utils/mod.rs index 62e230a..e40bd46 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -1 +1,25 @@ pub mod inbound_generator; + +pub fn url_decode(value: Option) -> Option { + return value.and_then(|s| { + urlencoding::decode(&s) + .ok() + .map(|decoded| decoded.into_owned()) + }); +} + +pub fn parse_raw_json(input: &str) -> Option { + serde_json::from_str::(input) + .ok() + .and_then(|v| match v { + serde_json::Value::Object(_) => Some(v), + _ => None, + }) +} + +pub fn get_parameter_value(query: &Vec<(&str, &str)>, param: &str) -> Option { + return query + .iter() + .find(|q| String::from(q.0) == String::from(param)) + .map(|q| q.1.to_string()); +}