github.com/ipfans/trojan-go@v0.11.0/tunnel/trojan/trojan_test.go (about)

     1  package trojan
     2  
     3  import (
     4  	"bytes"
     5  	"context"
     6  	"fmt"
     7  	"io"
     8  	"net"
     9  	"testing"
    10  
    11  	"github.com/ipfans/trojan-go/common"
    12  	"github.com/ipfans/trojan-go/config"
    13  	"github.com/ipfans/trojan-go/statistic/memory"
    14  	"github.com/ipfans/trojan-go/test/util"
    15  	"github.com/ipfans/trojan-go/tunnel"
    16  	"github.com/ipfans/trojan-go/tunnel/freedom"
    17  	"github.com/ipfans/trojan-go/tunnel/transport"
    18  )
    19  
    20  func TestTrojan(t *testing.T) {
    21  	port := common.PickPort("tcp", "127.0.0.1")
    22  	transportConfig := &transport.Config{
    23  		LocalHost:  "127.0.0.1",
    24  		LocalPort:  port,
    25  		RemoteHost: "127.0.0.1",
    26  		RemotePort: port,
    27  	}
    28  	ctx, cancel := context.WithCancel(context.Background())
    29  	ctx = config.WithConfig(ctx, transport.Name, transportConfig)
    30  	ctx = config.WithConfig(ctx, freedom.Name, &freedom.Config{})
    31  	tcpClient, err := transport.NewClient(ctx, nil)
    32  	common.Must(err)
    33  	tcpServer, err := transport.NewServer(ctx, nil)
    34  	common.Must(err)
    35  
    36  	serverPort := common.PickPort("tcp", "127.0.0.1")
    37  	authConfig := &memory.Config{Passwords: []string{"password"}}
    38  	clientConfig := &Config{
    39  		RemoteHost: "127.0.0.1",
    40  		RemotePort: serverPort,
    41  	}
    42  	serverConfig := &Config{
    43  		LocalHost:  "127.0.0.1",
    44  		LocalPort:  serverPort,
    45  		RemoteHost: "127.0.0.1",
    46  		RemotePort: util.EchoPort,
    47  	}
    48  
    49  	ctx = config.WithConfig(ctx, memory.Name, authConfig)
    50  	clientCtx := config.WithConfig(ctx, Name, clientConfig)
    51  	serverCtx := config.WithConfig(ctx, Name, serverConfig)
    52  	c, err := NewClient(clientCtx, tcpClient)
    53  	common.Must(err)
    54  	s, err := NewServer(serverCtx, tcpServer)
    55  	common.Must(err)
    56  	conn1, err := c.DialConn(&tunnel.Address{
    57  		DomainName:  "example.com",
    58  		AddressType: tunnel.DomainName,
    59  	}, nil)
    60  	common.Must(err)
    61  	common.Must2(conn1.Write([]byte("87654321")))
    62  	conn2, err := s.AcceptConn(nil)
    63  	common.Must(err)
    64  	buf := [8]byte{}
    65  	conn2.Read(buf[:])
    66  	if !util.CheckConn(conn1, conn2) {
    67  		t.Fail()
    68  	}
    69  
    70  	packet1, err := c.DialPacket(nil)
    71  	common.Must(err)
    72  	packet1.WriteWithMetadata([]byte("12345678"), &tunnel.Metadata{
    73  		Address: &tunnel.Address{
    74  			DomainName:  "example.com",
    75  			AddressType: tunnel.DomainName,
    76  			Port:        80,
    77  		},
    78  	})
    79  	packet2, err := s.AcceptPacket(nil)
    80  	common.Must(err)
    81  
    82  	_, m, err := packet2.ReadWithMetadata(buf[:])
    83  	common.Must(err)
    84  
    85  	fmt.Println(m)
    86  
    87  	if !util.CheckPacketOverConn(packet1, packet2) {
    88  		t.Fail()
    89  	}
    90  
    91  	// redirecting
    92  	conn, err := net.Dial("tcp", fmt.Sprintf("127.0.0.1:%d", port))
    93  	common.Must(err)
    94  	sendBuf := util.GeneratePayload(1024)
    95  	recvBuf := [1024]byte{}
    96  	common.Must2(conn.Write(sendBuf))
    97  	common.Must2(io.ReadFull(conn, recvBuf[:]))
    98  	if !bytes.Equal(sendBuf, recvBuf[:]) {
    99  		fmt.Println(sendBuf)
   100  		fmt.Println(recvBuf[:])
   101  		t.Fail()
   102  	}
   103  	conn1.Close()
   104  	conn2.Close()
   105  	packet1.Close()
   106  	packet2.Close()
   107  	conn.Close()
   108  	c.Close()
   109  	s.Close()
   110  	cancel()
   111  }