nite/sub2sing-box
1
0
Fork 0
mirror of https://github.com/bestnite/sub2sing-box.git synced 2025-10-28 09:33:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

整理代码

Browse Source
This commit is contained in:
nite07
2024-03-22 16:10:15 +08:00
committed by Nite07
parent f545848ce1
commit a7ceb4ecb0
16 changed files with 428 additions and 442 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
parser/vless.go
View File

@@ -1,35 +1,59 @@
package parser
import (
"errors"
"net/url"
"strconv"
"strings"
"sub2sing-box/constant"
"sub2sing-box/model"
)
func ParseVless(proxy string) (model.Outbound, error) {
if !strings.HasPrefix(proxy, "vless://") {
return model.Outbound{}, errors.New("invalid vless Url")
if !strings.HasPrefix(proxy, constant.VLESSPrefix) {
return model.Outbound{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
}
parts := strings.SplitN(strings.TrimPrefix(proxy, "vless://"), "@", 2)
if len(parts) != 2 {
return model.Outbound{}, errors.New("invalid vless Url")
urlParts := strings.SplitN(strings.TrimPrefix(proxy, constant.VLESSPrefix), "@", 2)
if len(urlParts) != 2 {
return model.Outbound{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing character '@' in url",
Raw: proxy,
}
}
serverInfo := strings.SplitN(parts[1], "#", 2)
serverInfo := strings.SplitN(urlParts[1], "#", 2)
serverAndPortAndParams := strings.SplitN(serverInfo[0], "?", 2)
if len(serverAndPortAndParams) != 2 {
return model.Outbound{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing character '?' in url",
Raw: proxy,
}
}
serverAndPort := strings.SplitN(serverAndPortAndParams[0], ":", 2)
if len(serverAndPort) != 2 {
return model.Outbound{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host or port",
Raw: proxy,
}
}
server, portStr := serverAndPort[0], serverAndPort[1]
port, err := ParsePort(portStr)
if err != nil {
return model.Outbound{}, err
}
params, err := url.ParseQuery(serverAndPortAndParams[1])
if err != nil {
return model.Outbound{}, err
}
if len(serverAndPort) != 2 {
return model.Outbound{}, errors.New("invalid vless Url")
}
port, err := strconv.Atoi(strings.TrimSpace(serverAndPort[1]))
if err != nil {
return model.Outbound{}, err
return model.Outbound{}, &ParseError{
Type: ErrCannotParseParams,
Raw: proxy,
Message: err.Error(),
}
}
remarks := ""
if len(serverInfo) == 2 {
if strings.Contains(serverInfo[1], "|") {
@@ -37,92 +61,107 @@ func ParseVless(proxy string) (model.Outbound, error) {
} else {
remarks, err = url.QueryUnescape(serverInfo[1])
if err != nil {
return model.Outbound{}, err
return model.Outbound{}, &ParseError{
Type: ErrCannotParseParams,
Raw: proxy,
Message: err.Error(),
}
}
}
} else {
remarks, err = url.QueryUnescape(serverAndPort[0])
remarks, err = url.QueryUnescape(server)
if err != nil {
return model.Outbound{}, err
}
}
server := strings.TrimSpace(serverAndPort[0])
uuid := strings.TrimSpace(parts[0])
uuid := strings.TrimSpace(urlParts[0])
flow, security, alpnStr, sni, insecure, fp, pbk, sid, path, host, serviceName := params.Get("flow"), params.Get("security"), params.Get("alpn"), params.Get("sni"), params.Get("allowInsecure"), params.Get("fp"), params.Get("pbk"), params.Get("sid"), params.Get("path"), params.Get("host"), params.Get("serviceName")
enableUTLS := fp != ""
insecureBool := insecure == "1"
var alpn []string
if strings.Contains(alpnStr, ",") {
alpn = strings.Split(alpnStr, ",")
} else {
alpn = nil
}
result := model.Outbound{
Type: "vless",
Tag: remarks,
VLESSOptions: model.VLESSOutboundOptions{
ServerOptions: model.ServerOptions{
Server: server,
ServerPort: uint16(port),
ServerPort: port,
},
UUID: uuid,
Flow: params.Get("flow"),
Flow: flow,
},
}
if params.Get("security") == "tls" {
var alpn []string
if strings.Contains(params.Get("alpn"), ",") {
alpn = strings.Split(params.Get("alpn"), ",")
} else {
alpn = nil
}
if security == "tls" {
result.VLESSOptions.OutboundTLSOptionsContainer = model.OutboundTLSOptionsContainer{
TLS: &model.OutboundTLSOptions{
Enabled: true,
ALPN: alpn,
ServerName: params.Get("sni"),
Insecure: params.Get("allowInsecure") == "1",
ServerName: sni,
Insecure: insecureBool,
},
}
if params.Get("fp") != "" {
result.VLESSOptions.OutboundTLSOptionsContainer.TLS.UTLS = &model.OutboundUTLSOptions{
Enabled: true,
Fingerprint: params.Get("fp"),
}
result.VLESSOptions.OutboundTLSOptionsContainer.TLS.UTLS = &model.OutboundUTLSOptions{
Enabled: enableUTLS,
Fingerprint: fp,
}
}
if params.Get("security") == "reality" {
if security == "reality" {
result.VLESSOptions.OutboundTLSOptionsContainer.TLS.Reality = &model.OutboundRealityOptions{
Enabled: true,
PublicKey: params.Get("pbk"),
ShortID: params.Get("sid"),
PublicKey: pbk,
ShortID: sid,
}
}
if params.Get("type") == "ws" {
result.VLESSOptions.Transport = &model.V2RayTransportOptions{
Type: "ws",
WebsocketOptions: model.V2RayWebsocketOptions{
Path: params.Get("path"),
Path: path,
},
}
if params.Get("host") != "" {
result.VLESSOptions.Transport.WebsocketOptions.Headers["Host"] = params.Get("host")
}
result.VLESSOptions.Transport.WebsocketOptions.Headers["Host"] = host
}
if params.Get("type") == "quic" {
result.VLESSOptions.Transport = &model.V2RayTransportOptions{
Type: "quic",
QUICOptions: model.V2RayQUICOptions{},
}
}
if params.Get("type") == "grpc" {
result.VLESSOptions.Transport = &model.V2RayTransportOptions{
Type: "grpc",
GRPCOptions: model.V2RayGRPCOptions{
ServiceName: params.Get("serviceName"),
ServiceName: serviceName,
},
}
}
if params.Get("type") == "http" {
host, err := url.QueryUnescape(params.Get("host"))
hosts, err := url.QueryUnescape(host)
if err != nil {
return model.Outbound{}, err
return model.Outbound{}, &ParseError{
Type: ErrCannotParseParams,
Raw: proxy,
Message: err.Error(),
}
}
result.VLESSOptions.Transport = &model.V2RayTransportOptions{
Type: "http",
HTTPOptions: model.V2RayHTTPOptions{
Host: strings.Split(host, ","),
Host: strings.Split(hosts, ","),
},
}
}