From 7554c48fa7d5f36b3ba327fb744838b5c456a91e Mon Sep 17 00:00:00 2001 From: zu1k Date: Mon, 7 Sep 2020 12:02:44 +0800 Subject: [PATCH] add sip002 support & derive proxy --- api/router.go | 12 +++++++ internal/app/task.go | 4 +-- pkg/provider/ssrsub.go | 13 ++----- pkg/provider/sssub.go | 32 ++++++++++------- pkg/proxy/convert.go | 80 ++++++++++++++++++++++++------------------ pkg/proxy/proxies.go | 33 +++++++++-------- 6 files changed, 100 insertions(+), 74 deletions(-) diff --git a/api/router.go b/api/router.go index e21121b..ca5f761 100644 --- a/api/router.go +++ b/api/router.go @@ -182,6 +182,18 @@ func setupRouter() { } c.String(200, vmessSub.Provide()) }) + + router.GET("/sip002/sub", func(c *gin.Context) { + proxies := cache.GetProxies("proxies") + sip002Sub := provider.SIP002Sub{ + provider.Base{ + Proxies: &proxies, + Types: "ss", + }, + } + c.String(200, sip002Sub.Provide()) + }) + router.GET("/link/:id", func(c *gin.Context) { idx := c.Param("id") proxies := cache.GetProxies("allproxies") diff --git a/internal/app/task.go b/internal/app/task.go index 368c5b0..62d16e4 100644 --- a/internal/app/task.go +++ b/internal/app/task.go @@ -31,8 +31,8 @@ func CrawlGo() { proxies = append(proxies, node) } } - // 节点去重 - proxies = proxies.Deduplication() + // 节点衍生并去重 + proxies = proxies.Derive() log.Println("CrawlGo node count:", len(proxies)) proxies = provider.Clash{ provider.Base{ diff --git a/pkg/provider/ssrsub.go b/pkg/provider/ssrsub.go index 8d54dd0..3cf21e0 100644 --- a/pkg/provider/ssrsub.go +++ b/pkg/provider/ssrsub.go @@ -3,8 +3,6 @@ package provider import ( "strings" - "github.com/zu1k/proxypool/pkg/proxy" - "github.com/zu1k/proxypool/pkg/tool" ) @@ -13,18 +11,11 @@ type SSRSub struct { } func (sub SSRSub) Provide() string { - sub.Types = "ssr,ss" + sub.Types = "ssr" sub.preFilter() var resultBuilder strings.Builder for _, p := range *sub.Proxies { - if p.TypeName() == "ssr" { - resultBuilder.WriteString(p.Link() + "\n") - } else if p.TypeName() == "ss" { - ssr, err := proxy.SS2SSR(p.(*proxy.Shadowsocks)) - if err == nil { - resultBuilder.WriteString(ssr.Link() + "\n") - } - } + resultBuilder.WriteString(p.Link() + "\n") } return tool.Base64EncodeString(resultBuilder.String(), false) } diff --git a/pkg/provider/sssub.go b/pkg/provider/sssub.go index a65c73b..180f5a1 100644 --- a/pkg/provider/sssub.go +++ b/pkg/provider/sssub.go @@ -3,6 +3,9 @@ package provider import ( "encoding/json" "strconv" + "strings" + + "github.com/zu1k/proxypool/pkg/tool" "github.com/zu1k/proxypool/pkg/proxy" ) @@ -22,22 +25,11 @@ type ssJson struct { } func (sub SSSub) Provide() string { - sub.Types = "ss,ssr" + sub.Types = "ss" sub.preFilter() proxies := make([]ssJson, 0, sub.Proxies.Len()) for _, p := range *sub.Proxies { - var pp *proxy.Shadowsocks - - if p.TypeName() == "ssr" { - var err error - pp, err = proxy.SSR2SS(p.(*proxy.ShadowsocksR)) - if err != nil { - continue - } - } else if p.TypeName() == "ss" { - pp = p.(*proxy.Shadowsocks) - } - + pp := p.(*proxy.Shadowsocks) proxies = append(proxies, ssJson{ Remarks: pp.Name, Server: pp.Server, @@ -54,3 +46,17 @@ func (sub SSSub) Provide() string { } return string(text) } + +type SIP002Sub struct { + Base +} + +func (sub SIP002Sub) Provide() string { + sub.Types = "ss" + sub.preFilter() + var resultBuilder strings.Builder + for _, p := range *sub.Proxies { + resultBuilder.WriteString(p.Link() + "\n") + } + return tool.Base64EncodeString(resultBuilder.String(), false) +} diff --git a/pkg/proxy/convert.go b/pkg/proxy/convert.go index c2f2641..40730da 100644 --- a/pkg/proxy/convert.go +++ b/pkg/proxy/convert.go @@ -6,44 +6,56 @@ import ( "github.com/zu1k/proxypool/pkg/tool" ) -func SS2SSR(ss *Shadowsocks) (ssr *ShadowsocksR, err error) { - if ss == nil { - return nil, errors.New("ss is nil") +var ErrorTypeCanNotConvert = errors.New("type not support") + +// Convert2SS convert proxy to ShadowsocksR if possible +func Convert2SSR(p Proxy) (ssr *ShadowsocksR, err error) { + if p.TypeName() == "ss" { + ss := p.(*Shadowsocks) + if ss == nil { + return nil, errors.New("ss is nil") + } + if !tool.CheckInList(SSRCipherList, ss.Cipher) { + return nil, errors.New("cipher not support") + } + base := ss.Base + base.Type = "ssr" + return &ShadowsocksR{ + Base: base, + Password: ss.Password, + Cipher: ss.Cipher, + Protocol: "origin", + Obfs: "plain", + Group: "proxy.tgbot.co", + }, nil } - if !tool.CheckInList(SSRCipherList, ss.Cipher) { - return nil, errors.New("cipher not support") - } - base := ss.Base - base.Type = "ssr" - return &ShadowsocksR{ - Base: base, - Password: ss.Password, - Cipher: ss.Cipher, - Protocol: "origin", - Obfs: "plain", - Group: "proxy.tgbot.co", - }, nil + return nil, ErrorTypeCanNotConvert } -func SSR2SS(ssr *ShadowsocksR) (ss *Shadowsocks, err error) { - if ssr == nil { - return nil, errors.New("ssr is nil") +// Convert2SS convert proxy to Shadowsocks if possible +func Convert2SS(p Proxy) (ss *Shadowsocks, err error) { + if p.TypeName() == "ss" { + ssr := p.(*ShadowsocksR) + if ssr == nil { + return nil, errors.New("ssr is nil") + } + if !tool.CheckInList(SSCipherList, ssr.Cipher) { + return nil, errors.New("cipher not support") + } + if ssr.Protocol != "origin" || ssr.Obfs != "plain" { + return nil, errors.New("protocol or obfs not allowed") + } + base := ssr.Base + base.Type = "ss" + return &Shadowsocks{ + Base: base, + Password: ssr.Password, + Cipher: ssr.Cipher, + Plugin: "", + PluginOpts: nil, + }, nil } - if !tool.CheckInList(SSCipherList, ssr.Cipher) { - return nil, errors.New("cipher not support") - } - if ssr.Protocol != "origin" || ssr.Obfs != "plain" { - return nil, errors.New("protocol or obfs not allowed") - } - base := ssr.Base - base.Type = "ss" - return &Shadowsocks{ - Base: base, - Password: ssr.Password, - Cipher: ssr.Cipher, - Plugin: "", - PluginOpts: nil, - }, nil + return nil, ErrorTypeCanNotConvert } var SSRCipherList = []string{ diff --git a/pkg/proxy/proxies.go b/pkg/proxy/proxies.go index 954bdb3..73e4420 100644 --- a/pkg/proxy/proxies.go +++ b/pkg/proxy/proxies.go @@ -110,20 +110,6 @@ func (ps ProxyList) NameAddTG() ProxyList { return ps } -func Deduplication(src ProxyList) ProxyList { - result := make(ProxyList, 0, len(src)) - temp := map[string]struct{}{} - for _, item := range src { - if item != nil { - if _, ok := temp[item.Identifier()]; !ok { - temp[item.Identifier()] = struct{}{} - result = append(result, item) - } - } - } - return result -} - func (ps ProxyList) Clone() ProxyList { result := make(ProxyList, 0, len(ps)) for _, pp := range ps { @@ -133,3 +119,22 @@ func (ps ProxyList) Clone() ProxyList { } return result } + +// Derive 将原有节点中的ss和ssr互相转换进行衍生 +func (ps ProxyList) Derive() ProxyList { + proxies := ps + for _, p := range ps { + if p.TypeName() == "ss" { + ssr, err := Convert2SSR(p) + if err == nil { + proxies = append(proxies, ssr) + } + } else if p.TypeName() == "ssr" { + ss, err := Convert2SS(p) + if err == nil { + proxies = append(proxies, ss) + } + } + } + return proxies.Deduplication() +}