shkong/clash-verge-rev
1
0
Fork 0
mirror of https://github.com/clash-verge-rev/clash-verge-rev synced 2025-05-05 06:23:44 +08:00
Code Packages Projects Releases Activity

chore: Improve URI parser

Browse Source
This commit is contained in:
MystiPanda 2024-07-05 22:44:05 +08:00
parent 5a1edc5ffb
commit ec6c2adf9b
No known key found for this signature in database
2 changed files with 459 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

470
src/services/types.d.ts vendored
View File

@ -228,8 +228,373 @@ interface IProxyGroupConfig {
icon?: string; icon?: string;
} }
interface IProxyConfig { interface WsOptions {
name: string; path?: string;
headers?: {
[key: string]: string;
};
"max-early-data"?: number;
"early-data-header-name"?: string;
"v2ray-http-upgrade"?: boolean;
"v2ray-http-upgrade-fast-open"?: boolean;
}
interface HttpOptions {
method?: string;
path?: string[];
headers?: {
[key: string]: string;
};
}
interface GrpcOptions {
"grpc-service-name"?: string;
}
type NetworkType = "ws" | "http" | "h2" | "grpc";
// base
interface IProxyBaseConfig {
tfo?: boolean;
mptcp?: boolean;
"interface-name"?: string;
"routing-mark"?: number;
"ip-version"?: string;
"dialer-proxy"?: string;
}
// direct
interface IProxyDirectConfig extends IProxyBaseConfig {
name?: string;
type: "direct";
}
// dns
interface IProxyDnsConfig extends IProxyBaseConfig {
name?: string;
type: "dns";
}
// http
interface IProxyHttpConfig extends IProxyBaseConfig {
name?: string;
type: "http";
server?: string;
port?: number;
username?: string;
password?: string;
tls?: boolean;
sni?: string;
"skip-cert-verify"?: boolean;
fingerprint?: string;
headers?: {};
}
// socks5
interface IProxySocks5Config extends IProxyBaseConfig {
name?: string;
type: "socks5";
server?: string;
port?: number;
username?: string;
password?: string;
tls?: boolean;
udp?: boolean;
"skip-cert-verify"?: boolean;
fingerprint?: string;
}
// ssh
interface IProxySshConfig extends IProxyBaseConfig {
name?: string;
type: "ssh";
server?: string;
port?: number;
username?: string;
password?: string;
"private-key"?: string;
"private-key-passphrase"?: string;
"host-key"?: string;
"host-key-algorithms"?: string;
}
// trojan
interface IProxyTrojanConfig extends IProxyBaseConfig {
name?: string;
type: "trojan";
server?: string;
port?: number;
password?: string;
alpn?: string[];
sni?: string;
"skip-cert-verify"?: boolean;
fingerprint?: string;
udp?: boolean;
network?: NetworkType;
"reality-opts"?: {};
"grpc-opts"?: GrpcOptions;
"ws-opts"?: WsOptions;
"ss-opts"?: {
enabled?: boolean;
method?: string;
password?: string;
};
"client-fingerprint"?: string;
}
// tuic
interface IProxyTuicConfig extends IProxyBaseConfig {
name?: string;
type: "tuic";
server?: string;
port?: number;
token?: string;
uuid?: string;
password?: string;
ip?: string;
"heartbeat-interval"?: number;
alpn?: string[];
"reduce-rtt"?: boolean;
"request-timeout"?: number;
"udp-relay-mode"?: string;
"congestion-controller"?: string;
"disable-sni"?: boolean;
"max-udp-relay-packet-size"?: number;
"fast-open"?: boolean;
"max-open-streams"?: number;
cwnd?: number;
"skip-cert-verify"?: boolean;
fingerprint?: string;
ca?: string;
"ca-str"?: string;
"recv-window-conn"?: number;
"recv-window"?: number;
"disable-mtu-discovery"?: boolean;
"max-datagram-frame-size"?: number;
sni?: string;
"udp-over-stream"?: boolean;
"udp-over-stream-version"?: number;
}
// vless
interface IProxyVlessConfig extends IProxyBaseConfig {
name?: string;
type: "vless";
server?: string;
port?: number;
uuid?: string;
flow?: string;
tls?: boolean;
alpn?: string[];
udp?: boolean;
"packet-addr"?: boolean;
xudp?: boolean;
"packet-encoding"?: string;
network?: NetworkType;
"reality-opts"?: {
"public-key"?: string;
"short-id"?: string;
};
"http-opts"?: HttpOptions;
"h2-opts"?: {};
"grpc-opts"?: GrpcOptions;
"ws-opts"?: WsOptions;
"ws-path"?: string;
"ws-headers"?: {};
"skip-cert-verify"?: boolean;
fingerprint?: string;
servername?: string;
"client-fingerprint"?: string;
}
// vmess
interface IProxyVmessConfig extends IProxyBaseConfig {
name?: string;
type: "vmess";
server?: string;
port?: number;
uuid?: string;
alterId?: number;
cipher?: string;
udp?: boolean;
network?: NetworkType;
tls?: boolean;
alpn?: string[];
"skip-cert-verify"?: boolean;
fingerprint?: string;
servername?: string;
"reality-opts"?: {};
"http-opts"?: HttpOptions;
"h2-opts"?: {
path?: string;
host?: string;
};
"grpc-opts"?: GrpcOptions;
"ws-opts"?: WsOptions;
"packet-addr"?: boolean;
xudp?: boolean;
"packet-encoding"?: string;
"global-padding"?: boolean;
"authenticated-length"?: boolean;
"client-fingerprint"?: string;
}
interface WireGuardPeerOptions {
server?: string;
port?: number;
"public-key"?: string;
"pre-shared-key"?: string;
reserved?: number[];
"allowed-ips"?: string[];
}
// wireguard
interface IProxyWireguardConfig extends IProxyBaseConfig, WireGuardPeerOptions {
name?: string;
type: "wireguard";
ip?: string;
ipv6?: string;
"private-key"?: string;
workers?: number;
mtu?: number;
udp?: boolean;
"persistent-keepalive"?: number;
peers?: WireGuardPeerOptions[];
"remote-dns-resolve"?: boolean;
dns?: string[];
"refresh-server-ip-interval"?: number;
}
// hysteria
interface IProxyHysteriaConfig extends IProxyBaseConfig {
name?: string;
type: "hysteria";
server?: string;
port?: number;
ports?: string;
protocol?: string;
"obfs-protocol"?: string;
up?: string;
"up-speed"?: number;
down?: string;
"down-speed"?: number;
auth?: string;
"auth-str"?: string;
obfs?: string;
sni?: string;
"skip-cert-verify"?: boolean;
fingerprint?: string;
alpn?: string[];
ca?: string;
"ca-str"?: string;
"recv-window-conn"?: number;
"recv-window"?: number;
"disable-mtu-discovery"?: boolean;
"fast-open"?: boolean;
"hop-interval"?: number;
}
// hysteria2
interface IProxyHysteria2Config extends IProxyBaseConfig {
name?: string;
type: "hysteria2";
server?: string;
port?: number;
ports?: string;
"hop-interval"?: number;
protocol?: string;
"obfs-protocol"?: string;
up?: string;
down?: string;
password?: string;
obfs?: string;
"obfs-password"?: string;
sni?: string;
"skip-cert-verify"?: boolean;
fingerprint?: string;
alpn?: string[];
ca?: string;
"ca-str"?: string;
cwnd?: number;
"udp-mtu"?: number;
}
// shadowsocks
interface IProxyShadowsocksConfig extends IProxyBaseConfig {
name?: string;
type: "ss";
server?: string;
port?: number;
password?: string;
cipher?: string;
udp?: boolean;
plugin?: string;
"plugin-opts"?: {
mode?: string;
host?: string;
password?: string;
path?: string;
tls?: string;
fingerprint?: string;
headers?: {};
"skip-cert-verify"?: boolean;
version?: number;
mux?: boolean;
"v2ray-http-upgrade"?: boolean;
"v2ray-http-upgrade-fast-open"?: boolean;
"version-hint"?: string;
"restls-script"?: string;
};
"udp-over-tcp"?: boolean;
"udp-over-tcp-version"?: number;
"client-fingerprint"?: string;
}
// shadowsocksR
interface IProxyshadowsocksRConfig extends IProxyBaseConfig {
name?: string;
type: "ssr";
server?: string;
port?: number;
password?: string;
cipher?: string;
obfs?: string;
"obfs-param"?: string;
protocol?: string;
"protocol-param"?: string;
udp?: boolean;
}
// sing-mux
interface IProxySmuxConfig {
smux?: {
enabled?: boolean;
protocol?: string;
"max-connections"?: number;
"min-streams"?: number;
"max-streams"?: number;
padding?: boolean;
statistic?: boolean;
"only-tcp"?: boolean;
"brutal-opts"?: {
enabled?: boolean;
up?: string;
down?: string;
};
};
}
// snell
interface IProxySnellConfig extends IProxyBaseConfig {
name?: string;
type: "snell";
server?: string;
port?: number;
psk?: string;
udp?: boolean;
version?: number;
"obfs-opts"?: {};
}
interface IProxyConfig
extends IProxyBaseConfig,
IProxyDirectConfig,
IProxyDnsConfig,
IProxyHttpConfig,
IProxySocks5Config,
IProxySshConfig,
IProxyTrojanConfig,
IProxyTuicConfig,
IProxyVlessConfig,
IProxyVmessConfig,
IProxyWireguardConfig,
IProxyHysteriaConfig,
IProxyHysteria2Config,
IProxyShadowsocksConfig,
IProxyshadowsocksRConfig,
IProxySmuxConfig,
IProxySnellConfig {
type: type:
| "ss" | "ss"
| "ssr" | "ssr"
@ -246,107 +611,6 @@ interface IProxyConfig {
| "socks5" | "socks5"
| "vmess" | "vmess"
| "vless"; | "vless";
server: string;
port: number;
"ip-version"?: string;
udp?: boolean;
"interface-name"?: string;
"routing-mark"?: number;
tfo?: boolean;
mptcp?: boolean;
"dialer-proxy"?: string;
plugin?: "obfs" | "v2ray-plugin" | "shadow-tls" | "restls";
"plugin-opts"?: {
mode?: string;
host?: string;
path?: string;
tls?: string;
};
cipher?: string;
password?: string;
"udp-over-tcp"?: boolean;
protocol?: string;
obfs?: string;
"protocol-param"?: string;
"obfs-param"?: string;
uuid?: string;
tls?: boolean;
"skip-cert-verify"?: boolean;
network?: "ws" | "http" | "h2" | "grpc";
"ws-opts"?: {
path?: string;
headers?: {};
};
alterId?: number;
sni?: string;
"http-opts"?: {};
"grpc-opts"?: {};
"ws-opts"?: {};
"h2-opts"?: {};
"reality-opts"?: {
"public-key"?: string;
"short-id"?: string;
};
flow?: "xtls-rprx-vision";
"client-fingerprint"?:
| "chrome"
| "firefox"
| "safari"
| "iOS"
| "android"
| "edge"
| "360"
| "qq"
| "random";
alpn?: string[];
ws?: {
headers?: {
Host?: string;
};
"ws-service-name"?: string;
path?: string;
};
http?: {
headers?: {
Host?: string;
};
"http-service-name"?: string;
path?: string;
};
grpc?: {};
ports?: string;
"obfs-password"?: string;
"tls-fingerprint"?: string;
"auth-str"?: string;
up?: string;
down?: string;
"fast-open"?: boolean;
fingerprint?: string;
"disable-mtu-discovery"?: boolean;
ca?: string;
"ca-str"?: string;
"recv-window-conn"?: number;
"recv-window"?: number;
token?: string;
ip?: string;
"heartbeat-interval"?: number;
"disable-sni"?: boolean;
"reduce-rtt"?: boolean;
"request-timeout"?: number;
"udp-relay-mode"?: string;
"congestion-controller"?: string;
"max-udp-relay-packet-size"?: number;
"max-open-streams"?: number;
"private-key"?: string;
"public-key"?: string;
ipv6?: string;
reserved?: number[];
mtu?: number;
"remote-dns-resolve"?: boolean;
"allowed-ips"?: string[];
dns?: string[];
"pre-shared-key"?: string;
username?: string;
} }
interface IVergeConfig { interface IVergeConfig {

183
src/utils/uri-parser.ts
View File

@ -51,6 +51,10 @@ function isPresent(value: any): boolean {
return value !== null && value !== undefined; return value !== null && value !== undefined;
} }
function trimStr(str: string | undefined): string | undefined {
return str ? str.trim() : str;
}
function isNotBlank(name: string) { function isNotBlank(name: string) {
return name.trim().length !== 0; return name.trim().length !== 0;
} }
@ -76,12 +80,12 @@ function decodeBase64OrOriginal(str: string): string {
} }
} }
function URI_SS(line: string): IProxyConfig { function URI_SS(line: string): IProxyShadowsocksConfig {
// parse url // parse url
let content = line.split("ss://")[1]; let content = line.split("ss://")[1];
const proxy: IProxyConfig = { const proxy: IProxyShadowsocksConfig = {
name: decodeURIComponent(line.split("#")[1]), name: trimStr(decodeURIComponent(line.split("#")[1])),
type: "ss", type: "ss",
server: "", server: "",
port: 0, port: 0,
@ -168,7 +172,7 @@ function URI_SS(line: string): IProxyConfig {
return proxy; return proxy;
} }
function URI_SSR(line: string): IProxyConfig { function URI_SSR(line: string): IProxyshadowsocksRConfig {
line = decodeBase64OrOriginal(line.split("ssr://")[1]); line = decodeBase64OrOriginal(line.split("ssr://")[1]);
// handle IPV6 & IPV4 format // handle IPV6 & IPV4 format
@ -186,8 +190,8 @@ function URI_SSR(line: string): IProxyConfig {
.substring(splitIdx + 1) .substring(splitIdx + 1)
.split("/?")[0] .split("/?")[0]
.split(":"); .split(":");
let proxy: IProxyConfig = { let proxy: IProxyshadowsocksRConfig = {
name: "", name: "SSR",
type: "ssr", type: "ssr",
server, server,
port, port,
@ -210,7 +214,7 @@ function URI_SSR(line: string): IProxyConfig {
proxy = { proxy = {
...proxy, ...proxy,
name: other_params.remarks name: other_params.remarks
? decodeBase64OrOriginal(other_params.remarks) ? trimStr(decodeBase64OrOriginal(other_params.remarks))
: proxy.server, : proxy.server,
"protocol-param": getIfNotBlank( "protocol-param": getIfNotBlank(
decodeBase64OrOriginal(other_params.protoparam || "").replace(/\s/g, "") decodeBase64OrOriginal(other_params.protoparam || "").replace(/\s/g, "")
@ -222,7 +226,7 @@ function URI_SSR(line: string): IProxyConfig {
return proxy; return proxy;
} }
function URI_VMESS(line: string): IProxyConfig { function URI_VMESS(line: string): IProxyVmessConfig {
line = line.split("vmess://")[1]; line = line.split("vmess://")[1];
let content = decodeBase64OrOriginal(line); let content = decodeBase64OrOriginal(line);
console.log(content); console.log(content);
@ -238,8 +242,8 @@ function URI_VMESS(line: string): IProxyConfig {
} }
} }
const proxy: IProxyConfig = { const proxy: IProxyVmessConfig = {
name: partitions[0].split("=")[0].trim(), name: trimStr(partitions[0].split("=")[0]),
type: "vmess", type: "vmess",
server: partitions[1], server: partitions[1],
port: parseInt(partitions[2], 10), port: parseInt(partitions[2], 10),
@ -308,29 +312,30 @@ function URI_VMESS(line: string): IProxyConfig {
} }
} }
} }
console.log(params);
const server = params.add; const server = params.add;
const port = parseInt(getIfPresent(params.port), 10); const port = parseInt(getIfPresent(params.port), 10);
const proxy: IProxyConfig = { const proxy: IProxyVmessConfig = {
name: name:
params.ps ?? trimStr(params.ps) ??
params.remarks ?? trimStr(params.remarks) ??
params.remark ?? trimStr(params.remark) ??
`VMess ${server}:${port}`, `VMess ${server}:${port}`,
type: "vmess", type: "vmess",
server, server,
port, port,
cipher: getIfPresent(params.scy, "auto"), cipher: getIfPresent(params.scy, "auto"),
uuid: params.id, uuid: params.id,
alterId: parseInt(getIfPresent(params.aid ?? params.alterId, 0), 10),
tls: ["tls", true, 1, "1"].includes(params.tls), tls: ["tls", true, 1, "1"].includes(params.tls),
"skip-cert-verify": isPresent(params.verify_cert) "skip-cert-verify": isPresent(params.verify_cert)
? !params.verify_cert ? !params.verify_cert
: undefined, : undefined,
}; };
proxy.alterId = parseInt(getIfPresent(params.aid ?? params.alterId, 0), 10);
if (proxy.tls && params.sni) { if (proxy.tls && params.sni) {
proxy.sni = params.sni; proxy.servername = params.sni;
} }
let httpupgrade = false; let httpupgrade = false;
@ -383,7 +388,6 @@ function URI_VMESS(line: string): IProxyConfig {
if (["grpc"].includes(proxy.network)) { if (["grpc"].includes(proxy.network)) {
proxy[`grpc-opts`] = { proxy[`grpc-opts`] = {
"grpc-service-name": getIfNotBlank(transportPath), "grpc-service-name": getIfNotBlank(transportPath),
"_grpc-type": getIfNotBlank(params.type),
}; };
} else { } else {
const opts: Record<string, any> = { const opts: Record<string, any> = {
@ -400,8 +404,8 @@ function URI_VMESS(line: string): IProxyConfig {
delete proxy.network; delete proxy.network;
} }
if (proxy.tls && !proxy.sni && transportHost) { if (proxy.tls && !proxy.servername && transportHost) {
proxy.sni = transportHost; proxy.servername = transportHost;
} }
} }
@ -409,7 +413,7 @@ function URI_VMESS(line: string): IProxyConfig {
} }
} }
function URI_VLESS(line: string): IProxyConfig { function URI_VLESS(line: string): IProxyVlessConfig {
line = line.split("vless://")[1]; line = line.split("vless://")[1];
let isShadowrocket; let isShadowrocket;
let parsed = /^(.*?)@(.*?):(\d+)\/?(\?(.*?))?(?:#(.*?))?$/.exec(line)!; let parsed = /^(.*?)@(.*?):(\d+)\/?(\?(.*?))?(?:#(.*?))?$/.exec(line)!;
@ -428,9 +432,9 @@ function URI_VLESS(line: string): IProxyConfig {
uuid = decodeURIComponent(uuid); uuid = decodeURIComponent(uuid);
name = decodeURIComponent(name); name = decodeURIComponent(name);
const proxy: IProxyConfig = { const proxy: IProxyVlessConfig = {
type: "vless", type: "vless",
name, name: "",
server, server,
port, port,
uuid, uuid,
@ -444,14 +448,17 @@ function URI_VLESS(line: string): IProxyConfig {
} }
proxy.name = proxy.name =
name ?? params.remarks ?? params.remark ?? `VLESS ${server}:${port}`; trimStr(name) ??
trimStr(params.remarks) ??
trimStr(params.remark) ??
`VLESS ${server}:${port}`;
proxy.tls = (params.security && params.security !== "none") || undefined; proxy.tls = (params.security && params.security !== "none") || undefined;
if (isShadowrocket && /TRUE|1/i.test(params.tls)) { if (isShadowrocket && /TRUE|1/i.test(params.tls)) {
proxy.tls = true; proxy.tls = true;
params.security = params.security ?? "reality"; params.security = params.security ?? "reality";
} }
proxy.sni = params.sni || params.peer; proxy.servername = params.sni || params.peer;
proxy.flow = params.flow ? "xtls-rprx-vision" : undefined; proxy.flow = params.flow ? "xtls-rprx-vision" : undefined;
proxy["client-fingerprint"] = params.fp as proxy["client-fingerprint"] = params.fp as
@ -468,7 +475,7 @@ function URI_VLESS(line: string): IProxyConfig {
proxy["skip-cert-verify"] = /(TRUE)|1/i.test(params.allowInsecure); proxy["skip-cert-verify"] = /(TRUE)|1/i.test(params.allowInsecure);
if (["reality"].includes(params.security)) { if (["reality"].includes(params.security)) {
const opts: IProxyConfig["reality-opts"] = {}; const opts: IProxyVlessConfig["reality-opts"] = {};
if (params.pbk) { if (params.pbk) {
opts["public-key"] = params.pbk; opts["public-key"] = params.pbk;
} }
@ -481,18 +488,17 @@ function URI_VLESS(line: string): IProxyConfig {
} }
let httpupgrade = false; let httpupgrade = false;
proxy.ws = { proxy["ws-opts"] = {
headers: undefined, headers: undefined,
"ws-service-name": undefined,
path: undefined, path: undefined,
}; };
proxy.http = {
proxy["http-opts"] = {
headers: undefined, headers: undefined,
"http-service-name": undefined,
path: undefined, path: undefined,
}; };
proxy.grpc = { "_grpc-type": undefined }; proxy["grpc-opts"] = {};
proxy.network = params.type as "ws" | "http" | "h2" | "grpc";
if (params.headerType === "http") { if (params.headerType === "http") {
proxy.network = "http"; proxy.network = "http";
} else { } else {
@ -500,7 +506,22 @@ function URI_VLESS(line: string): IProxyConfig {
httpupgrade = true; httpupgrade = true;
} }
if (!proxy.network && isShadowrocket && params.obfs) { if (!proxy.network && isShadowrocket && params.obfs) {
proxy.network = params.obfs as "ws" | "http" | "h2" | "grpc"; switch (params.type) {
case "sw":
proxy.network = "ws";
break;
case "http":
proxy.network = "http";
break;
case "h2":
proxy.network = "h2";
break;
case "grpc":
proxy.network = "grpc";
break;
default: {
}
}
} }
if (["websocket"].includes(proxy.network)) { if (["websocket"].includes(proxy.network)) {
proxy.network = "ws"; proxy.network = "ws";
@ -520,20 +541,9 @@ function URI_VLESS(line: string): IProxyConfig {
opts.headers = { Host: host }; opts.headers = { Host: host };
} }
} }
if (params.serviceName) {
opts[`${proxy.network}-service-name`] = params.serviceName;
} else if (isShadowrocket && params.path) {
if (!["ws", "http", "h2"].includes(proxy.network)) {
opts[`${proxy.network}-service-name`] = params.path;
delete params.path;
}
}
if (params.path) { if (params.path) {
opts.path = params.path; opts.path = params.path;
} }
if (["grpc"].includes(proxy.network)) {
opts["_grpc-type"] = params.mode || "gun";
}
if (httpupgrade) { if (httpupgrade) {
opts["v2ray-http-upgrade"] = true; opts["v2ray-http-upgrade"] = true;
opts["v2ray-http-upgrade-fast-open"] = true; opts["v2ray-http-upgrade-fast-open"] = true;
@ -543,25 +553,25 @@ function URI_VLESS(line: string): IProxyConfig {
} }
} }
if (proxy.tls && !proxy.sni) { if (proxy.tls && !proxy.servername) {
if (proxy.network === "ws") { if (proxy.network === "ws") {
proxy.sni = proxy.ws?.headers?.Host; proxy.servername = proxy["ws-opts"]?.headers?.Host;
} else if (proxy.network === "http") { } else if (proxy.network === "http") {
let httpHost = proxy.http?.headers?.Host; let httpHost = proxy["http-opts"]?.headers?.Host;
proxy.sni = Array.isArray(httpHost) ? httpHost[0] : httpHost; proxy.servername = Array.isArray(httpHost) ? httpHost[0] : httpHost;
} }
} }
return proxy; return proxy;
} }
function URI_Trojan(line: string): IProxyConfig { function URI_Trojan(line: string): IProxyTrojanConfig {
let [newLine, name] = line.split(/#(.+)/, 2); let [newLine, name] = line.split(/#(.+)/, 2);
const parser = getTrojanURIParser(); const parser = getTrojanURIParser();
const proxy = parser.parse(newLine); const proxy: IProxyTrojanConfig = parser.parse(newLine);
if (isNotBlank(name)) { if (isNotBlank(name)) {
try { try {
proxy.name = decodeURIComponent(name); proxy.name = trimStr(decodeURIComponent(name));
} catch (e) { } catch (e) {
throw Error("Can not get proxy name"); throw Error("Can not get proxy name");
} }
@ -569,7 +579,7 @@ function URI_Trojan(line: string): IProxyConfig {
return proxy; return proxy;
} }
function URI_Hysteria2(line: string): IProxyConfig { function URI_Hysteria2(line: string): IProxyHysteria2Config {
line = line.split(/(hysteria2|hy2):\/\//)[2]; line = line.split(/(hysteria2|hy2):\/\//)[2];
// eslint-disable-next-line no-unused-vars // eslint-disable-next-line no-unused-vars
let [__, password, server, ___, port, ____, addons = "", name] = let [__, password, server, ___, port, ____, addons = "", name] =
@ -579,12 +589,12 @@ function URI_Hysteria2(line: string): IProxyConfig {
portNum = 443; portNum = 443;
} }
password = decodeURIComponent(password); password = decodeURIComponent(password);
if (name != null) {
name = decodeURIComponent(name);
}
name = name ?? `Hysteria2 ${server}:${port}`;
const proxy: IProxyConfig = { let decodedName = trimStr(decodeURIComponent(name));
name = decodedName ?? `Hysteria2 ${server}:${port}`;
const proxy: IProxyHysteria2Config = {
type: "hysteria2", type: "hysteria2",
name, name,
server, server,
@ -612,12 +622,12 @@ function URI_Hysteria2(line: string): IProxyConfig {
proxy["obfs-password"] = params["obfs-password"]; proxy["obfs-password"] = params["obfs-password"];
proxy["skip-cert-verify"] = /(TRUE)|1/i.test(params.insecure); proxy["skip-cert-verify"] = /(TRUE)|1/i.test(params.insecure);
proxy.tfo = /(TRUE)|1/i.test(params.fastopen); proxy.tfo = /(TRUE)|1/i.test(params.fastopen);
proxy["tls-fingerprint"] = params.pinSHA256; proxy.fingerprint = params.pinSHA256;
return proxy; return proxy;
} }
function URI_Hysteria(line: string): IProxyConfig { function URI_Hysteria(line: string): IProxyHysteriaConfig {
line = line.split(/(hysteria|hy):\/\//)[2]; line = line.split(/(hysteria|hy):\/\//)[2];
let [__, server, ___, port, ____, addons = "", name] = let [__, server, ___, port, ____, addons = "", name] =
/^(.*?)(:(\d+))?\/?(\?(.*?))?(?:#(.*?))?$/.exec(line)!; /^(.*?)(:(\d+))?\/?(\?(.*?))?(?:#(.*?))?$/.exec(line)!;
@ -625,12 +635,11 @@ function URI_Hysteria(line: string): IProxyConfig {
if (isNaN(portNum)) { if (isNaN(portNum)) {
portNum = 443; portNum = 443;
} }
if (name != null) { let decodedName = trimStr(decodeURIComponent(name));
name = decodeURIComponent(name);
}
name = name ?? `Hysteria ${server}:${port}`;
const proxy: IProxyConfig = { name = decodedName ?? `Hysteria ${server}:${port}`;
const proxy: IProxyHysteriaConfig = {
type: "hysteria", type: "hysteria",
name, name,
server, server,
@ -713,7 +722,7 @@ function URI_Hysteria(line: string): IProxyConfig {
return proxy; return proxy;
} }
function URI_TUIC(line: string): IProxyConfig { function URI_TUIC(line: string): IProxyTuicConfig {
line = line.split(/tuic:\/\//)[1]; line = line.split(/tuic:\/\//)[1];
let [__, uuid, password, server, ___, port, ____, addons = "", name] = let [__, uuid, password, server, ___, port, ____, addons = "", name] =
@ -724,12 +733,11 @@ function URI_TUIC(line: string): IProxyConfig {
portNum = 443; portNum = 443;
} }
password = decodeURIComponent(password); password = decodeURIComponent(password);
if (name != null) { let decodedName = trimStr(decodeURIComponent(name));
name = decodeURIComponent(name);
}
name = name ?? `TUIC ${server}:${port}`;
const proxy: IProxyConfig = { name = decodedName ?? `TUIC ${server}:${port}`;
const proxy: IProxyTuicConfig = {
type: "tuic", type: "tuic",
name, name,
server, server,
@ -794,7 +802,7 @@ function URI_TUIC(line: string): IProxyConfig {
return proxy; return proxy;
} }
function URI_Wireguard(line: string): IProxyConfig { function URI_Wireguard(line: string): IProxyWireguardConfig {
line = line.split(/(wireguard|wg):\/\//)[2]; line = line.split(/(wireguard|wg):\/\//)[2];
let [__, ___, privateKey, server, ____, port, _____, addons = "", name] = let [__, ___, privateKey, server, ____, port, _____, addons = "", name] =
/^((.*?)@)?(.*?)(:(\d+))?\/?(\?(.*?))?(?:#(.*?))?$/.exec(line)!; /^((.*?)@)?(.*?)(:(\d+))?\/?(\?(.*?))?(?:#(.*?))?$/.exec(line)!;
@ -804,11 +812,10 @@ function URI_Wireguard(line: string): IProxyConfig {
portNum = 443; portNum = 443;
} }
privateKey = decodeURIComponent(privateKey); privateKey = decodeURIComponent(privateKey);
if (name != null) { let decodedName = trimStr(decodeURIComponent(name));
name = decodeURIComponent(name);
} name = decodedName ?? `WireGuard ${server}:${port}`;
name = name ?? `WireGuard ${server}:${port}`; const proxy: IProxyWireguardConfig = {
const proxy: IProxyConfig = {
type: "wireguard", type: "wireguard",
name, name,
server, server,
@ -877,7 +884,7 @@ function URI_Wireguard(line: string): IProxyConfig {
return proxy; return proxy;
} }
function URI_HTTP(line: string): IProxyConfig { function URI_HTTP(line: string): IProxyHttpConfig {
line = line.split(/(http|https):\/\//)[2]; line = line.split(/(http|https):\/\//)[2];
let [__, ___, auth, server, ____, port, _____, addons = "", name] = let [__, ___, auth, server, ____, port, _____, addons = "", name] =
/^((.*?)@)?(.*?)(:(\d+))?\/?(\?(.*?))?(?:#(.*?))?$/.exec(line)!; /^((.*?)@)?(.*?)(:(\d+))?\/?(\?(.*?))?(?:#(.*?))?$/.exec(line)!;
@ -889,11 +896,10 @@ function URI_HTTP(line: string): IProxyConfig {
if (auth) { if (auth) {
auth = decodeURIComponent(auth); auth = decodeURIComponent(auth);
} }
if (name != null) { let decodedName = trimStr(decodeURIComponent(name));
name = decodeURIComponent(name);
} name = decodedName ?? `HTTP ${server}:${portNum}`;
name = name ?? `HTTP ${server}:${portNum}`; const proxy: IProxyHttpConfig = {
const proxy: IProxyConfig = {
type: "http", type: "http",
name, name,
server, server,
@ -919,9 +925,6 @@ function URI_HTTP(line: string): IProxyConfig {
case "skip-cert-verify": case "skip-cert-verify":
proxy["skip-cert-verify"] = /(TRUE)|1/i.test(value); proxy["skip-cert-verify"] = /(TRUE)|1/i.test(value);
break; break;
case "udp":
proxy["udp"] = /(TRUE)|1/i.test(value);
break;
case "ip-version": case "ip-version":
proxy["ip-version"] = value; proxy["ip-version"] = value;
break; break;
@ -933,7 +936,7 @@ function URI_HTTP(line: string): IProxyConfig {
return proxy; return proxy;
} }
function URI_SOCKS(line: string): IProxyConfig { function URI_SOCKS(line: string): IProxySocks5Config {
line = line.split(/socks5:\/\//)[1]; line = line.split(/socks5:\/\//)[1];
let [__, ___, auth, server, ____, port, _____, addons = "", name] = let [__, ___, auth, server, ____, port, _____, addons = "", name] =
/^((.*?)@)?(.*?)(:(\d+))?\/?(\?(.*?))?(?:#(.*?))?$/.exec(line)!; /^((.*?)@)?(.*?)(:(\d+))?\/?(\?(.*?))?(?:#(.*?))?$/.exec(line)!;
@ -945,11 +948,9 @@ function URI_SOCKS(line: string): IProxyConfig {
if (auth) { if (auth) {
auth = decodeURIComponent(auth); auth = decodeURIComponent(auth);
} }
if (name != null) { let decodedName = trimStr(decodeURIComponent(name));
name = decodeURIComponent(name); name = decodedName ?? `SOCKS5 ${server}:${portNum}`;
} const proxy: IProxySocks5Config = {
name = name ?? `SOCKS5 ${server}:${portNum}`;
const proxy: IProxyConfig = {
type: "socks5", type: "socks5",
name, name,
server, server,