284 lines
8.4 KiB
Go
284 lines
8.4 KiB
Go
package proxy
|
|
|
|
import (
|
|
"context"
|
|
"crypto/aes"
|
|
"encoding/hex"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"net/url"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestIPZanRequestURLSetsRequestedCount(t *testing.T) {
|
|
raw := "https://service.ipzan.com/core-extract?num=1&minute=10&protocol=1&secret=x"
|
|
got, err := NewIPZanProvider().RequestURL(raw, 6)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !strings.Contains(got, "num=6") || strings.Contains(got, "num=1") {
|
|
t.Fatalf("RequestURL() = %q", got)
|
|
}
|
|
}
|
|
|
|
func TestIPZanParseTextMultiple(t *testing.T) {
|
|
body := []byte("1.2.3.4:8001\r\n5.6.7.8:8002\r\n")
|
|
got, err := NewIPZanProvider().Parse(
|
|
"https://service.ipzan.com/core-extract?protocol=3",
|
|
body,
|
|
)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 2 {
|
|
t.Fatalf("len=%d, want 2", len(got))
|
|
}
|
|
if got[0].URL != "socks5://1.2.3.4:8001" {
|
|
t.Fatalf("URL=%q", got[0].URL)
|
|
}
|
|
}
|
|
|
|
func TestIPZanParseJSONError(t *testing.T) {
|
|
body := []byte(`{"code":-1,"data":null,"status":200,"message":"请先将1.2.3.4加入到白名单再进行提取"}`)
|
|
_, err := NewIPZanProvider().Parse("https://service.ipzan.com/core-extract", body)
|
|
if err == nil || !IsFatal(err) {
|
|
t.Fatalf("expected fatal provider error, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestIPZanParseJSONList(t *testing.T) {
|
|
body := []byte(`{"code":0,"status":200,"data":{"list":[{"ip":"1.2.3.4","port":8001,"account":"user-a","password":"pass-a","expired":1893456000000},{"ip":"5.6.7.8","port":"8002"}]}}`)
|
|
got, err := NewIPZanProvider().Parse(
|
|
"https://service.ipzan.com/core-extract?protocol=1",
|
|
body,
|
|
)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 2 || got[0].URL != "http://user-a:pass-a@1.2.3.4:8001" || got[1].URL != "http://5.6.7.8:8002" {
|
|
t.Fatalf("unexpected endpoints: %#v", got)
|
|
}
|
|
if got[0].ExpiresAt != time.UnixMilli(1893456000000) {
|
|
t.Fatalf("ExpiresAt=%v", got[0].ExpiresAt)
|
|
}
|
|
}
|
|
|
|
func TestGenericParseJSONListWithAuth(t *testing.T) {
|
|
body := []byte(`{"code":0,"data":{"list":[{"ip":"1.2.3.4","port":9000,"username":"u","password":"p"}]}}`)
|
|
got, err := NewGenericProvider().Parse("https://example.test/api", body)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 1 || got[0].URL != "http://u:p@1.2.3.4:9000" {
|
|
t.Fatalf("unexpected endpoints: %#v", got)
|
|
}
|
|
}
|
|
|
|
func TestGenericParseIPZanAccountPasswordSample(t *testing.T) {
|
|
body := []byte(`{"data":{"list":[{"ip":"203.0.113.10","port":"15471","expired":1893456000000,"net":"电信","account":"test-account","password":"test-password"}]},"code":0,"message":"","status":200}`)
|
|
got, err := NewGenericProvider().Parse("https://example.test/api?protocol=1", body)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 1 {
|
|
t.Fatalf("len=%d, want 1", len(got))
|
|
}
|
|
if got[0].URL != "http://test-account:test-password@203.0.113.10:15471" {
|
|
t.Fatalf("URL=%q", got[0].URL)
|
|
}
|
|
if got[0].Username != "test-account" || got[0].Password != "test-password" {
|
|
t.Fatalf("credentials not parsed: %#v", got[0])
|
|
}
|
|
if got[0].ExpiresAt != time.UnixMilli(1893456000000) {
|
|
t.Fatalf("ExpiresAt=%v", got[0].ExpiresAt)
|
|
}
|
|
}
|
|
|
|
func TestGenericProviderDoesNotTreatErrorIPAsProxy(t *testing.T) {
|
|
body := []byte(`{"code":-1,"status":200,"message":"请先将1.2.3.4加入白名单"}`)
|
|
_, err := NewGenericProvider().Parse("https://example.test/api", body)
|
|
if err == nil || !IsFatal(err) {
|
|
t.Fatalf("expected fatal provider error, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestGenericProviderParsesLegacyJSONData(t *testing.T) {
|
|
body := []byte(`{"status":100,"info":"成功","data":[{"ip":"1.2.3.4","port":"8001","prov":"浙江","city":"嘉兴"}]}`)
|
|
got, err := NewGenericProvider().Parse("https://example.test/api", body)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 1 || got[0].URL != "http://1.2.3.4:8001" || got[0].Region != "浙江 嘉兴" {
|
|
t.Fatalf("unexpected endpoints: %#v", got)
|
|
}
|
|
}
|
|
|
|
type roundTripFunc func(*http.Request) (*http.Response, error)
|
|
|
|
func (fn roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
|
|
return fn(req)
|
|
}
|
|
|
|
type autoWhitelistTestProvider struct {
|
|
parseCalls int
|
|
addedIP string
|
|
}
|
|
|
|
func (p *autoWhitelistTestProvider) ID() string { return "test" }
|
|
|
|
func (p *autoWhitelistTestProvider) Match(*url.URL) bool { return true }
|
|
|
|
func (p *autoWhitelistTestProvider) RequestURL(apiURL string, count int) (string, error) {
|
|
return apiURL, nil
|
|
}
|
|
|
|
func (p *autoWhitelistTestProvider) Parse(string, []byte) ([]Endpoint, error) {
|
|
p.parseCalls++
|
|
if p.parseCalls == 1 {
|
|
return nil, &ProviderError{
|
|
Provider: "test",
|
|
Message: "请先将1.2.3.4加入白名单再提取",
|
|
Fatal: true,
|
|
}
|
|
}
|
|
return []Endpoint{{URL: "http://1.2.3.4:9000", IP: "1.2.3.4"}}, nil
|
|
}
|
|
|
|
func (p *autoWhitelistTestProvider) EnsureWhitelist(context.Context, *http.Client, WhitelistConfig) error {
|
|
return nil
|
|
}
|
|
|
|
func (p *autoWhitelistTestProvider) AddWhitelist(_ context.Context, _ *http.Client, cfg WhitelistConfig) error {
|
|
p.addedIP = cfg.IP
|
|
return nil
|
|
}
|
|
|
|
func TestExtractWithWhitelistUsesProviderReportedIP(t *testing.T) {
|
|
provider := &autoWhitelistTestProvider{}
|
|
client := &http.Client{Transport: roundTripFunc(func(*http.Request) (*http.Response, error) {
|
|
return &http.Response{
|
|
StatusCode: http.StatusOK,
|
|
Body: io.NopCloser(strings.NewReader("probe")),
|
|
Header: make(http.Header),
|
|
}, nil
|
|
})}
|
|
service := NewServiceWithProviders(client, provider)
|
|
got, err := service.ExtractWithWhitelist(
|
|
context.Background(),
|
|
"https://example.test/extract",
|
|
1,
|
|
WhitelistConfig{AutoWhitelist: true},
|
|
)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if provider.addedIP != "1.2.3.4" {
|
|
t.Fatalf("addedIP=%q", provider.addedIP)
|
|
}
|
|
if len(got) != 1 {
|
|
t.Fatalf("len=%d, want 1", len(got))
|
|
}
|
|
}
|
|
|
|
func TestServiceSelectsIPZanProvider(t *testing.T) {
|
|
client := &http.Client{Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
|
|
if got := req.URL.Query().Get("num"); got != "3" {
|
|
t.Fatalf("num=%q, want 3", got)
|
|
}
|
|
return &http.Response{
|
|
StatusCode: http.StatusOK,
|
|
Body: io.NopCloser(strings.NewReader("1.2.3.4:8001\r\n5.6.7.8:8002\r\n9.9.9.9:8003")),
|
|
Header: make(http.Header),
|
|
}, nil
|
|
})}
|
|
service := NewServiceWithProviders(client, NewIPZanProvider(), NewGenericProvider())
|
|
got, err := service.Extract(
|
|
context.Background(),
|
|
"https://service.ipzan.com/core-extract?num=1&protocol=1&secret=x",
|
|
3,
|
|
)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 3 {
|
|
t.Fatalf("len=%d, want 3", len(got))
|
|
}
|
|
if got[0].Provider != "ipzan" {
|
|
t.Fatalf("provider=%q, want ipzan", got[0].Provider)
|
|
}
|
|
}
|
|
|
|
func TestIPZanEnsureWhitelistSignsAndAdds(t *testing.T) {
|
|
const (
|
|
loginPassword = "login-pass"
|
|
secret = "extract-secret"
|
|
signKey = "0123456789abcdef"
|
|
publicIP = "1.2.3.4"
|
|
)
|
|
fixedNow := time.Unix(1700000000, 0)
|
|
var addCalled bool
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch r.URL.Path {
|
|
case "/whiteList-verify":
|
|
if r.URL.Query().Get("no") != "plan-no" || r.URL.Query().Get("ip") != publicIP {
|
|
t.Fatalf("unexpected verify query: %s", r.URL.RawQuery)
|
|
}
|
|
io.WriteString(w, `{"code":0,"data":false,"status":200,"message":""}`)
|
|
case "/whiteList-add":
|
|
addCalled = true
|
|
if err := r.ParseForm(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if r.Form.Get("replace") != "1" {
|
|
t.Fatalf("replace=%q", r.Form.Get("replace"))
|
|
}
|
|
encrypted, err := hex.DecodeString(r.Form.Get("sign"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
block, err := aes.NewCipher([]byte(signKey))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
decrypted := make([]byte, len(encrypted))
|
|
for offset := 0; offset < len(encrypted); offset += block.BlockSize() {
|
|
block.Decrypt(decrypted[offset:offset+block.BlockSize()], encrypted[offset:offset+block.BlockSize()])
|
|
}
|
|
padding := int(decrypted[len(decrypted)-1])
|
|
plain := string(decrypted[:len(decrypted)-padding])
|
|
if want := loginPassword + ":" + secret + ":1700000000"; plain != want {
|
|
t.Fatalf("sign plain=%q, want %q", plain, want)
|
|
}
|
|
io.WriteString(w, `{"code":0,"data":true,"status":200,"message":""}`)
|
|
default:
|
|
http.NotFound(w, r)
|
|
}
|
|
}))
|
|
defer server.Close()
|
|
|
|
provider := &IPZanProvider{
|
|
baseURL: server.URL,
|
|
now: func() time.Time { return fixedNow },
|
|
}
|
|
err := provider.EnsureWhitelist(
|
|
context.Background(),
|
|
server.Client(),
|
|
WhitelistConfig{
|
|
APIURL: "https://service.ipzan.com/core-extract?no=plan-no&secret=" + secret,
|
|
IP: publicIP,
|
|
LoginPassword: loginPassword,
|
|
SignKey: signKey,
|
|
ReplaceOldest: true,
|
|
},
|
|
)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !addCalled {
|
|
t.Fatal("whiteList-add was not called")
|
|
}
|
|
}
|