update

Hunter0x7c7

2022-08-11 b8230139fb40edea387617b6accd8371e37eda58

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
package scenarios 
 
import ( 
    "fmt" 
    "testing" 
    "time" 
 
    xproxy "golang.org/x/net/proxy" 
    "google.golang.org/protobuf/types/known/anypb" 
 
    core "github.com/v2fly/v2ray-core/v5" 
    "github.com/v2fly/v2ray-core/v5/app/dns" 
    "github.com/v2fly/v2ray-core/v5/app/proxyman" 
    "github.com/v2fly/v2ray-core/v5/app/router" 
    "github.com/v2fly/v2ray-core/v5/app/router/routercommon" 
    "github.com/v2fly/v2ray-core/v5/common" 
    "github.com/v2fly/v2ray-core/v5/common/net" 
    "github.com/v2fly/v2ray-core/v5/common/serial" 
    "github.com/v2fly/v2ray-core/v5/proxy/blackhole" 
    "github.com/v2fly/v2ray-core/v5/proxy/freedom" 
    "github.com/v2fly/v2ray-core/v5/proxy/socks" 
    "github.com/v2fly/v2ray-core/v5/testing/servers/tcp" 
) 
 
func TestResolveIP(t *testing.T) { 
    tcpServer := tcp.Server{ 
        MsgProcessor: xor, 
    } 
    dest, err := tcpServer.Start() 
    common.Must(err) 
    defer tcpServer.Close() 
 
    serverPort := tcp.PickPort() 
    serverConfig := &core.Config{ 
        App: []*anypb.Any{ 
            serial.ToTypedMessage(&dns.Config{ 
                Hosts: map[string]*net.IPOrDomain{ 
                    "google.com": net.NewIPOrDomain(dest.Address), 
                }, 
            }), 
            serial.ToTypedMessage(&router.Config{ 
                DomainStrategy: router.DomainStrategy_IpIfNonMatch, 
                Rule: []*router.RoutingRule{ 
                    { 
                        Cidr: []*routercommon.CIDR{ 
                            { 
                                Ip:     []byte{127, 0, 0, 0}, 
                                Prefix: 8, 
                            }, 
                        }, 
                        TargetTag: &router.RoutingRule_Tag{ 
                            Tag: "direct", 
                        }, 
                    }, 
                }, 
            }), 
        }, 
        Inbound: []*core.InboundHandlerConfig{ 
            { 
                ReceiverSettings: serial.ToTypedMessage(&proxyman.ReceiverConfig{ 
                    PortRange: net.SinglePortRange(serverPort), 
                    Listen:    net.NewIPOrDomain(net.LocalHostIP), 
                }), 
                ProxySettings: serial.ToTypedMessage(&socks.ServerConfig{ 
                    AuthType: socks.AuthType_NO_AUTH, 
                    Accounts: map[string]string{ 
                        "Test Account": "Test Password", 
                    }, 
                    Address:    net.NewIPOrDomain(net.LocalHostIP), 
                    UdpEnabled: false, 
                }), 
            }, 
        }, 
        Outbound: []*core.OutboundHandlerConfig{ 
            { 
                ProxySettings: serial.ToTypedMessage(&blackhole.Config{}), 
            }, 
            { 
                Tag: "direct", 
                ProxySettings: serial.ToTypedMessage(&freedom.Config{ 
                    DomainStrategy: freedom.Config_USE_IP, 
                }), 
            }, 
        }, 
    } 
 
    servers, err := InitializeServerConfigs(serverConfig) 
    common.Must(err) 
    defer CloseAllServers(servers) 
 
    { 
        noAuthDialer, err := xproxy.SOCKS5("tcp", net.TCPDestination(net.LocalHostIP, serverPort).NetAddr(), nil, xproxy.Direct) 
        common.Must(err) 
        conn, err := noAuthDialer.Dial("tcp", fmt.Sprintf("google.com:%d", dest.Port)) 
        common.Must(err) 
        defer conn.Close() 
 
        if err := testTCPConn2(conn, 1024, time.Second*5)(); err != nil { 
            t.Error(err) 
        } 
    } 
}