mirror of
https://github.com/wyx2685/V2bX.git
synced 2026-02-04 04:30:08 +00:00
update to v1.1.0
change to uniproxy api refactor build inbound refactor limiter and rule add ss2022 support add speedlimit support and more...
This commit is contained in:
Yuzuki999
@@ -1,266 +1,82 @@
|
||||
package panel
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
md52 "crypto/md5"
|
||||
"fmt"
|
||||
"github.com/go-resty/resty/v2"
|
||||
"github.com/goccy/go-json"
|
||||
"github.com/xtls/xray-core/infra/conf"
|
||||
"log"
|
||||
"os"
|
||||
"regexp"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
type DetectRule struct {
|
||||
ProtocolRule []string
|
||||
DestinationRule []DestinationRule
|
||||
type NodeInfo struct {
|
||||
Host string `json:"host"`
|
||||
ServerPort int `json:"server_port"`
|
||||
ServerName string `json:"server_name"`
|
||||
Network string `json:"network"`
|
||||
NetworkSettings json.RawMessage `json:"networkSettings"`
|
||||
Cipher string `json:"cipher"`
|
||||
ServerKey string `json:"server_key"`
|
||||
Tls int `json:"tls"`
|
||||
Routes []Route `json:"routes"`
|
||||
BaseConfig *BaseConfig `json:"base_config"`
|
||||
Rules []DestinationRule `json:"-"`
|
||||
localNodeConfig `json:"-"`
|
||||
}
|
||||
type Route struct {
|
||||
Id int `json:"id"`
|
||||
Match string `json:"match"`
|
||||
Action string `json:"action"`
|
||||
//ActionValue interface{} `json:"action_value"`
|
||||
}
|
||||
type BaseConfig struct {
|
||||
PushInterval any `json:"push_interval"`
|
||||
PullInterval any `json:"pull_interval"`
|
||||
}
|
||||
type DestinationRule struct {
|
||||
ID int
|
||||
Pattern *regexp.Regexp
|
||||
}
|
||||
|
||||
// readLocalRuleList reads the local rule list file
|
||||
func readLocalRuleList(path string) (LocalRuleList *DetectRule) {
|
||||
LocalRuleList = &DetectRule{}
|
||||
if path != "" {
|
||||
// open the file
|
||||
file, err := os.Open(path)
|
||||
//handle errors while opening
|
||||
if err != nil {
|
||||
log.Printf("Error when opening file: %s", err)
|
||||
return
|
||||
}
|
||||
fileScanner := bufio.NewScanner(file)
|
||||
// read line by line
|
||||
for fileScanner.Scan() {
|
||||
LocalRuleList.DestinationRule = append(LocalRuleList.DestinationRule, DestinationRule{
|
||||
ID: -1,
|
||||
Pattern: regexp.MustCompile(fileScanner.Text()),
|
||||
})
|
||||
}
|
||||
// handle first encountered error while reading
|
||||
if err := fileScanner.Err(); err != nil {
|
||||
log.Fatalf("Error while reading file: %s", err)
|
||||
return
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
type NodeInfo struct {
|
||||
DeviceLimit int
|
||||
SpeedLimit uint64
|
||||
NodeType string
|
||||
type localNodeConfig struct {
|
||||
NodeId int
|
||||
NodeType string
|
||||
TLSType string
|
||||
EnableVless bool
|
||||
EnableTls bool
|
||||
//EnableSS2022 bool
|
||||
V2ray *V2rayConfig
|
||||
Trojan *TrojanConfig
|
||||
SS *SSConfig
|
||||
SpeedLimit int
|
||||
DeviceLimit int
|
||||
}
|
||||
|
||||
type SSConfig struct {
|
||||
Port int `json:"port"`
|
||||
TransportProtocol string `json:"transportProtocol"`
|
||||
CypherMethod string `json:"cypher"`
|
||||
}
|
||||
type V2rayConfig struct {
|
||||
Inbounds []conf.InboundDetourConfig `json:"inbounds"`
|
||||
Routing *struct {
|
||||
Rules json.RawMessage `json:"rules"`
|
||||
} `json:"routing"`
|
||||
}
|
||||
|
||||
type Rule struct {
|
||||
Type string `json:"type"`
|
||||
InboundTag string `json:"inboundTag,omitempty"`
|
||||
OutboundTag string `json:"outboundTag"`
|
||||
Domain []string `json:"domain,omitempty"`
|
||||
Protocol []string `json:"protocol,omitempty"`
|
||||
}
|
||||
|
||||
type TrojanConfig struct {
|
||||
LocalPort int `json:"local_port"`
|
||||
Password []interface{} `json:"password"`
|
||||
TransportProtocol string
|
||||
Ssl struct {
|
||||
Sni string `json:"sni"`
|
||||
} `json:"ssl"`
|
||||
}
|
||||
|
||||
// GetNodeInfo will pull NodeInfo Config from v2board
|
||||
func (c *Client) GetNodeInfo() (nodeInfo *NodeInfo, err error) {
|
||||
var path string
|
||||
var res *resty.Response
|
||||
switch c.NodeType {
|
||||
case "V2ray":
|
||||
path = "/api/v1/server/Deepbwork/config"
|
||||
case "Trojan":
|
||||
path = "/api/v1/server/TrojanTidalab/config"
|
||||
case "Shadowsocks":
|
||||
if nodeInfo, err = c.ParseSSNodeResponse(); err == nil {
|
||||
return nodeInfo, nil
|
||||
} else {
|
||||
return nil, err
|
||||
}
|
||||
default:
|
||||
return nil, fmt.Errorf("unsupported Node type: %s", c.NodeType)
|
||||
const path = "/api/v1/server/UniProxy/config"
|
||||
r, err := c.client.R().Get(path)
|
||||
if err = c.checkResponse(r, path, err); err != nil {
|
||||
return
|
||||
}
|
||||
res, err = c.client.R().
|
||||
SetQueryParam("local_port", "1").
|
||||
ForceContentType("application/json").
|
||||
Get(path)
|
||||
err = c.checkResponse(res, path, err)
|
||||
err = json.Unmarshal(r.Body(), &nodeInfo)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
return
|
||||
}
|
||||
c.access.Lock()
|
||||
defer c.access.Unlock()
|
||||
switch c.NodeType {
|
||||
case "V2ray":
|
||||
i := bytes.Index(res.Body(), []byte("outbo"))
|
||||
md := md52.Sum(res.Body()[:i])
|
||||
nodeNotIsChange := true
|
||||
if c.NodeInfoRspMd5 == [16]byte{} {
|
||||
nodeNotIsChange = false
|
||||
c.NodeInfoRspMd5 = md
|
||||
} else {
|
||||
if c.NodeInfoRspMd5 != md {
|
||||
nodeNotIsChange = false
|
||||
c.NodeInfoRspMd5 = md
|
||||
}
|
||||
}
|
||||
md2 := md52.Sum(res.Body()[i:])
|
||||
ruleIsChange := false
|
||||
if c.NodeRuleRspMd5 != md2 {
|
||||
ruleIsChange = true
|
||||
c.NodeRuleRspMd5 = md2
|
||||
}
|
||||
nodeInfo, err = c.ParseV2rayNodeResponse(res.Body(), nodeNotIsChange, ruleIsChange)
|
||||
case "Trojan":
|
||||
md := md52.Sum(res.Body())
|
||||
if c.NodeInfoRspMd5 != [16]byte{} {
|
||||
if c.NodeInfoRspMd5 == md {
|
||||
return nil, nil
|
||||
}
|
||||
}
|
||||
c.NodeInfoRspMd5 = md
|
||||
nodeInfo, err = c.ParseTrojanNodeResponse(res.Body())
|
||||
}
|
||||
return nodeInfo, nil
|
||||
}
|
||||
|
||||
func (c *Client) GetNodeRule() (*DetectRule, error) {
|
||||
ruleList := c.LocalRuleList
|
||||
if c.NodeType != "V2ray" || c.RemoteRuleCache == nil {
|
||||
if c.etag == r.Header().Get("ETag") { // node info not changed
|
||||
return nil, nil
|
||||
}
|
||||
// V2board only support the rule for v2ray
|
||||
// fix: reuse config response
|
||||
c.access.Lock()
|
||||
defer c.access.Unlock()
|
||||
if len(c.RemoteRuleCache) >= 2 {
|
||||
for i, rule := range (c.RemoteRuleCache)[1].Domain {
|
||||
ruleListItem := DestinationRule{
|
||||
ID: i,
|
||||
Pattern: regexp.MustCompile(rule),
|
||||
}
|
||||
ruleList.DestinationRule = append(ruleList.DestinationRule, ruleListItem)
|
||||
nodeInfo.NodeId = c.NodeId
|
||||
nodeInfo.NodeType = c.NodeType
|
||||
for i := range nodeInfo.Routes { // parse rules from routes
|
||||
r := &nodeInfo.Routes[i]
|
||||
if r.Action == "block" {
|
||||
nodeInfo.Rules = append(nodeInfo.Rules, DestinationRule{
|
||||
ID: r.Id,
|
||||
Pattern: regexp.MustCompile(r.Match),
|
||||
})
|
||||
}
|
||||
}
|
||||
if len(c.RemoteRuleCache) >= 3 {
|
||||
for _, str := range (c.RemoteRuleCache)[2].Protocol {
|
||||
ruleList.ProtocolRule = append(ruleList.ProtocolRule, str)
|
||||
}
|
||||
nodeInfo.Routes = nil
|
||||
if _, ok := nodeInfo.BaseConfig.PullInterval.(int); !ok {
|
||||
i, _ := strconv.Atoi(nodeInfo.BaseConfig.PullInterval.(string))
|
||||
nodeInfo.BaseConfig.PullInterval = i
|
||||
}
|
||||
c.RemoteRuleCache = nil
|
||||
return ruleList, nil
|
||||
}
|
||||
|
||||
// ParseTrojanNodeResponse parse the response for the given node info format
|
||||
func (c *Client) ParseTrojanNodeResponse(body []byte) (*NodeInfo, error) {
|
||||
node := &NodeInfo{Trojan: &TrojanConfig{}}
|
||||
var err = json.Unmarshal(body, node.Trojan)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("unmarshal nodeinfo error: %s", err)
|
||||
}
|
||||
node.SpeedLimit = uint64(c.SpeedLimit * 1000000 / 8)
|
||||
node.DeviceLimit = c.DeviceLimit
|
||||
node.NodeId = c.NodeID
|
||||
node.NodeType = c.NodeType
|
||||
node.Trojan.TransportProtocol = "tcp"
|
||||
return node, nil
|
||||
}
|
||||
|
||||
// ParseSSNodeResponse parse the response for the given node info format
|
||||
func (c *Client) ParseSSNodeResponse() (*NodeInfo, error) {
|
||||
var port int
|
||||
var method string
|
||||
userInfo, err := c.GetUserList()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(userInfo) > 0 {
|
||||
port = userInfo[0].Port
|
||||
method = userInfo[0].Cipher
|
||||
} else {
|
||||
return nil, fmt.Errorf("shadowsocks node need a active user")
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
node := &NodeInfo{
|
||||
SpeedLimit: uint64(c.SpeedLimit * 1000000 / 8),
|
||||
DeviceLimit: c.DeviceLimit,
|
||||
//EnableSS2022: c.EnableSS2022,
|
||||
NodeType: c.NodeType,
|
||||
NodeId: c.NodeID,
|
||||
SS: &SSConfig{
|
||||
Port: port,
|
||||
TransportProtocol: "tcp",
|
||||
CypherMethod: method,
|
||||
},
|
||||
}
|
||||
return node, nil
|
||||
}
|
||||
|
||||
// ParseV2rayNodeResponse parse the response for the given nodeinfor format
|
||||
func (c *Client) ParseV2rayNodeResponse(body []byte, notParseNode, parseRule bool) (*NodeInfo, error) {
|
||||
if notParseNode && !parseRule {
|
||||
return nil, nil
|
||||
}
|
||||
node := &NodeInfo{V2ray: &V2rayConfig{}}
|
||||
err := json.Unmarshal(body, node.V2ray)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("unmarshal nodeinfo error: %s", err)
|
||||
}
|
||||
if parseRule {
|
||||
c.RemoteRuleCache = []Rule{}
|
||||
err := json.Unmarshal(node.V2ray.Routing.Rules, &c.RemoteRuleCache)
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
}
|
||||
if notParseNode {
|
||||
return nil, nil
|
||||
}
|
||||
}
|
||||
node.V2ray.Routing = nil
|
||||
node.SpeedLimit = uint64(c.SpeedLimit * 1000000 / 8)
|
||||
node.DeviceLimit = c.DeviceLimit
|
||||
node.NodeType = c.NodeType
|
||||
node.NodeId = c.NodeID
|
||||
if c.EnableXTLS {
|
||||
node.TLSType = "xtls"
|
||||
} else {
|
||||
node.TLSType = "tls"
|
||||
}
|
||||
node.EnableVless = c.EnableVless
|
||||
node.EnableTls = node.V2ray.Inbounds[0].StreamSetting.Security == "tls"
|
||||
return node, nil
|
||||
if _, ok := nodeInfo.BaseConfig.PushInterval.(int); !ok {
|
||||
i, _ := strconv.Atoi(nodeInfo.BaseConfig.PushInterval.(string))
|
||||
nodeInfo.BaseConfig.PushInterval = i
|
||||
}
|
||||
c.etag = r.Header().Get("Etag")
|
||||
return
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user