1.不追踪二进制文件

2.重构。完成了基本的功能。

Signed-off-by: dmy@lab <dmy@lab.com>

.gitignore

@@ -1 +1 @@
-一个加密中转程序，支持TCP和UDP。
+TransX.exe

README.md

@@ -0,0 +1 @@
+一个加密中转程序，支持TCP和UDP。

cipher/communication.go

@@ -1,15 +0,0 @@
-package cipher
-
-import (
-//	"github.com/TransX/cipher"
-)
-
-func SendData(carrier *Carrier, nByte int) (n int, err error) {
-	n, err = carrier.Conn.Write(carrier.Cache[:nByte])
-	return
-}
-
-func ReceiveData(carrier *Carrier) (n int, err error) {
-	n, err = carrier.Conn.Read(carrier.Cache)
-	return
-}

main_test.go

@@ -1,49 +1,63 @@
 package main
 
-import(
+import (
-	"testing"
+	"fmt"
 	"net"
+	"testing"
+	"time"
 )
 
-func server(){
+func server(t *testing.T) {
-	listener,err=net.Listen("tcp4","0.0.0.0:1234")
+	listener, err := net.Listen("tcp4", "127.0.0.1:1244")
-	if err!=nil{
+	if err != nil {
 		t.Fatal(err)
 	}
 	for {
-		conn,err:=listener.Accept()
+		conn, err := listener.Accept()
-		if err!=nil{
+		fmt.Println("Test Server Incoming", conn.RemoteAddr().String())
+		if err != nil {
 			t.Fatal(err)
 		}
-		bytes:=make([]byte,32)
+		bytes := make([]byte, 32)
-		n,err:=conn.Read(bytes)
+		n, err := conn.Read(bytes)
-		t.Log("Server Receive ",bytes[:n])
+		fmt.Println("Test Server Receive ", string(bytes[:n]))
-		_,err:=conn.Write([]byte("OK"))
+		_, err = conn.Write([]byte("OK"))
-		if err!=nil{
+		fmt.Println("Test Server write")
-			t.Fatail(err)
+		if err != nil {
+			t.Fatal(err)
 		}
 		conn.Close()
+		fmt.Println("Test Server closed")
 	}
 }
 
-func client(){
+func client(t *testing.T) {
-	conn,err:=net.Dial("tcp4","0.0.0.0:1234")
+	for {
-	if err!=nil{
+		conn, err := net.Dial("tcp4", "127.0.0.1:1200")
-			t.Fatail(err)
+		if err != nil {
+			t.Fatal(err)
 		}
-	for{
 		conn.Write([]byte("Client"))
-		bytes:=make([]byte,32)
+		fmt.Println("Test Client write")
-		n,err:=conn.Read(byte)
+		bytes := make([]byte, 32)
-		if err!=nil{
+		n, err := conn.Read(bytes)
+		fmt.Println("Test Client read")
+		if err != nil {
 			t.Fatal(err)
 		}
-		t.Log("Client Receive ",bytes[:n])
+		fmt.Println("Test Client Receive ", string(bytes[:n]))
+		time.Sleep(time.Second * 2)
 		conn.Close()
+		fmt.Println("Test Client closed")
+
 	}
 }
 
-func TestTunnel(t *testing.T)
+func TestTunnel(t *testing.T) {
-{
+	//	t.Log("Start testing.")
-	StartTunnel("0.0.0.0","1200","0.0.0.0",)
+	fmt.Println("Test Start testing.")
-}
+	go server(t)
+	go client(t)
+	trans := NewTransTCP()
+	trans.Start("1200", "127.0.0.1", "1244")
+}

tcp.go

@@ -1,16 +1,15 @@
 package main
 
 import (
-	"github.com/TransX/cipher"
+	"github.com/TransX/tscipher"
-	"io"
+	//	"io"
 	"log"
 	"net"
 )
 
 type TransTCP struct {
 	//	serverConn *net.Conn
-	clientConn net.Conn
+	//	clientConn net.Conn
-	listener   net.Listener
 	//	cache      []byte
 }
 
@@ -18,74 +17,88 @@ func NewTransTCP() *TransTCP {
 	return &TransTCP{}
 }
 
-func (this *TransTCP) CreateTCPClient(ip, port string) (err error) {
+func (this *TransTCP) createTCPClient(ip, port string) (conn net.Conn, err error) {
-	conn, err := net.Dial("tcp4", ip+":"+port)
+	conn, err = net.Dial("tcp4", ip+":"+port)
 	if err == nil {
-		this.clientConn = conn
+
 	} else {
-		this.clientConn = nil
+		conn = nil
 	}
 	return
 }
 
-func (this *TransTCP) CreateTCPListener(ip, port string) (err error) {
+func (this *TransTCP) createTCPListener(ip, port string) (listen net.Listener, err error) {
 	listener, _err := net.Listen("tcp4", ip+":"+port)
 	if _err == nil {
-		this.listener = listener
+		listen = listener
-		return nil
+		err = nil
+		return
 	} else {
-		return _err
+		listen = nil
+		err = _err
 	}
 	return
 }
 
-func (this *TransTCP) Start(remoteAddr chan net.Addr) (err error) {
+func (this *TransTCP) tunnel(src, dest net.Conn) {
-	cache := make([]byte, 1024*128) //128kB
+	defer func() {
-	//	this.cache = cache
+		if r := recover(); r != nil {
-	for {
+			if src != nil {
-		if listenerConn, _err := this.listener.Accept(); err == nil {
+				src.Close()
-			remoteAddr <- listenerConn.RemoteAddr()
-			//构建Carrier
-			revCarrier := &cipher.Carrier{
-				listenerConn,
-				cipher.NewCipher("default"),
-				cache,
 			}
-			sendCarrier := &cipher.Carrier{
+			if dest != nil {
-				this.clientConn,
+				dest.Close()
-				cipher.NewCipher("default"),
-				cache,
 			}
-			go func() {
-				for {
-					nByte, _err := cipher.ReceiveData(revCarrier)
-					if _err != nil {
-						if _err == io.EOF {
-							revCarrier.Conn.Close()
-							sendCarrier.Conn.Close()
-							log.Println("EOF")
-							return
-						} else {
-							log.Println(revCarrier.Conn.RemoteAddr().String(), _err)
-							return //TODO:还需要处理
-						}
-					}
-					log.Println("Received ", nByte, " From ", revCarrier.Conn.RemoteAddr().String())
-					nByte, _err = cipher.SendData(sendCarrier, nByte)
-					if _err == nil {
-						log.Println("Send ", nByte, " To ", sendCarrier.Conn.RemoteAddr().String())
-						return
-					} else {
-						log.Println(sendCarrier.Conn.RemoteAddr().String(), _err)
-					}
-				}
 
-			}()
-
-		} else {
-			err = _err
 		}
-
+	}()
+	cache := make([]byte, 1024*128) //128kB
+	for {
+		//构建Carrier
+		revCarrier := &tscipher.Carrier{
+			src,
+			tscipher.NewCipher("default"),
+			cache,
+		}
+		nByte, err := tscipher.ReceiveData(revCarrier)
+		if err != nil {
+			log.Panicln("Read panic", err, src.RemoteAddr().String())
+		}
+		log.Println("Reived ", string(cache[:nByte]))
+		sendCarrier := &tscipher.Carrier{
+			dest,
+			tscipher.NewCipher("default"),
+			cache,
+		}
+		_, err = tscipher.SendData(sendCarrier, nByte)
+		log.Println("Write")
+		if err != nil {
+			log.Panicln("Write panic", err, dest.RemoteAddr().String())
+		}
+	}
+
+}
+
+func (this *TransTCP) Start(listenPort, destIP, destPort string) {
+
+	listener, err := this.createTCPListener("0.0.0.0", listenPort)
+	if err != nil {
+		log.Fatalln("Failed to create listener.", err)
+	}
+	for {
+		if listenerConn, err := listener.Accept(); err == nil {
+			log.Println("Incoming ", listenerConn.RemoteAddr().String())
+			//创建到目标的连接
+			destConn, err := this.createTCPClient(destIP, destPort)
+			if err != nil {
+				log.Fatalln("Failed to connect to destination.", err)
+			}
+			log.Println("Dial", destConn.RemoteAddr().String())
+			go this.tunnel(listenerConn, destConn)
+			go this.tunnel(destConn, listenerConn)
+		} else {
+			log.Println("Failed to accept incoming connection.", err)
+
+		}
 	}
-	return nil
 }

tscipher/chacha.go

@@ -1,4 +1,4 @@
-package cipher
+package tscipher
 
 type ChaCha struct {
 }

tscipher/cipher.go

@@ -1,4 +1,4 @@
-package cipher
+package tscipher
 
 import (
 	"net"
@@ -21,3 +21,13 @@ func NewCipher(cipherName string) (cipher Cipher) {
 	}
 	return nil //TODO:临时这样处理
 }
+
+func SendData(carrier *Carrier, nByte int) (n int, err error) {
+	n, err = carrier.Conn.Write(carrier.Cache[:nByte])
+	return
+}
+
+func ReceiveData(carrier *Carrier) (n int, err error) {
+	n, err = carrier.Conn.Read(carrier.Cache)
+	return
+}

tscipher/communication.go

@@ -0,0 +1,5 @@
+package tscipher
+
+import (
+//	"github.com/TransX/cipher"
+)

tunnel.go

@@ -1,18 +1,18 @@
 package main
 
-func StartTunnel(sourceIP, desIP, desPort string) {
+//func StartTunnel(sourceIP, desIP, desPort string) {
-	remoteAddr := make(chan net.Addr)
+//	remoteAddr := make(chan net.Addr)
-	transSrcToDes := NewTransTCP()
+//	transSrcToDes := NewTransTCP()
-	transSrcToDes.CreateTCPListener("0.0.0.0", desPort)
+//	transSrcToDes.CreateTCPListener("0.0.0.0", desPort)
-	transSrcToDes.CreateTCPClient(desIP, desPort)
+//	transSrcToDes.CreateTCPClient(desIP, desPort)
-	go transSrcToDes.Start(remoteAddr)
+//	go transSrcToDes.Start(remoteAddr)
-	sourcePort := <-remoteAddr
+//	sourcePort := <-remoteAddr
-	transDesToSrc := NewTransTCP()
+//	transDesToSrc := NewTransTCP()
-	transDesToSrc.CreateTCPListener("0.0.0.0", sourcePort)
+//	transDesToSrc.CreateTCPListener("0.0.0.0", sourcePort)
-	transSrcToDes.CreateTCPClient(sourceIP, sourcePort)
+//	transSrcToDes.CreateTCPClient(sourceIP, sourcePort)
 
-	go transDesToSrc.Start()
+//	go transDesToSrc.Start()
-	c := make(chan byte)
+//	c := make(chan byte)
-	<-c
+//	<-c
 
-}
+//}