facat
/
transx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

1.不追踪二进制文件 

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

Signed-off-by: dmy@lab <dmy@lab.com>
This commit is contained in:
dmy@lab 2015-10-08 23:11:07 +08:00
parent fc533656a0
commit 9c4dafc07d
10 changed files with 142 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

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

1
README.md Normal file
View File

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

BIN
TransX.exe
View File

Binary file not shown.

15
cipher/communication.go
View File

@ -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
}

64
main_test.go
View File

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

133
tcp.go
View File

@ -1,16 +1,15 @@
package main
import (
"github.com/TransX/cipher"
"io"
"github.com/TransX/tscipher"
// "io"
"log"
"net"
)
type TransTCP struct {
// serverConn *net.Conn
clientConn net.Conn
listener net.Listener
// clientConn net.Conn
// cache []byte
}
@ -18,74 +17,88 @@ func NewTransTCP() *TransTCP {
return &TransTCP{}
}
func (this *TransTCP) CreateTCPClient(ip, port string) (err error) {
conn, err := net.Dial("tcp4", ip+":"+port)
func (this *TransTCP) createTCPClient(ip, port string) (conn net.Conn, err error) {
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
return nil
} else {
return _err
}
return
}
func (this *TransTCP) Start(remoteAddr chan net.Addr) (err error) {
cache := make([]byte, 1024*128) //128kB
// this.cache = cache
for {
if listenerConn, _err := this.listener.Accept(); err == nil {
remoteAddr <- listenerConn.RemoteAddr()
//构建Carrier
revCarrier := &cipher.Carrier{
listenerConn,
cipher.NewCipher("default"),
cache,
}
sendCarrier := &cipher.Carrier{
this.clientConn,
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")
listen = listener
err = nil
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 {
listen = nil
err = _err
}
return
}
func (this *TransTCP) tunnel(src, dest net.Conn) {
defer func() {
if r := recover(); r != nil {
if src != nil {
src.Close()
}
if dest != nil {
dest.Close()
}
}
return nil
}()
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)
}
}
}

2
cipher/chacha.go → tscipher/chacha.go
View File

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

12
cipher/cipher.go → tscipher/cipher.go
View File

@ -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
}

5
tscipher/communication.go Normal file
View File

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

28
tunnel.go
View File

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