Merge remote-tracking branch 'origin/master' into extensions_cmd_improvements

.dockerignore

@@ -1,9 +1,4 @@
-# go-assets.sh downloads
 /server/assets/fs/**.zip
-/server/assets/fs/**/garble*
-/server/assets/fs/**/zig.tar.xz
-/server/assets/fs/**/zig.zip
-/server/assets/fs/src.zip
 
 /*.sdk.tar.xz
 
@@ -24,5 +19,3 @@
 /SECURITY.md
 /README.md
 /CONTRIBUTING.md
-
-.downloaded_assets

.github/CODEOWNERS

@@ -1 +1 @@
-* @BishopFox/bf-red-team
+* @BishopFox/red-team

.github/workflows/autorelease.yml

@@ -2,101 +2,136 @@ name: Release
 
 on:
   push:
-    tags:
-      - "v*.*.*"
-
-permissions:
-  contents: write
+    branches: [master]
 
 jobs:
-  tag-check:
-    name: Check Release Tag
+  servers-build:
+    name: Release Build Server
+    if: startsWith( github.ref, 'refs/tags/v')
     runs-on: ubuntu-latest
-    timeout-minutes: 30
-    outputs:
-      tag: ${{ steps.tag.outputs.tag }}
-    steps:
-      - name: Check Out Code
-        uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-
-      - name: Validate Release Tag
-        id: tag
-        run: |
-          git fetch --prune --tags -f origin
-          tag="${GITHUB_REF_NAME}"
-
-          if ! printf '%s\n' "$tag" | grep -Eq '^v[0-9]+\.[0-9]+\.[0-9]+$'; then
-            echo "Tag $tag is not a release semver tag."
-            exit 0
-          fi
-
-          if ! git merge-base --is-ancestor "$GITHUB_SHA" "origin/master"; then
-            echo "Tag $tag does not point to a commit on origin/master."
-            exit 0
-          fi
-
-          echo "tag=$tag" >> "$GITHUB_OUTPUT"
-
-  release:
-    name: Release
-    needs: tag-check
-    if: needs.tag-check.outputs.tag != ''
-    runs-on: ubuntu-latest
-    environment: release
     timeout-minutes: 45
     steps:
+      - name: Go 1.21
+        uses: actions/setup-go@v5
+        with:
+          go-version: "^1.21"
+
+      - name: OS Packages
+        run: |
+          sudo apt-get update --fix-missing && sudo apt-get -y install \
+          git build-essential zlib1g zlib1g-dev wget zip unzip
+
       - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
+
+      - name: Git Fetch Tags
+        run: git fetch --prune --unshallow --tags -f
+
+      - name: Make
+        run: make servers
+
+      - name: Server Artifacts
+        uses: actions/upload-artifact@v4
         with:
-          fetch-depth: 0
+          name: servers
+          path: ./sliver-server_*
 
-      - name: Go 1.26.6
-        uses: actions/setup-go@v6
+  clients-build:
+    name: Release Build Client
+    if: startsWith( github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    steps:
+      - name: Go 1.22
+        uses: actions/setup-go@v5
         with:
-          go-version: "1.26.6"
+          go-version: "^1.22"
 
-      - name: Install Minisign
-        run: sudo apt-get update --fix-missing && sudo apt-get -y install minisign
+      - name: Check Out Code
+        uses: actions/checkout@v4
 
-      - name: Build Clients
+      - name: Git Fetch Tags
+        run: git fetch --prune --unshallow --tags -f
+
+      - name: Make
+        run: make clients
+
+      - name: Client Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: clients
+          path: ./sliver-client_*
+
+  tagged-release:
+    needs: [servers-build, clients-build]
+
+    name: "Tagged Release"
+    if: startsWith( github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+
+    steps:
+      - run: mkdir -p ./builds
+      - uses: actions/download-artifact@v4
+        with:
+          path: ./builds
+
+      - name: Extract Artifacts
         run: |
-          make clients
-          mkdir -p artifacts
-          mv sliver-client_* artifacts/
+          mkdir -p ./artifacts
+          cp ./builds/clients/* ./artifacts
+          cp ./builds/servers/* ./artifacts
 
-      - name: Build Servers
+      - name: GPG Key(s)
         run: |
-          make servers
-          mv sliver-server_* artifacts/
+          cat <(echo -e "${{ secrets.SLIVER_GPG }}") | gpg --batch --import
+          gpg --list-secret-keys --keyid-format LONG
 
-      - name: Sign Artifacts
-        env:
-          MINISIGN_KEY: ${{ secrets.MINISIGN_SLIVER_RELEASE_KEY }}
+      # Linux
+      - name: Linux 386 (Client Only)
         run: |
-          echo "$MINISIGN_KEY" | base64 -d > minisign.key
-          echo "minisign.key bytes: $(wc -c < minisign.key | tr -d ' ')"
-          echo "minisign.key sha256: $(sha256sum minisign.key | awk '{print $1}')"
-          chmod 600 minisign.key
-          for file in artifacts/sliver-*; do
-            [ -f "$file" ] || continue
-            minisign -S -s minisign.key -m "$file" -x "$file.minisig" -W
-          done
-          rm -f minisign.key
-
-      - name: Create Release
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_linux-386.sig --detach-sig ./artifacts/sliver-client_linux-386
+      - name: Linux AMD64
         run: |
-          tag="${{ needs.tag-check.outputs.tag }}"
-          if gh release view "$tag" >/dev/null 2>&1; then
-            echo "Release $tag already exists."
-            exit 0
-          fi
-          gh release create "$tag" --generate-notes
+          gpg --default-key 4449039C --output ./artifacts/sliver-server_linux-amd64.sig --detach-sig ./artifacts/sliver-server_linux-amd64
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_linux-amd64.sig --detach-sig ./artifacts/sliver-client_linux-amd64
+      - name: Linux ARM64
+        run: |
+          gpg --default-key 4449039C --output ./artifacts/sliver-server_linux-arm64.sig --detach-sig ./artifacts/sliver-server_linux-arm64
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_linux-arm64.sig --detach-sig ./artifacts/sliver-client_linux-arm64
 
-      - name: Upload Artifacts
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: gh release upload "${{ needs.tag-check.outputs.tag }}" artifacts/* --clobber
+      # Windows
+      - name: Windows 386 (Client Only)
+        run: |
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_windows-386.sig --detach-sig ./artifacts/sliver-client_windows-386.exe
+      - name: Windows AMD64
+        run: |
+          gpg --default-key 4449039C --output ./artifacts/sliver-server_windows-amd64.sig --detach-sig ./artifacts/sliver-server_windows-amd64.exe
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_windows-amd64.sig --detach-sig ./artifacts/sliver-client_windows-amd64.exe
+      - name: Windows ARM64 (Client Only)
+        run: |
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_windows-arm64.sig --detach-sig ./artifacts/sliver-client_windows-arm64.exe
+
+      # MacOS
+      - name: MacOS AMD64
+        run: |
+          gpg --default-key 4449039C --output ./artifacts/sliver-server_macos-amd64.sig --detach-sig ./artifacts/sliver-server_macos-amd64
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_macos-amd64.sig --detach-sig ./artifacts/sliver-client_macos-amd64
+      - 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
+
+      # FreeBSD
+      - name: FreeBSD AMD64 (Client Only)
+        run: |
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_freebsd-amd64.sig --detach-sig ./artifacts/sliver-client_freebsd-amd64.exe
+      - name: FreeBSD ARM64 (Client Only)
+        run: |
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_freebsd-arm64.sig --detach-sig ./artifacts/sliver-client_freebsd-arm64.exe
+
+      - name: "Publish Release"
+        uses: "bishopfox/action-gh-release@v1"
+        with:
+          files: |
+            ./artifacts/*

.github/workflows/codeql-scanning.yml

@@ -16,13 +16,13 @@ jobs:
 
     steps:
       # Setup go environment
-      - name: Go 1.26.6
-        uses: actions/setup-go@v6
+      - name: Go 1.22
+        uses: actions/setup-go@v5
         with:
-          go-version: "1.26.6"
+          go-version: "^1.22"
 
       - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           # Must fetch at least the immediate parents so that if this is
           # a pull request then we can checkout the head of the pull request.
@@ -36,10 +36,10 @@ jobs:
           git build-essential zlib1g zlib1g-dev wget zip unzip
 
       - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v4
+        uses: github/codeql-action/init@v3
         with:
           config-file: ./.github/codeql/codeql-config.yml
           languages: go
@@ -48,6 +48,6 @@ jobs:
         run: make
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v4
+        uses: github/codeql-action/analyze@v3
         env:
           VERSION: ${{github.sha}}

.github/workflows/docs.yml

@@ -35,7 +35,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Detect package manager
         id: detect-package-manager
@@ -56,7 +56,7 @@ jobs:
           fi
 
       - name: Setup Node
-        uses: actions/setup-node@v6
+        uses: actions/setup-node@v4
         with:
           cache: "npm"
           cache-dependency-path: "**/package-lock.json"
@@ -66,7 +66,7 @@ jobs:
         uses: actions/configure-pages@v5
 
       - name: Restore cache
-        uses: actions/cache@v5
+        uses: actions/cache@v4
         with:
           path: |
             .next/cache
@@ -85,7 +85,7 @@ jobs:
         run: ${{ steps.detect-package-manager.outputs.runner }} next build
 
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v4
+        uses: actions/upload-pages-artifact@v3
         with:
           path: ${{ github.workspace }}/docs/sliver-docs/out
 

.github/workflows/golangci-lint.yml

@@ -1,56 +0,0 @@
-name: golangci-lint
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-    paths:
-      - ".golangci.yml"
-      - ".github/workflows/golangci-lint.yml"
-      - "go.mod"
-      - "go.sum"
-      - "go.work"
-      - "go.work.sum"
-      - "Makefile"
-      - "vendor/**"
-      - "**/*.go"
-
-permissions:
-  contents: read
-  pull-requests: read
-
-jobs:
-  lint:
-    name: golangci-lint (${{ matrix.goos }})
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    strategy:
-      fail-fast: false
-      matrix:
-        goos:
-          - linux
-          - darwin
-          - windows
-    env:
-      GOOS: ${{ matrix.goos }}
-      GOARCH: amd64
-      CGO_ENABLED: "0"
-    steps:
-      - name: Check Out Code
-        uses: actions/checkout@v6
-
-      - name: Go 1.26.6
-        uses: actions/setup-go@v6
-        with:
-          go-version: "1.26.6"
-
-      - name: Run golangci-lint
-        uses: golangci/golangci-lint-action@v9
-        with:
-          version: v2.12.2
-          # Keep legacy findings visible without making them blockers.
-          only-new-issues: true
-          args: ./client/... ./server/... ./util/... ./protobuf/... ./docs ./implant/...

.github/workflows/unit-tests.yml

@@ -6,13 +6,11 @@ on:
     paths:
       - "go.mod"
       - "go.sum"
-      - ".github/workflows/unit-tests.yml"
       - "Makefile"
       - "**/*.go"
       - "**/*.c"
       - "**/*.h"
       - "**/*.sh"
-      - "**/*.ps1"
     types:
       - opened
       - reopened
@@ -20,15 +18,15 @@ on:
       - ready_for_review
 
 jobs:
-  linux-build-test:
-    name: Linux Build & Test
+  linux-windows-build-test:
+    name: Linux & Windows Test
     runs-on: ubuntu-latest
-    timeout-minutes: 180
+    timeout-minutes: 90
     steps:
-      - name: Go 1.26.6
-        uses: actions/setup-go@v6
+      - name: Go 1.22
+        uses: actions/setup-go@v5
         with:
-          go-version: "1.26.6"
+          go-version: "^1.22"
 
       - name: OS Packages
         run: |
@@ -36,92 +34,38 @@ jobs:
           git build-essential zlib1g zlib1g-dev wget zip unzip
 
       - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Git Fetch Tags
         run: git fetch --prune --unshallow --tags -f
 
+      - name: Make Linux (amd64)
+        run: make linux-amd64
+
+      - name: Test Linux
+        run: ./sliver-server unpack --force && ./go-tests.sh
+
       - name: Make Windows (amd64)
         run: make windows-amd64
 
       - name: Make Linux (arm64)
         run: make linux-arm64
 
-      - name: Make Linux (amd64)
-        run: make linux-amd64
-
-      - name: Determine go-tests flags
-        id: go-tests-flags
-        shell: bash
-        run: |
-          set -euo pipefail
-          base_sha="${{ github.event.pull_request.base.sha }}"
-          head_sha="${{ github.sha }}"
-          if git diff --name-only "$base_sha" "$head_sha" | grep -qE '^(implant/|server/gogo/|server/generate/)'; then
-            echo "args=" >> "$GITHUB_OUTPUT"
-          else
-            echo "args=--skip-generate" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Test Linux
-        run: make clean && make && ./sliver-server unpack --force && ./go-tests.sh ${{ steps.go-tests-flags.outputs.args }}
-
-  windows-build-test:
-    name: Windows Build & Test
-    runs-on: windows-latest
-    timeout-minutes: 180
-    steps:
-      - name: Go 1.26.6
-        uses: actions/setup-go@v6
-        with:
-          go-version: "1.26.6"
-
-      - name: Install make
-        run: choco install make -y --no-progress
-
-      - name: Check Out Code
-        uses: actions/checkout@v6
-
-      - name: Git Fetch Tags
-        run: git fetch --prune --unshallow --tags -f
-
-      - name: Make Windows (amd64)
-        run: make windows-amd64
-
-      - name: Determine go-tests flags
-        id: go-tests-flags
-        shell: pwsh
-        run: |
-          $baseSha = "${{ github.event.pull_request.base.sha }}"
-          $headSha = "${{ github.sha }}"
-          $changedFiles = git diff --name-only $baseSha $headSha
-
-          if ($changedFiles | Select-String -Pattern '^(implant/|server/gogo/|server/generate/)') {
-            "args=" | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
-          } else {
-            "args=--skip-generate" | Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
-          }
-
-      - name: Test Windows
-        shell: pwsh
-        run: |
-          make clean
-          make
-          ./go-tests.ps1 ${{ steps.go-tests-flags.outputs.args }}
-
-
   macos-build-test:
     name: MacOS Test
     runs-on: macos-latest
-    timeout-minutes: 180
+    timeout-minutes: 90
     steps:
-      - name: Go 1.26.6
-        uses: actions/setup-go@v6
+      - name: Go 1.22
+        uses: actions/setup-go@v5
         with:
-          go-version: "1.26.6"
+          go-version: "^1.22"
+
+      - name: Mingw
+        run: brew install mingw-w64
 
       - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Git Fetch Tags
         run: git fetch --prune --unshallow --tags -f
@@ -129,37 +73,24 @@ jobs:
       - name: Make MacOS (amd64)
         run: make macos-amd64
 
+      - name: Test MacOS (amd64)
+        run: ./sliver-server unpack --force && ./go-tests.sh
+
       - name: Make MacOS (arm64)
         run: make macos-arm64
 
-      - name: Determine go-tests flags
-        id: go-tests-flags
-        shell: bash
-        run: |
-          set -euo pipefail
-          base_sha="${{ github.event.pull_request.base.sha }}"
-          head_sha="${{ github.sha }}"
-          if git diff --name-only "$base_sha" "$head_sha" | grep -qE '^(implant/|server/gogo/|server/generate/)'; then
-            echo "args=" >> "$GITHUB_OUTPUT"
-          else
-            echo "args=--skip-generate" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Test MacOS
-        run: make clean && make && ./sliver-server unpack --force && ./go-tests.sh ${{ steps.go-tests-flags.outputs.args }}
-
   clients-build:
     name: Clients Build
     runs-on: ubuntu-latest
     timeout-minutes: 90
     steps:
-      - name: Go 1.26.6
-        uses: actions/setup-go@v6
+      - name: Go 1.22
+        uses: actions/setup-go@v5
         with:
-          go-version: "1.26.6"
+          go-version: "^1.22"
 
       - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Git Fetch Tags
         run: git fetch --prune --unshallow --tags -f

.gitignore

@@ -1,17 +1,7 @@
-/crush
-
-/examples
-
-/.vscode
 /.vscode/*
 /.devcontainer
 /.idea
 
-/artifacts
-/artifacts/**
-
-*.rc
-
 /Dockerfile.*
 /*.sdk.tar.xz
 
@@ -55,8 +45,6 @@ sliver-server-windows.zip
 .DS_Store
 
 dist/
-.gocache/
-.gomodcache/
 
 # Flag to show that go-assets.sh has been run
 .downloaded_assets

.golangci.yml

@@ -1,27 +0,0 @@
-version: "2"
-
-run:
-  timeout: 10m
-  modules-download-mode: vendor
-  build-tags:
-    - client
-    - server
-    - osusergo
-    - netgo
-    - go_sqlite
-    # Raw implant entry points are Go templates; lint their supporting packages.
-    - sliver_lint
-
-linters:
-  default: standard
-  enable:
-    - gocyclo
-    - misspell
-    - revive
-  settings:
-    gocyclo:
-      min-complexity: 15
-
-formatters:
-  enable:
-    - gofmt

AGENTS.md

@@ -1,18 +0,0 @@
-# Repository Guidelines
-
-## Build, Test, and Development Commands
-- `make` builds server + client using vendored modules and runs `go-assets.sh`.
-- `make client` builds a CGO-free client; `make debug` keeps symbols.
-- `make pb` regenerates protobuf stubs from `protobuf/`.
-- `./go-tests.sh` runs the Go test suite, this is the only way you should run unit tests.
-- Docs site: `cd docs/sliver-docs && npm install && npm run dev` for local dev; `npm run build` for a static build.
-
-## Coding Style & Naming Conventions
-- Run `gofmt` on all Go code; keep package names lowercase and idiomatic.
-- Avoid `CGO` and empty interfaces; prefer explicit types and interfaces.
-- Do not import `server` packages from `client`.
-
-## Testing Guidelines
-- Prefer `docker build --target test --build-arg GO_TESTS_FLAGS=--skip-generate .` 
-- Add or update tests when behavior changes; some server packages run longer tests.
-

Dockerfile

@@ -5,12 +5,11 @@
 #
 # For unit testing:
 #   docker build --target test .
-#   docker build --target test --build-arg GO_TESTS_FLAGS=--skip-generate .
 #
 
 # STAGE: base
 ## Compiles Sliver for use
-FROM golang:latest AS base
+FROM golang:1.22.5 AS base
 
 ### Base packages
 RUN apt-get update --fix-missing && apt-get -y install \
@@ -21,10 +20,10 @@ RUN groupadd -g 999 sliver && useradd -r -u 999 -g sliver sliver
 RUN mkdir -p /home/sliver/ && chown -R sliver:sliver /home/sliver
 
 ### Build sliver:
-RUN mkdir -p /go/src/github.com/bishopfox/sliver
 WORKDIR /go/src/github.com/bishopfox/sliver
 ADD . /go/src/github.com/bishopfox/sliver/
-RUN make
+RUN make clean-all 
+RUN make 
 RUN cp -vv sliver-server /opt/sliver-server 
 
 # STAGE: test
@@ -32,9 +31,6 @@ RUN cp -vv sliver-server /opt/sliver-server
 ## Use `--target test` in the docker build command to run this stage
 FROM base AS test
 
-ARG GO_TESTS_FLAGS=""
-ENV GO_TESTS_FLAGS="${GO_TESTS_FLAGS}"
-
 RUN apt-get update --fix-missing \
     && apt-get -y upgrade \
     && apt-get -y install \
@@ -43,7 +39,7 @@ RUN apt-get update --fix-missing \
 RUN /opt/sliver-server unpack --force 
 
 ### Run unit tests
-RUN /go/src/github.com/bishopfox/sliver/go-tests.sh ${GO_TESTS_FLAGS}
+RUN /go/src/github.com/bishopfox/sliver/go-tests.sh
 
 # STAGE: production
 ## Final dockerized form of Sliver
@@ -95,7 +91,7 @@ ENTRYPOINT [ "/opt/sliver-server" ]
 
 
 # STAGE: production-slim (about 1Gb smaller)
-FROM debian:bookworm-slim AS production-slim
+FROM debian:bookworm-slim as production-slim
 
 ### Install production packages
 RUN apt-get update --fix-missing \

Makefile

@@ -2,330 +2,202 @@
 # Makefile for Sliver
 #
 
-.DEFAULT_GOAL := default
-
 GO ?= go
-ARTIFACT_SUFFIX ?=
+ARTIFACT_SUFFIX ?= 
 ENV =
 TAGS ?= -tags go_sqlite
 CGO_ENABLED = 0
-GOLANGCI_LINT ?= golangci-lint
-# The tree has legacy lint findings, so gate issues introduced by this change.
-GOLANGCI_LINT_BASE ?= master
-GOLANGCI_LINT_ARGS ?= --new-from-merge-base=$(GOLANGCI_LINT_BASE)
-GOLANGCI_LINT_PACKAGES = \
-	./client/... \
-	./server/... \
-	./util/... \
-	./protobuf/... \
-	./docs \
-	./implant/...
 
 ifneq (,$(findstring cgo_sqlite,$(TAGS)))
 	CGO_ENABLED = 1
 endif
 
-MIN_SUPPORTED_GO_MAJOR_VERSION = 1
-MIN_SUPPORTED_GO_MINOR_VERSION = 26
-GO_VERSION_VALIDATION_ERR_MSG = Golang version is not supported, please update to at least $(MIN_SUPPORTED_GO_MAJOR_VERSION).$(MIN_SUPPORTED_GO_MINOR_VERSION)
-
-SLIVER_PUBLIC_KEY ?= RWTZPg959v3b7tLG7VzKHRB1/QT+d3c71Uzetfa44qAoX5rH7mGoQTTR
-ARMORY_PUBLIC_KEY ?= RWSBpxpRWDrD7Fe+VvRE3c2VEDC2NK80rlNCj+BX0gz44Xw07r6KQD9L
-ARMORY_REPO_URL ?= https://api.github.com/repos/sliverarmory/armory/releases
-CLIENT_ASSETS_PKG = github.com/bishopfox/sliver/client/assets
-SLIVER_UPDATE_PKG = github.com/bishopfox/sliver/client/command/update
-PB_COMPILERS = protoc protoc-gen-go protoc-gen-go-grpc
-
-.PHONY: lint
-lint:
-	$(GOLANGCI_LINT) run $(GOLANGCI_LINT_ARGS) $(GOLANGCI_LINT_PACKAGES)
-
-ifneq ($(OS),Windows_NT)
+#
+# Prerequisites 
+#
+# https://stackoverflow.com/questions/5618615/check-if-a-program-exists-from-a-makefile
+EXECUTABLES = uname sed git zip date cut $(GO)
+K := $(foreach exec,$(EXECUTABLES),\
+        $(if $(shell which $(exec)),some string,$(error "No $(exec) in PATH")))
 
 #
-# Prerequisites
+# Version Information
 #
-# https://stackoverflow.com/questions/5618615/check-if-a-program-exists-from-a-makefile
-EXECUTABLES = uname sed git date cut $(GO)
-K := $(foreach exec,$(EXECUTABLES),\
-        $(if $(shell which $(exec)),some string,$(error "No $(exec) in PATH")))
-
-#
-# Build Information
-#
+GO_VERSION = $(shell $(GO) version)
 GO_MAJOR_VERSION = $(shell $(GO) version | cut -c 14- | cut -d' ' -f1 | cut -d'.' -f1)
 GO_MINOR_VERSION = $(shell $(GO) version | cut -c 14- | cut -d' ' -f1 | cut -d'.' -f2)
+MIN_SUPPORTED_GO_MAJOR_VERSION = 1
+MIN_SUPPORTED_GO_MINOR_VERSION = 21
+GO_VERSION_VALIDATION_ERR_MSG = Golang version is not supported, please update to at least $(MIN_SUPPORTED_GO_MAJOR_VERSION).$(MIN_SUPPORTED_GO_MINOR_VERSION)
+
+VERSION ?= $(shell git describe --abbrev=0)
+COMPILED_AT = $(shell date +%s)
+RELEASES_URL ?= https://api.github.com/repos/BishopFox/sliver/releases
+ARMORY_PUBLIC_KEY ?= RWSBpxpRWDrD7Fe+VvRE3c2VEDC2NK80rlNCj+BX0gz44Xw07r6KQD9L
+ARMORY_REPO_URL ?= https://api.github.com/repos/sliverarmory/armory/releases
+VERSION_PKG = github.com/bishopfox/sliver/client/version
+CLIENT_ASSETS_PKG = github.com/bishopfox/sliver/client/assets
+
+GIT_DIRTY = $(shell git diff --quiet|| echo 'Dirty')
+GIT_COMMIT = $(shell git rev-parse HEAD)
 
 LDFLAGS = -ldflags "-s -w \
-	-X $(SLIVER_UPDATE_PKG).SliverPublicKey=$(SLIVER_PUBLIC_KEY) \
+	-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_PUBLIC_KEY) \
-	-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
-
-# Debug builds shouldn't be stripped (-s -w flags)
-LDFLAGS_DEBUG = -ldflags "-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUBLIC_KEY) \
-	-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
-
-SED_INPLACE := sed -i
-STATIC_TARGET := linux
-
+	-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
+
+# Debug builds shouldn'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_PUBLIC_KEY) \
+	-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
+
+SED_INPLACE := sed -i
+STATIC_TARGET := linux
+
 UNAME_S := $(shell uname -s)
 UNAME_P := $(shell uname -p)
 
 # Programs required for generating protobuf/grpc files
+PB_COMPILERS = protoc protoc-gen-go protoc-gen-go-grpc
 ifeq ($(MAKECMDGOALS), pb)
 	K := $(foreach exec,$(PB_COMPILERS),\
 			$(if $(shell which $(exec)),some string,$(error "Missing protobuf util $(exec) in PATH")))
 endif
-
-# *** Darwin ***
-ifeq ($(UNAME_S),Darwin)
-	SED_INPLACE := sed -i ''
-	STATIC_TARGET := macos
-endif
-
-# If no target is specified, determine GOARCH
-ifeq ($(UNAME_P),arm)
-	ifeq ($(MAKECMDGOALS), )
-		ifeq ($(origin GOARCH), undefined)
-			ENV += GOARCH=arm64
-		endif
-	endif
-endif
-
-ifeq ($(MAKECMDGOALS), linux)
-	# Redefine LDFLAGS to add the static part
-	LDFLAGS = -ldflags "-s -w \
-		-extldflags '-static' \
-		-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUBLIC_KEY) \
-		-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
-endif
-
-#
-# Targets
-#
-.PHONY: default
-default: clean validate-go-version
-	env -u GOOS -u GOARCH $(MAKE) GOOS= GOARCH= .downloaded_assets
-	$(ENV) $(if $(GOOS),GOOS=$(GOOS)) $(if $(GOARCH),GOARCH=$(GOARCH)) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	$(ENV) $(if $(GOOS),GOOS=$(GOOS)) $(if $(GOARCH),GOARCH=$(GOARCH)) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
-
-# Allows you to build a CGO-free client for any target e.g. `GOOS=windows GOARCH=arm64 make client`
-# NOTE: WireGuard is not supported on all platforms, but most 64-bit GOOS/GOARCH combinations should work.
-.PHONY: client
-client: clean .downloaded_assets validate-go-version
-	$(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client ./client
-
-.PHONY: macos-amd64
-macos-amd64: clean .downloaded_assets validate-go-version
-	GOOS=darwin GOARCH=amd64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	GOOS=darwin GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(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
-	GOOS=darwin GOARCH=arm64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	GOOS=darwin GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
-
-.PHONY: linux-amd64
-linux-amd64: clean .downloaded_assets validate-go-version
-	GOOS=linux GOARCH=amd64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	GOOS=linux GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(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
-	GOOS=linux GOARCH=arm64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	GOOS=linux GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
-
-.PHONY: windows-amd64
-windows-amd64: clean .downloaded_assets validate-go-version
-	GOOS=windows GOARCH=amd64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX).exe ./server
-	GOOS=windows GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX).exe ./client
-
-.PHONY: clients
-clients: clean .downloaded_assets validate-go-version
-	GOOS=darwin GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_macos-amd64$(ARTIFACT_SUFFIX) ./client
-	GOOS=darwin GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_macos-arm64$(ARTIFACT_SUFFIX) ./client
-	GOOS=linux GOARCH=386 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_linux-386$(ARTIFACT_SUFFIX) ./client
-	GOOS=linux GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_linux-amd64$(ARTIFACT_SUFFIX) ./client
-	GOOS=linux GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_linux-arm64$(ARTIFACT_SUFFIX) ./client
-	GOOS=windows GOARCH=386 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_windows-386$(ARTIFACT_SUFFIX).exe ./client
-	GOOS=windows GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_windows-amd64$(ARTIFACT_SUFFIX).exe ./client
-	GOOS=windows GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_windows-arm64$(ARTIFACT_SUFFIX).exe ./client
-	GOOS=freebsd GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_freebsd-amd64$(ARTIFACT_SUFFIX) ./client
-	GOOS=freebsd GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_freebsd-arm64$(ARTIFACT_SUFFIX) ./client
-
-.PHONY: servers
-servers: clean .downloaded_assets validate-go-version
-	GOOS=windows GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_windows-amd64$(ARTIFACT_SUFFIX).exe ./server
-	GOOS=windows GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_windows-arm64$(ARTIFACT_SUFFIX).exe ./server
-	GOOS=linux GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_linux-amd64$(ARTIFACT_SUFFIX) ./server
-	GOOS=linux GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_linux-arm64$(ARTIFACT_SUFFIX) ./server
-	GOOS=darwin GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_darwin-arm64$(ARTIFACT_SUFFIX) ./server
-	GOOS=darwin GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_darwin-amd64$(ARTIFACT_SUFFIX) ./server
-
-.PHONY: pb
-pb:
-	protoc -I protobuf/ protobuf/commonpb/common.proto --go_out=paths=source_relative:protobuf/
-	protoc -I protobuf/ protobuf/sliverpb/sliver.proto --go_out=paths=source_relative:protobuf/
-	protoc -I protobuf/ protobuf/clientpb/client.proto --go_out=paths=source_relative:protobuf/
-	protoc -I protobuf/ protobuf/dnspb/dns.proto --go_out=paths=source_relative:protobuf/
-	protoc -I protobuf/ protobuf/rpcpb/services.proto --go_out=paths=source_relative:protobuf/ --go-grpc_out=protobuf/ --go-grpc_opt=paths=source_relative 
-
-.PHONY: debug
-debug: clean
-	$(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor $(TAGS),server $(LDFLAGS_DEBUG) -o sliver-server$(ARTIFACT_SUFFIX) ./server
-	$(ENV) CGO_ENABLED=0 $(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 ;\
-	elif [ $(GO_MAJOR_VERSION) -lt $(MIN_SUPPORTED_GO_MAJOR_VERSION) ]; then \
-		echo '$(GO_VERSION_VALIDATION_ERR_MSG)';\
-		exit 1; \
-	elif [ $(GO_MINOR_VERSION) -lt $(MIN_SUPPORTED_GO_MINOR_VERSION) ] ; then \
-		echo '$(GO_VERSION_VALIDATION_ERR_MSG)';\
-		exit 1; \
-	fi
-
-.PHONY: clean-all
-clean-all: clean
-	rm -rf ./server/assets/fs/darwin/amd64
-	rm -rf ./server/assets/fs/darwin/arm64
-	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-client_* sliver-server sliver-server_* sliver-*.exe
-
-.downloaded_assets:
-	$(ENV) $(GO) run -mod=vendor ./util/cmd/assets
-	touch ./.downloaded_assets
-
-
+
+# *** Darwin ***
+ifeq ($(UNAME_S),Darwin)
+	SED_INPLACE := sed -i ''
+	STATIC_TARGET := macos
+endif
+
+# If no target is specified, determine GOARCH
+ifeq ($(UNAME_P),arm)
+	ifeq ($(MAKECMDGOALS), )
+		ENV += GOARCH=arm64
+	endif
+endif
+
+ifeq ($(MAKECMDGOALS), linux)
+	# Redefine LDFLAGS to add the static part
+	LDFLAGS = -ldflags "-s -w \
+		-extldflags '-static' \
+		-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_PUBLIC_KEY) \
+		-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
+endif
+
 #
-# >>> WINDOWS <<<
+# Targets
 #
-else
+.PHONY: default
+default: clean .downloaded_assets validate-go-version
+	$(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
+	$(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
 
-SHELL := cmd.exe
-.SHELLFLAGS := /C
+# Allows you to build a CGO-free client for any target e.g. `GOOS=windows GOARCH=arm64 make client`
+# NOTE: WireGuard is not supported on all platforms, but most 64-bit GOOS/GOARCH combinations should work.
+.PHONY: client
+client: clean .downloaded_assets validate-go-version
+	$(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client ./client
 
-GO_VERSION := $(patsubst go%,%,$(strip $(shell $(GO) env GOVERSION)))
-GO_MAJOR_VERSION := $(word 1,$(subst ., ,$(GO_VERSION)))
-GO_MINOR_VERSION := $(word 2,$(subst ., ,$(GO_VERSION)))
+.PHONY: macos-amd64
+macos-amd64: clean .downloaded_assets validate-go-version
+	GOOS=darwin GOARCH=amd64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
+	GOOS=darwin GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
 
-LDFLAGS = -ldflags "-s -w -X $(SLIVER_UPDATE_PKG).SliverPublicKey=$(SLIVER_PUBLIC_KEY) -X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUBLIC_KEY) -X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
+.PHONY: macos-arm64
+macos-arm64: clean .downloaded_assets validate-go-version
+	GOOS=darwin GOARCH=arm64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
+	GOOS=darwin GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
 
-LDFLAGS_DEBUG = -ldflags "-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUBLIC_KEY) -X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
+.PHONY: linux-amd64
+linux-amd64: clean .downloaded_assets validate-go-version
+	GOOS=linux GOARCH=amd64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
+	GOOS=linux GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
 
-COMMA := ,
-
-ifeq ($(MAKECMDGOALS), linux)
-	LDFLAGS = -ldflags "-s -w -extldflags '-static' -X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUBLIC_KEY) -X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
-endif
-
-define windows_exec
-$(strip $(foreach envvar,$(1),set "$(envvar)" && ))$(2)
-endef
-
-define windows_go_build
-$(call windows_exec,$(ENV) GOOS=$(1) GOARCH=$(2) CGO_ENABLED=$(3),"$(GO)" build $(4) $(TAGS)$(COMMA)$(5) $(6) -o $(7) ./$(5))
-endef
-
-.PHONY: default
-default: clean validate-go-version
-	$(call windows_exec,$(ENV) GOOS= GOARCH=,"$(MAKE)" GOOS= GOARCH= .downloaded_assets)
-	$(call windows_go_build,$(GOOS),$(GOARCH),$(CGO_ENABLED),-mod=vendor -trimpath,server,$(LDFLAGS),sliver-server$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,$(GOOS),$(GOARCH),0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client$(ARTIFACT_SUFFIX))
-
-.PHONY: client
-client: clean .downloaded_assets validate-go-version
-	$(call windows_go_build,$(GOOS),$(GOARCH),0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client)
-
-.PHONY: macos-amd64
-macos-amd64: clean .downloaded_assets validate-go-version
-	$(call windows_go_build,darwin,amd64,$(CGO_ENABLED),-mod=vendor -trimpath,server,$(LDFLAGS),sliver-server$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,darwin,amd64,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client$(ARTIFACT_SUFFIX))
-
-.PHONY: macos-arm64
-macos-arm64: clean .downloaded_assets validate-go-version
-	$(call windows_go_build,darwin,arm64,$(CGO_ENABLED),-mod=vendor -trimpath,server,$(LDFLAGS),sliver-server$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,darwin,arm64,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client$(ARTIFACT_SUFFIX))
-
-.PHONY: linux-amd64
-linux-amd64: clean .downloaded_assets validate-go-version
-	$(call windows_go_build,linux,amd64,$(CGO_ENABLED),-mod=vendor -trimpath,server,$(LDFLAGS),sliver-server$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,linux,amd64,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client$(ARTIFACT_SUFFIX))
-
-.PHONY: linux-arm64
-linux-arm64: clean .downloaded_assets validate-go-version
-	$(call windows_go_build,linux,arm64,$(CGO_ENABLED),-mod=vendor -trimpath,server,$(LDFLAGS),sliver-server$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,linux,arm64,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client$(ARTIFACT_SUFFIX))
-
-.PHONY: windows-amd64
-windows-amd64: clean .downloaded_assets validate-go-version
-	$(call windows_go_build,windows,amd64,$(CGO_ENABLED),-mod=vendor -trimpath,server,$(LDFLAGS),sliver-server$(ARTIFACT_SUFFIX).exe)
-	$(call windows_go_build,windows,amd64,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client$(ARTIFACT_SUFFIX).exe)
-
-.PHONY: clients
-clients: clean .downloaded_assets validate-go-version
-	$(call windows_go_build,darwin,amd64,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client_macos-amd64$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,darwin,arm64,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client_macos-arm64$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,linux,386,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client_linux-386$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,linux,amd64,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client_linux-amd64$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,linux,arm64,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client_linux-arm64$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,windows,386,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client_windows-386$(ARTIFACT_SUFFIX).exe)
-	$(call windows_go_build,windows,amd64,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client_windows-amd64$(ARTIFACT_SUFFIX).exe)
-	$(call windows_go_build,windows,arm64,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client_windows-arm64$(ARTIFACT_SUFFIX).exe)
-	$(call windows_go_build,freebsd,amd64,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client_freebsd-amd64$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,freebsd,arm64,0,-mod=vendor -trimpath,client,$(LDFLAGS),sliver-client_freebsd-arm64$(ARTIFACT_SUFFIX))
-
-.PHONY: servers
-servers: clean .downloaded_assets validate-go-version
-	$(call windows_go_build,windows,amd64,0,-mod=vendor -trimpath,server,$(LDFLAGS),sliver-server_windows-amd64$(ARTIFACT_SUFFIX).exe)
-	$(call windows_go_build,windows,arm64,0,-mod=vendor -trimpath,server,$(LDFLAGS),sliver-server_windows-arm64$(ARTIFACT_SUFFIX).exe)
-	$(call windows_go_build,linux,amd64,0,-mod=vendor -trimpath,server,$(LDFLAGS),sliver-server_linux-amd64$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,linux,arm64,0,-mod=vendor -trimpath,server,$(LDFLAGS),sliver-server_linux-arm64$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,darwin,arm64,0,-mod=vendor -trimpath,server,$(LDFLAGS),sliver-server_darwin-arm64$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,darwin,amd64,0,-mod=vendor -trimpath,server,$(LDFLAGS),sliver-server_darwin-amd64$(ARTIFACT_SUFFIX))
-
-.PHONY: pb
-pb: validate-pb-compilers
-	protoc -I protobuf/ protobuf/commonpb/common.proto --go_out=paths=source_relative:protobuf/
-	protoc -I protobuf/ protobuf/sliverpb/sliver.proto --go_out=paths=source_relative:protobuf/
-	protoc -I protobuf/ protobuf/clientpb/client.proto --go_out=paths=source_relative:protobuf/
-	protoc -I protobuf/ protobuf/dnspb/dns.proto --go_out=paths=source_relative:protobuf/
-	protoc -I protobuf/ protobuf/rpcpb/services.proto --go_out=paths=source_relative:protobuf/ --go-grpc_out=protobuf/ --go-grpc_opt=paths=source_relative
-
-.PHONY: debug
-debug: clean
-	$(call windows_go_build,$(GOOS),$(GOARCH),$(CGO_ENABLED),-mod=vendor,server,$(LDFLAGS_DEBUG),sliver-server$(ARTIFACT_SUFFIX))
-	$(call windows_go_build,$(GOOS),$(GOARCH),0,-mod=vendor,client,$(LDFLAGS_DEBUG),sliver-client$(ARTIFACT_SUFFIX))
-
-.PHONY: validate-pb-compilers
-validate-pb-compilers:
-	@for %%P in ($(PB_COMPILERS)) do @where.exe %%P >NUL || (echo Missing protobuf util %%P in PATH & exit /b 1)
-
-validate-go-version:
-	@if $(GO_MAJOR_VERSION) GTR $(MIN_SUPPORTED_GO_MAJOR_VERSION) (exit /b 0) else if $(GO_MAJOR_VERSION) LSS $(MIN_SUPPORTED_GO_MAJOR_VERSION) (echo $(GO_VERSION_VALIDATION_ERR_MSG) & exit /b 1) else if $(GO_MINOR_VERSION) LSS $(MIN_SUPPORTED_GO_MINOR_VERSION) (echo $(GO_VERSION_VALIDATION_ERR_MSG) & exit /b 1)
-
-.PHONY: clean-all
-clean-all: clean
-	-rmdir /S /Q server\assets\fs\darwin\amd64
-	-rmdir /S /Q server\assets\fs\darwin\arm64
-	-rmdir /S /Q server\assets\fs\windows\amd64
-	-rmdir /S /Q server\assets\fs\linux\amd64
-	-del /Q /F server\assets\fs\*.zip 2>NUL
-	-del /Q /F .downloaded_assets 2>NUL
-
-.PHONY: clean
-clean:
-	-del /Q /F sliver-client sliver-client_* sliver-server sliver-server_* sliver-*.exe 2>NUL
-
-.downloaded_assets:
-	$(call windows_exec,$(ENV),"$(GO)" run -mod=vendor ./util/cmd/assets)
-	@type NUL > .downloaded_assets
-
-endif
+.PHONY: linux-arm64
+linux-arm64: clean .downloaded_assets validate-go-version
+	GOOS=linux GOARCH=arm64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX) ./server
+	GOOS=linux GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX) ./client
+
+.PHONY: windows-amd64
+windows-amd64: clean .downloaded_assets validate-go-version
+	GOOS=windows GOARCH=amd64 $(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server$(ARTIFACT_SUFFIX).exe ./server
+	GOOS=windows GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client$(ARTIFACT_SUFFIX).exe ./client
+
+.PHONY: clients
+clients: clean .downloaded_assets validate-go-version
+	GOOS=darwin GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_macos-amd64$(ARTIFACT_SUFFIX) ./client
+	GOOS=darwin GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_macos-arm64$(ARTIFACT_SUFFIX) ./client
+	GOOS=linux GOARCH=386 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_linux-386$(ARTIFACT_SUFFIX) ./client
+	GOOS=linux GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_linux-amd64$(ARTIFACT_SUFFIX) ./client
+	GOOS=linux GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_linux-arm64$(ARTIFACT_SUFFIX) ./client
+	GOOS=windows GOARCH=386 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_windows-386$(ARTIFACT_SUFFIX).exe ./client
+	GOOS=windows GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_windows-amd64$(ARTIFACT_SUFFIX).exe ./client
+	GOOS=windows GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_windows-arm64$(ARTIFACT_SUFFIX).exe ./client
+	GOOS=freebsd GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_freebsd-amd64$(ARTIFACT_SUFFIX) ./client
+	GOOS=freebsd GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_freebsd-arm64$(ARTIFACT_SUFFIX) ./client
+
+.PHONY: servers
+servers: 
+	GOOS=windows GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_windows-amd64$(ARTIFACT_SUFFIX).exe ./server
+	GOOS=linux GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_linux-amd64$(ARTIFACT_SUFFIX) ./server
+	GOOS=linux GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_linux-arm64$(ARTIFACT_SUFFIX) ./server
+	GOOS=darwin GOARCH=arm64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_darwin-arm64$(ARTIFACT_SUFFIX) ./server
+	GOOS=darwin GOARCH=amd64 $(ENV) CGO_ENABLED=0 $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_darwin-amd64$(ARTIFACT_SUFFIX) ./server
+
+.PHONY: pb
+pb:
+	protoc -I protobuf/ protobuf/commonpb/common.proto --go_out=paths=source_relative:protobuf/
+	protoc -I protobuf/ protobuf/sliverpb/sliver.proto --go_out=paths=source_relative:protobuf/
+	protoc -I protobuf/ protobuf/clientpb/client.proto --go_out=paths=source_relative:protobuf/
+	protoc -I protobuf/ protobuf/dnspb/dns.proto --go_out=paths=source_relative:protobuf/
+	protoc -I protobuf/ protobuf/rpcpb/services.proto --go_out=paths=source_relative:protobuf/ --go-grpc_out=protobuf/ --go-grpc_opt=paths=source_relative 
+
+.PHONY: debug
+debug: clean
+	$(ENV) CGO_ENABLED=$(CGO_ENABLED) $(GO) build -mod=vendor $(TAGS),server $(LDFLAGS_DEBUG) -o sliver-server$(ARTIFACT_SUFFIX) ./server
+	$(ENV) CGO_ENABLED=0 $(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 ;\
+	elif [ $(GO_MAJOR_VERSION) -lt $(MIN_SUPPORTED_GO_MAJOR_VERSION) ]; then \
+		echo '$(GO_VERSION_VALIDATION_ERR_MSG)';\
+		exit 1; \
+	elif [ $(GO_MINOR_VERSION) -lt $(MIN_SUPPORTED_GO_MINOR_VERSION) ] ; then \
+		echo '$(GO_VERSION_VALIDATION_ERR_MSG)';\
+		exit 1; \
+	fi
+
+.PHONY: clean-all
+clean-all: clean
+	rm -rf ./server/assets/fs/darwin/amd64
+	rm -rf ./server/assets/fs/darwin/arm64
+	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-client_* sliver-server sliver-server_* sliver-*.exe
+
+.downloaded_assets:
+	./go-assets.sh
+	touch ./.downloaded_assets

README.md

@@ -4,9 +4,13 @@ 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) [![golangci-lint](https://github.com/BishopFox/sliver/actions/workflows/golangci-lint.yml/badge.svg)](https://github.com/BishopFox/sliver/actions/workflows/golangci-lint.yml) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+[![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)
 
-Visit [https://sliver.sh/](https://sliver.sh/) for tutorials and documentation.
+# v1.6.0 / `master`
+
+**NOTE:** You are looking at the latest master branch of Sliver v1.6.0; new PRs should target this branch. However, this branch is NOT RECOMMENDED for production use yet. Please use release tagged versions for the best experience.
+
+For PRs containing bug fixes specific to Sliver v1.5, please target the [`v1.5.x/master` branch](https://github.com/BishopFox/sliver/tree/v1.5.x/master).
 
 ### Features
 
@@ -17,7 +21,7 @@ Visit [https://sliver.sh/](https://sliver.sh/) for tutorials and documentation.
 - [Procedurally generated C2](https://sliver.sh/docs?name=HTTPS+C2) over HTTP(S)
 - [DNS canary](https://sliver.sh/docs?name=DNS+C2) blue team detection
 - [Secure C2](https://sliver.sh/docs?name=Transport+Encryption) over mTLS, WireGuard, HTTP(S), and DNS
-- Fully scriptable using [Python](https://github.com/moloch--/sliver-py)
+- Fully scriptable using [JavaScript/TypeScript](https://github.com/moloch--/sliver-script) or [Python](https://github.com/moloch--/sliver-py)
 - Windows process migration, process injection, user token manipulation, etc.
 - Let's Encrypt integration
 - In-memory .NET assembly execution
@@ -35,12 +39,16 @@ Download the latest [release](https://github.com/BishopFox/sliver/releases) and
 
 ### Help!
 
-Please checkout the [wiki](https://sliver.sh/), or start a [GitHub discussion](https://github.com/BishopFox/sliver/discussions).
+Please checkout the [wiki](https://sliver.sh/), or start a [GitHub discussion](https://github.com/BishopFox/sliver/discussions). We also tend to hang out in the #golang Slack channel on the [Bloodhound Gang](https://bloodhoundgang.herokuapp.com/) server.
 
 ### Compile From Source
 
 See the [wiki](https://sliver.sh/docs?name=Compile+from+Source).
 
+### Feedback
+
+Please take a moment and fill out [our survey](https://forms.gle/SwVsHFNh24ChG58C6).
+
 ### License - GPLv3
 
 Sliver is licensed under [GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html), some sub-components may have separate licenses. See their respective subdirectories in this project for details.

build.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""
+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
+
+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 --target test .")
+    if status == 0:
+        print("\n\n" + INFO + "Build successful")
+
+
+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/README.md

@@ -1,26 +1,18 @@
-# client
+Client
+=======
 
-## Overview
+This directory contains the client implementation, pretty much all of this code is also used by the server console. 
 
-Main command-line client for interacting with and administering Sliver servers. Provides the Cobra entrypoint and aggregates console, command, and transport subsystems.
+__Important:__ No code in this directory can import any code from `server/`.
 
-## Go Files
-
-- `main.go` – Entry point that initializes the CLI, processes flags, and launches the interactive console.
-
-## Sub-packages
-
-- `assets/` – Manages embedded client asset manifests such as operator profiles, settings, and armory catalogs. Handles serialization, bundling, and lookup of static client metadata.
-- `cli/` – Defines the Cobra root command and CLI initialization for the Sliver client binary. Sets up persistent flags, environment bootstrapping, and command wiring.
-- `command/` – Shared registration glue, scaffolding, and helpers for Sliver client console command groups. Hosts common utilities for binding Cobra commands to RPC-backed actions.
-- `console/` – Renders the interactive console UI, logging, and terminal helpers for the client. Coordinates readline behavior, prompt styling, and message formatting.
-- `constants/` – Centralizes constants shared across the client runtime and command packages. Captures strings, flag names, and feature toggles used throughout the CLI.
-- `core/` – Maintains client application state, background workers, and RPC coordination. Orchestrates session tracking, event streams, and health checks.
-- `credentials/` – Credential management utilities including sniffers and import helpers for operators. Provides parsers, storage helpers, and output formatting for recovered secrets.
-- `licenses/` – Holds embedded license metadata bundled with the client distribution. Supplies license retrieval utilities used for attribution commands.
-- `overlord/` – Supervises long-running client jobs, scheduling, and task orchestration. Tracks job lifecycle events and exposes status updates to the console.
-- `packages/` – Deals with packaged extensions and module discovery for the client. Scans, validates, and caches extension manifests and assets.
-- `spin/` – Lightweight terminal spinner utilities used for progress feedback. Wraps spinner styles and timing helpers shared across commands.
-- `tcpproxy/` – Implements the local TCP proxy used for port forwarding from the client side. Manages listener lifecycles, connection pumps, and cleanup hooks.
-- `transport/` – Client-side transports and RPC wiring to communicate with Sliver servers. Builds authenticated gRPC clients, TLS dialers, and reconnect logic.
-- `version/` – Build-time version and semantic metadata for the client binary. Exposes git information, release channels, and helper formatters.
+ * `assets/` - Static asset files and management code (e.g. client configs)
+ * `cli/` - Command line interface implementation
+ * `command/` - Console command implementations
+ * `constants/` - Various shared constant values
+ * `core/` - Client state management
+ * `licenses/` - Open source licenses 
+ * `spin/` - Console spinner library
+ * `tcpproxy/` - Local TCP proxy listener code
+ * `transport/` - Wires the client to the server
+ * `version/` - Version information
+ * `main.go` - Entrypoint

client/assets/README.md

@@ -1,15 +1,3 @@
-# client/assets
+Assets
+======
 
-## Overview
-
-Manages embedded client asset manifests such as operator profiles, settings, and armory catalogs. Handles serialization, bundling, and lookup of static client metadata. Core logic addresses aliases, armories, C2 profiles, and extensions within the assets package.
-
-## Go Files
-
-- `aliases.go` – Provides helpers for discovering, installing, and reading alias manifests shipped with the client.
-- `armories.go` – Loads configured armory definitions and persists operator customizations.
-- `assets.go` – Central entry point that exposes asset directories, lazy initialization, and filesystem utilities.
-- `c2profiles.go` – Embeds default HTTP C2 profile templates and exposes lookup utilities.
-- `config.go` – Tracks client configuration paths and manages persistence of runtime options.
-- `extensions.go` – Handles embedded extension manifests and supports lookup by command name.
-- `settings.go` – Stores default console settings and manages serialization to disk.

client/assets/assets.go

@@ -34,19 +34,12 @@ const (
 	SliverClientDirName = ".sliver-client"
 
 	versionFileName = "version"
-	envVarName      = "SLIVER_CLIENT_ROOT_DIR"
 )
 
 // GetRootAppDir - Get the Sliver app dir ~/.sliver-client/
 func GetRootAppDir() string {
-	value := os.Getenv(envVarName)
-	var dir string
-	if len(value) == 0 {
-		user, _ := user.Current()
-		dir = filepath.Join(user.HomeDir, SliverClientDirName)
-	} else {
-		dir = value
-	}
+	user, _ := user.Current()
+	dir := filepath.Join(user.HomeDir, SliverClientDirName)
 	if _, err := os.Stat(dir); os.IsNotExist(err) {
 		err = os.MkdirAll(dir, 0700)
 		if err != nil {
@@ -80,18 +73,6 @@ func GetConsoleLogsDir() string {
 	return consoleLogsDir
 }
 
-// GetMCPLogsDir - Get the Sliver client MCP logs dir ~/.sliver-client/logs/mcp/
-func GetMCPLogsDir() string {
-	mcpLogsDir := filepath.Join(GetClientLogsDir(), "mcp")
-	if _, err := os.Stat(mcpLogsDir); os.IsNotExist(err) {
-		err = os.MkdirAll(mcpLogsDir, 0700)
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-	return mcpLogsDir
-}
-
 func assetVersion() string {
 	appDir := GetRootAppDir()
 	data, err := os.ReadFile(filepath.Join(appDir, versionFileName))
@@ -115,7 +96,7 @@ func Setup(force bool, echo bool) {
 	if force || localVer == "" || localVer != ver.GitCommit {
 		if echo {
 			fmt.Printf(`
-Sliver  Copyright (C) 2026  Bishop Fox
+Sliver  Copyright (C) 2022  Bishop Fox
 This program comes with ABSOLUTELY NO WARRANTY; for details type 'licenses'.
 This is free software, and you are welcome to redistribute it
 under certain conditions; type 'licenses' for details.`)
@@ -123,6 +104,7 @@ under certain conditions; type 'licenses' for details.`)
 		}
 		saveAssetVersion(appDir)
 	}
-	_, _ = LoadSettings()
-	_, _ = LoadSpoofMetadataConfig()
+	if _, err := os.Stat(filepath.Join(appDir, settingsFileName)); os.IsNotExist(err) {
+		SaveSettings(nil)
+	}
 }

client/assets/c2profiles.go

@@ -57,17 +57,30 @@ type HTTPC2ImplantConfig struct {
 	NonceQueryArgChars string                 `json:"nonce_query_args"`
 	URLParameters      []NameValueProbability `json:"url_parameters"`
 	Headers            []NameValueProbability `json:"headers"`
-	NonceQueryLength   int                    `json:"nonce_query_length"`
-	NonceMode          string                 `json:"nonce_mode"`
 
-	MaxFileGen    int `json:"max_files"`
-	MinFileGen    int `json:"min_files"`
-	MaxPathGen    int `json:"max_paths"`
-	MinPathGen    int `json:"min_paths"`
-	MaxPathLength int `json:"max_path_length"`
-	MinPathLength int `json:"min_path_length"`
+	MaxFiles int `json:"max_files"`
+	MinFiles int `json:"min_files"`
+	MaxPaths int `json:"max_paths"`
+	MinPaths int `json:"min_paths"`
 
-	Extensions []string `json:"extensions"`
-	Files      []string `json:"files"`
-	Paths      []string `json:"paths"`
+	// Stager files and paths
+	StagerFileExt string   `json:"stager_file_ext"`
+	StagerFiles   []string `json:"stager_files"`
+	StagerPaths   []string `json:"stager_paths"`
+
+	// Poll files and paths
+	PollFileExt string   `json:"poll_file_ext"`
+	PollFiles   []string `json:"poll_files"`
+	PollPaths   []string `json:"poll_paths"`
+
+	// Session files and paths
+	StartSessionFileExt string   `json:"start_session_file_ext"`
+	SessionFileExt      string   `json:"session_file_ext"`
+	SessionFiles        []string `json:"session_files"`
+	SessionPaths        []string `json:"session_paths"`
+
+	// Close session files and paths
+	CloseFileExt string   `json:"close_file_ext"`
+	CloseFiles   []string `json:"close_files"`
+	ClosePaths   []string `json:"close_paths"`
 }

client/assets/config.go

@@ -34,25 +34,15 @@ const (
 	ConfigDirName = "configs"
 )
 
-// ClientWGConfig - Optional WireGuard wrapper configuration for multiplayer.
-type ClientWGConfig struct {
-	ServerPubKey     string `json:"server_pub_key"`
-	ClientPrivateKey string `json:"client_private_key"`
-	ClientPubKey     string `json:"client_pub_key"`
-	ClientIP         string `json:"client_ip"`
-	ServerIP         string `json:"server_ip"`
-}
-
 // ClientConfig - Client JSON config
 type ClientConfig struct {
-	Operator      string          `json:"operator"` // This value is actually ignored for the most part (cert CN is used instead)
-	LHost         string          `json:"lhost"`
-	LPort         int             `json:"lport"`
-	Token         string          `json:"token"`
-	CACertificate string          `json:"ca_certificate"`
-	PrivateKey    string          `json:"private_key"`
-	Certificate   string          `json:"certificate"`
-	WG            *ClientWGConfig `json:"wg,omitempty"`
+	Operator      string `json:"operator"` // This value is actually ignored for the most part (cert CN is used instead)
+	LHost         string `json:"lhost"`
+	LPort         int    `json:"lport"`
+	Token         string `json:"token"`
+	CACertificate string `json:"ca_certificate"`
+	PrivateKey    string `json:"private_key"`
+	Certificate   string `json:"certificate"`
 }
 
 // GetConfigDir - Returns the path to the config dir

client/assets/legacy.go

@@ -1,27 +0,0 @@
-package assets
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-func legacyBackupPath(legacyPath string) string {
-	dir := filepath.Dir(legacyPath)
-	base := filepath.Base(legacyPath)
-	name := strings.TrimSuffix(base, filepath.Ext(base))
-	return filepath.Join(dir, "."+name+".json-old")
-}
-
-func renameLegacyConfig(legacyPath string) error {
-	if _, err := os.Stat(legacyPath); os.IsNotExist(err) {
-		return nil
-	}
-	backupPath := legacyBackupPath(legacyPath)
-	if _, err := os.Stat(backupPath); err == nil {
-		if err := os.Remove(backupPath); err != nil {
-			return err
-		}
-	}
-	return os.Rename(legacyPath, backupPath)
-}

client/assets/settings.go

@@ -22,111 +22,39 @@ import (
 	"encoding/json"
 	"os"
 	"path/filepath"
-	"strings"
-
-	"gopkg.in/yaml.v3"
 )
 
 const (
-	settingsFileName       = "tui-settings.yaml"
-	settingsLegacyFileName = "tui-settings.json"
-)
-
-const (
-	// Accepted values for tui-settings.yaml "prompt:":
-	// - host: show "[host]" prefix on sliver-client, "[server]" on server console
-	// - operator-host: show "[operator@host]" prefix on sliver-client, "[server]" on server console
-	// - basic: show "sliver >" (no prefix)
-	// - custom: render full prompt from prompt_template
-	PromptStyleHost         = "host"
-	PromptStyleOperatorHost = "operator-host"
-	PromptStyleBasic        = "basic"
-	PromptStyleCustom       = "custom"
+	settingsFileName = "tui-settings.json"
 )
 
 // ClientSettings - Client JSON config
 type ClientSettings struct {
-	TableStyle        string `json:"tables" yaml:"tables"`
-	AutoAdult         bool   `json:"autoadult" yaml:"autoadult"`
-	BeaconAutoResults bool   `json:"beacon_autoresults" yaml:"beacon_autoresults"`
-	SmallTermWidth    int    `json:"small_term_width" yaml:"small_term_width"`
-	AlwaysOverflow    bool   `json:"always_overflow" yaml:"always_overflow"`
-	VimMode           bool   `json:"vim_mode" yaml:"vim_mode"`
-	UserConnect       bool   `json:"user_connect" yaml:"user_connect"`
-	ConsoleLogs       bool   `json:"console_logs" yaml:"console_logs"`
-	PromptStyle       string `json:"prompt" yaml:"prompt"`
-	PromptTemplate    string `json:"prompt_template" yaml:"prompt_template"`
+	TableStyle        string `json:"tables"`
+	AutoAdult         bool   `json:"autoadult"`
+	BeaconAutoResults bool   `json:"beacon_autoresults"`
+	SmallTermWidth    int    `json:"small_term_width"`
+	AlwaysOverflow    bool   `json:"always_overflow"`
+	VimMode           bool   `json:"vim_mode"`
+	UserConnect       bool   `json:"user_connect"`
+	ConsoleLogs       bool   `json:"console_logs"`
 }
 
 // LoadSettings - Load the client settings from disk
 func LoadSettings() (*ClientSettings, error) {
 	rootDir, _ := filepath.Abs(GetRootAppDir())
-	settingsPath := filepath.Join(rootDir, settingsFileName)
-	legacyPath := filepath.Join(rootDir, settingsLegacyFileName)
+	data, err := os.ReadFile(filepath.Join(rootDir, settingsFileName))
+	if err != nil {
+		return defaultSettings(), err
+	}
 	settings := defaultSettings()
-	migratedLegacy := false
-
-	data, err := os.ReadFile(settingsPath)
-	if err == nil {
-		if err = yaml.Unmarshal(data, settings); err != nil {
-			return defaultSettings(), err
-		}
-	} else if !os.IsNotExist(err) {
+	err = json.Unmarshal(data, settings)
+	if err != nil {
 		return defaultSettings(), err
-	} else if data, err = os.ReadFile(legacyPath); err == nil {
-		if err = json.Unmarshal(data, settings); err != nil {
-			return defaultSettings(), err
-		}
-		migratedLegacy = true
-	} else if !os.IsNotExist(err) {
-		return defaultSettings(), err
-	}
-
-	// Ensure any missing/unknown values are coerced to a supported prompt style.
-	settings.PromptStyle = NormalizePromptStyle(settings.PromptStyle)
-	if err := SaveSettings(settings); err != nil {
-		return settings, err
-	}
-	if migratedLegacy {
-		if err := renameLegacyConfig(legacyPath); err != nil {
-			return settings, err
-		}
 	}
 	return settings, nil
 }
 
-// NormalizePromptStyle canonicalizes prompt style strings and returns a safe
-// default if the value is empty/unknown.
-func NormalizePromptStyle(v string) string {
-	switch strings.ToLower(strings.TrimSpace(v)) {
-	case PromptStyleOperatorHost:
-		return PromptStyleOperatorHost
-	case PromptStyleHost:
-		return PromptStyleHost
-	case PromptStyleBasic:
-		return PromptStyleBasic
-	case PromptStyleCustom:
-		return PromptStyleCustom
-
-	// Backward compatible aliases.
-	case "show host":
-		return PromptStyleHost
-	case "show user and host":
-		return PromptStyleOperatorHost
-	case "show operator and host":
-		return PromptStyleOperatorHost
-	case "operator@host":
-		return PromptStyleOperatorHost
-	case "user@host":
-		return PromptStyleOperatorHost
-
-	case "":
-		return PromptStyleHost
-	default:
-		return PromptStyleHost
-	}
-}
-
 func defaultSettings() *ClientSettings {
 	return &ClientSettings{
 		TableStyle:        "SliverDefault",
@@ -136,20 +64,16 @@ func defaultSettings() *ClientSettings {
 		AlwaysOverflow:    false,
 		VimMode:           false,
 		ConsoleLogs:       true,
-		PromptStyle:       PromptStyleHost,
-		PromptTemplate:    DefaultPromptTemplate,
 	}
 }
 
-const DefaultPromptTemplate = `{{- if .IsServer -}}{{ .Styles.Bold.Render "[server]" }} {{ .Styles.Underline.Render "sliver" }}{{ .Target.Suffix }} > {{- else -}}{{- if .Host -}}{{ .Styles.BoldPrimary.Render (printf "[%s]" .Host) }} {{- end -}}{{ .Styles.Underline.Render "sliver" }}{{ .Target.Suffix }} > {{- end -}}`
-
 // SaveSettings - Save the current settings to disk
 func SaveSettings(settings *ClientSettings) error {
 	rootDir, _ := filepath.Abs(GetRootAppDir())
 	if settings == nil {
 		settings = defaultSettings()
 	}
-	data, err := yaml.Marshal(settings)
+	data, err := json.MarshalIndent(settings, "", "  ")
 	if err != nil {
 		return err
 	}

client/assets/settings_test.go

@@ -1,137 +0,0 @@
-package assets
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestLoadSettingsParsesYAML(t *testing.T) {
-	t.Setenv(envVarName, t.TempDir())
-
-	rootDir, _ := filepath.Abs(GetRootAppDir())
-	settingsPath := filepath.Join(rootDir, settingsFileName)
-
-	data := []byte(`tables: "Compact"
-autoadult: true
-beacon_autoresults: false
-small_term_width: 120
-always_overflow: true
-vim_mode: true
-user_connect: true
-console_logs: false
-prompt: "basic"
-prompt_template: "{{.Host}}"
-`)
-	if err := os.WriteFile(settingsPath, data, 0o600); err != nil {
-		t.Fatalf("failed to write yaml settings: %v", err)
-	}
-
-	settings, err := LoadSettings()
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if settings.TableStyle != "Compact" {
-		t.Fatalf("expected TableStyle %q, got %q", "Compact", settings.TableStyle)
-	}
-	if !settings.AutoAdult {
-		t.Fatalf("expected AutoAdult true")
-	}
-	if settings.BeaconAutoResults {
-		t.Fatalf("expected BeaconAutoResults false")
-	}
-	if settings.SmallTermWidth != 120 {
-		t.Fatalf("expected SmallTermWidth %d, got %d", 120, settings.SmallTermWidth)
-	}
-	if !settings.AlwaysOverflow {
-		t.Fatalf("expected AlwaysOverflow true")
-	}
-	if !settings.VimMode {
-		t.Fatalf("expected VimMode true")
-	}
-	if !settings.UserConnect {
-		t.Fatalf("expected UserConnect true")
-	}
-	if settings.ConsoleLogs {
-		t.Fatalf("expected ConsoleLogs false")
-	}
-	if settings.PromptStyle != PromptStyleBasic {
-		t.Fatalf("expected PromptStyle %q, got %q", PromptStyleBasic, settings.PromptStyle)
-	}
-	if settings.PromptTemplate != "{{.Host}}" {
-		t.Fatalf("expected PromptTemplate %q, got %q", "{{.Host}}", settings.PromptTemplate)
-	}
-}
-
-func TestLoadSettingsMigratesLegacyJSON(t *testing.T) {
-	t.Setenv(envVarName, t.TempDir())
-
-	rootDir, _ := filepath.Abs(GetRootAppDir())
-	legacyPath := filepath.Join(rootDir, settingsLegacyFileName)
-
-	legacy := &ClientSettings{
-		TableStyle:        "Legacy",
-		AutoAdult:         true,
-		BeaconAutoResults: false,
-		SmallTermWidth:    200,
-		AlwaysOverflow:    true,
-		VimMode:           true,
-		UserConnect:       true,
-		ConsoleLogs:       false,
-		PromptStyle:       PromptStyleOperatorHost,
-		PromptTemplate:    "{{.Operator}}@{{.Host}} sliver > ",
-	}
-	data, err := json.MarshalIndent(legacy, "", "  ")
-	if err != nil {
-		t.Fatalf("failed to marshal legacy settings: %v", err)
-	}
-	if err := os.WriteFile(legacyPath, data, 0o600); err != nil {
-		t.Fatalf("failed to write legacy settings: %v", err)
-	}
-
-	settings, err := LoadSettings()
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if settings.TableStyle != "Legacy" {
-		t.Fatalf("expected TableStyle %q, got %q", "Legacy", settings.TableStyle)
-	}
-	if settings.PromptStyle != PromptStyleOperatorHost {
-		t.Fatalf("expected PromptStyle %q, got %q", PromptStyleOperatorHost, settings.PromptStyle)
-	}
-	if settings.PromptTemplate != "{{.Operator}}@{{.Host}} sliver > " {
-		t.Fatalf("expected PromptTemplate %q, got %q", "{{.Operator}}@{{.Host}} sliver > ", settings.PromptTemplate)
-	}
-	if _, err := os.Stat(filepath.Join(rootDir, settingsFileName)); err != nil {
-		t.Fatalf("expected yaml settings to exist: %v", err)
-	}
-	if _, err := os.Stat(legacyPath); !os.IsNotExist(err) {
-		t.Fatalf("expected legacy settings to be renamed: %v", err)
-	}
-	if _, err := os.Stat(legacyBackupPath(legacyPath)); err != nil {
-		t.Fatalf("expected legacy backup to exist: %v", err)
-	}
-}
-
-func TestLoadSettingsWritesDefault(t *testing.T) {
-	t.Setenv(envVarName, t.TempDir())
-
-	settings, err := LoadSettings()
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if settings.TableStyle != "SliverDefault" {
-		t.Fatalf("expected default TableStyle %q, got %q", "SliverDefault", settings.TableStyle)
-	}
-	if settings.PromptStyle != PromptStyleHost {
-		t.Fatalf("expected default PromptStyle %q, got %q", PromptStyleHost, settings.PromptStyle)
-	}
-	if settings.PromptTemplate != DefaultPromptTemplate {
-		t.Fatalf("expected default PromptTemplate %q, got %q", DefaultPromptTemplate, settings.PromptTemplate)
-	}
-	rootDir, _ := filepath.Abs(GetRootAppDir())
-	if _, err := os.Stat(filepath.Join(rootDir, settingsFileName)); err != nil {
-		t.Fatalf("expected default settings to be written: %v", err)
-	}
-}

client/assets/spoof_metadata.go

@@ -1,216 +0,0 @@
-package assets
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2026  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"
-	"path/filepath"
-
-	"gopkg.in/yaml.v3"
-)
-
-const spoofMetadataFileName = "spoof-metadata.yaml"
-
-const defaultSpoofMetadataConfigTemplate = `# Sliver executable metadata spoofing configuration.
-# Used by generate commands when --spoof-metadata is set.
-#
-# Fields that reference file content support either:
-# - path: read bytes from a local file path
-# - base64: inline base64 file content
-# Do not set both path and base64 for the same object.
-#
-# Example 1: Minimal path-based metadata cloning (most common)
-pe:
-  source:
-    name: metadata-source.exe
-    path: ""
-
-  # Optional icon donor. Reserved for future standalone icon mutation support.
-  icon:
-    name: icon.ico
-    path: ""
-
-  # Example 2: Inline/base64 source (uncomment and remove "path" above)
-  # source:
-  #   name: metadata-source.exe
-  #   base64: "TVqQAAMAAAAEAAAA..."
-
-  # Example 3: Optional PE structure overrides (advanced)
-  # Applied after metadata/resources are cloned from source.
-  # Omitted fields keep cloned values.
-  # resource_directory:
-  #   characteristics: 0
-  #   time_date_stamp: 0
-  #   major_version: 1
-  #   minor_version: 0
-  #   number_of_named_entries: 0
-  #   number_of_id_entries: 0
-  #
-  # resource_directory_entries:
-  #   - name: 1
-  #     offset_to_data: 0
-  #
-  # resource_data_entries:
-  #   - offset_to_data: 0
-  #     size: 0
-  #     code_page: 0
-  #     reserved: 0
-  #
-  # export_directory:
-  #   characteristics: 0
-  #   time_date_stamp: 0
-  #   major_version: 1
-  #   minor_version: 0
-  #   name: 0
-  #   base: 0
-  #   number_of_functions: 0
-  #   number_of_names: 0
-  #   address_of_functions: 0
-  #   address_of_names: 0
-  #   address_of_name_ordinals: 0
-`
-
-// SpoofMetadataConfig stores default metadata spoofing inputs for generate commands.
-type SpoofMetadataConfig struct {
-	PE *PESpoofMetadataConfig `json:"pe,omitempty" yaml:"pe,omitempty"`
-}
-
-// PESpoofMetadataConfig stores PE-specific spoofing inputs.
-type PESpoofMetadataConfig struct {
-	Source *SpoofMetadataDataSource `json:"source,omitempty" yaml:"source,omitempty"`
-	Icon   *SpoofMetadataDataSource `json:"icon,omitempty" yaml:"icon,omitempty"`
-
-	ResourceDirectory        *ImageResourceDirectory        `json:"resource_directory,omitempty" yaml:"resource_directory,omitempty"`
-	ResourceDirectoryEntries []*ImageResourceDirectoryEntry `json:"resource_directory_entries,omitempty" yaml:"resource_directory_entries,omitempty"`
-	ResourceDataEntries      []*ImageResourceDataEntry      `json:"resource_data_entries,omitempty" yaml:"resource_data_entries,omitempty"`
-	ExportDirectory          *ImageExportDirectory          `json:"export_directory,omitempty" yaml:"export_directory,omitempty"`
-}
-
-// SpoofMetadataDataSource points to bytes that should be sent to the server.
-// Either Path or Base64 may be set.
-type SpoofMetadataDataSource struct {
-	Name   string `json:"name,omitempty" yaml:"name,omitempty"`
-	Path   string `json:"path,omitempty" yaml:"path,omitempty"`
-	Base64 string `json:"base64,omitempty" yaml:"base64,omitempty"`
-}
-
-type ImageResourceDirectory struct {
-	Characteristics      uint32 `json:"characteristics,omitempty" yaml:"characteristics,omitempty"`
-	TimeDateStamp        uint32 `json:"time_date_stamp,omitempty" yaml:"time_date_stamp,omitempty"`
-	MajorVersion         uint32 `json:"major_version,omitempty" yaml:"major_version,omitempty"`
-	MinorVersion         uint32 `json:"minor_version,omitempty" yaml:"minor_version,omitempty"`
-	NumberOfNamedEntries uint32 `json:"number_of_named_entries,omitempty" yaml:"number_of_named_entries,omitempty"`
-	NumberOfIDEntries    uint32 `json:"number_of_id_entries,omitempty" yaml:"number_of_id_entries,omitempty"`
-}
-
-type ImageResourceDirectoryEntry struct {
-	Name         uint32 `json:"name,omitempty" yaml:"name,omitempty"`
-	OffsetToData uint32 `json:"offset_to_data,omitempty" yaml:"offset_to_data,omitempty"`
-}
-
-type ImageResourceDataEntry struct {
-	OffsetToData uint32 `json:"offset_to_data,omitempty" yaml:"offset_to_data,omitempty"`
-	Size         uint32 `json:"size,omitempty" yaml:"size,omitempty"`
-	CodePage     uint32 `json:"code_page,omitempty" yaml:"code_page,omitempty"`
-	Reserved     uint32 `json:"reserved,omitempty" yaml:"reserved,omitempty"`
-}
-
-type ImageExportDirectory struct {
-	Characteristics       uint32 `json:"characteristics,omitempty" yaml:"characteristics,omitempty"`
-	TimeDateStamp         uint32 `json:"time_date_stamp,omitempty" yaml:"time_date_stamp,omitempty"`
-	MajorVersion          uint32 `json:"major_version,omitempty" yaml:"major_version,omitempty"`
-	MinorVersion          uint32 `json:"minor_version,omitempty" yaml:"minor_version,omitempty"`
-	Name                  uint32 `json:"name,omitempty" yaml:"name,omitempty"`
-	Base                  uint32 `json:"base,omitempty" yaml:"base,omitempty"`
-	NumberOfFunctions     uint32 `json:"number_of_functions,omitempty" yaml:"number_of_functions,omitempty"`
-	NumberOfNames         uint32 `json:"number_of_names,omitempty" yaml:"number_of_names,omitempty"`
-	AddressOfFunctions    uint32 `json:"address_of_functions,omitempty" yaml:"address_of_functions,omitempty"`
-	AddressOfNames        uint32 `json:"address_of_names,omitempty" yaml:"address_of_names,omitempty"`
-	AddressOfNameOrdinals uint32 `json:"address_of_name_ordinals,omitempty" yaml:"address_of_name_ordinals,omitempty"`
-}
-
-// SpoofMetadataConfigPath returns the spoof metadata config file path.
-func SpoofMetadataConfigPath() string {
-	rootDir, _ := filepath.Abs(GetRootAppDir())
-	return filepath.Join(rootDir, spoofMetadataFileName)
-}
-
-// LoadSpoofMetadataConfig loads spoof metadata config from disk, writing defaults
-// if the file is missing.
-func LoadSpoofMetadataConfig() (*SpoofMetadataConfig, error) {
-	config := defaultSpoofMetadataConfig()
-	configPath := SpoofMetadataConfigPath()
-
-	data, err := os.ReadFile(configPath)
-	if err != nil {
-		if !os.IsNotExist(err) {
-			return defaultSpoofMetadataConfig(), err
-		}
-		if err := os.WriteFile(configPath, []byte(defaultSpoofMetadataConfigTemplate), 0o600); err != nil {
-			return defaultSpoofMetadataConfig(), err
-		}
-		data = []byte(defaultSpoofMetadataConfigTemplate)
-	}
-	if err := yaml.Unmarshal(data, config); err != nil {
-		return defaultSpoofMetadataConfig(), err
-	}
-
-	normalizeSpoofMetadataConfig(config)
-	return config, nil
-}
-
-// SaveSpoofMetadataConfig writes spoof metadata config to disk.
-func SaveSpoofMetadataConfig(config *SpoofMetadataConfig) error {
-	if config == nil {
-		config = defaultSpoofMetadataConfig()
-	}
-	normalizeSpoofMetadataConfig(config)
-	data, err := yaml.Marshal(config)
-	if err != nil {
-		return err
-	}
-	return os.WriteFile(SpoofMetadataConfigPath(), data, 0o600)
-}
-
-func normalizeSpoofMetadataConfig(config *SpoofMetadataConfig) {
-	if config.PE == nil {
-		config.PE = &PESpoofMetadataConfig{}
-	}
-	if config.PE.Source == nil {
-		config.PE.Source = &SpoofMetadataDataSource{Name: "metadata-source.exe"}
-	}
-	if config.PE.Icon == nil {
-		config.PE.Icon = &SpoofMetadataDataSource{Name: "icon.ico"}
-	}
-}
-
-func defaultSpoofMetadataConfig() *SpoofMetadataConfig {
-	return &SpoofMetadataConfig{
-		PE: &PESpoofMetadataConfig{
-			Source: &SpoofMetadataDataSource{
-				Name: "metadata-source.exe",
-				Path: "",
-			},
-			Icon: &SpoofMetadataDataSource{
-				Name: "icon.ico",
-				Path: "",
-			},
-		},
-	}
-}

client/cli/README.md

@@ -1,14 +1,4 @@
-# client/cli
+CLI
+===
 
-## Overview
-
-Defines the Cobra root command and CLI initialization for the Sliver client binary. Sets up persistent flags, environment bootstrapping, and command wiring. Core logic addresses console, implant, import, and version within the cli package.
-
-## Go Files
-
-- `cli.go` – Builds the root Cobra command, wires global flags, and starts the console UI.
-- `config.go` – Parses CLI configuration files and environment variables used during startup.
-- `console.go` – Launches the interactive console mode and handles profile selection.
-- `implant.go` – Implements CLI entry points for implant-specific operations without launching the console.
-- `import.go` – Provides import routines for bringing external state into the client (e.g., implants or loot).
-- `version.go` – Prints version/build information for the CLI binary.
+This package implements the Sliver client cli.

client/cli/cli.go

@@ -51,8 +51,6 @@ func init() {
 	defer logFile.Close()
 
 	rootCmd.TraverseChildren = true
-	rootCmd.Flags().String(RCFlagName, "", "path to rc script file")
-	rootCmd.PersistentFlags().Bool(enableWGFlag, false, "connect to multiplayer through the operator config's WireGuard wrapper")
 
 	// Create the console client, without any RPC or commands bound to it yet.
 	// This created before anything so that multiple commands can make use of
@@ -71,9 +69,6 @@ func init() {
 	// other command trees below, such as the implant one.
 	rootCmd.AddCommand(consoleCmd(con))
 
-	// MCP stdio server.
-	rootCmd.AddCommand(mcpCmd(con))
-
 	// Implant.
 	// The implant command allows users to run commands on slivers from their
 	// system shell. It makes use of pre-runners for connecting to the server

client/cli/config.go

@@ -23,34 +23,48 @@ import (
 	"sort"
 
 	"github.com/bishopfox/sliver/client/assets"
-	"github.com/bishopfox/sliver/client/forms"
+	"gopkg.in/AlecAivazis/survey.v1"
 )
 
-func selectConfig() (string, *assets.ClientConfig) {
+func selectConfig() *assets.ClientConfig {
 	configs := assets.GetConfigs()
 
 	if len(configs) == 0 {
-		return "", nil
+		return nil
 	}
 
 	if len(configs) == 1 {
-		for key, config := range configs {
-			return key, config
+		for _, config := range configs {
+			return config
 		}
 	}
 
-	keys := make([]string, 0, len(configs))
-	for key := range configs {
-		keys = append(keys, key)
+	answer := struct{ Config string }{}
+	qs := getPromptForConfigs(configs)
+	err := survey.Ask(qs, &answer)
+	if err != nil {
+		fmt.Println(err.Error())
+		return nil
+	}
+
+	return configs[answer.Config]
+}
+
+func getPromptForConfigs(configs map[string]*assets.ClientConfig) []*survey.Question {
+	keys := []string{}
+	for k := range configs {
+		keys = append(keys, k)
 	}
 	sort.Strings(keys)
 
-	selection := keys[0]
-	err := forms.Select("Select a server:", keys, &selection)
-	if err != nil {
-		fmt.Println(err.Error())
-		return "", nil
+	return []*survey.Question{
+		{
+			Name: "config",
+			Prompt: &survey.Select{
+				Message: "Select a server:",
+				Options: keys,
+				Default: keys[0],
+			},
+		},
 	}
-
-	return selection, configs[selection]
 }

client/cli/connect_spinner.go

@@ -1,177 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"io"
-	"strings"
-	"time"
-	"unicode/utf8"
-
-	bspinner "charm.land/bubbles/v2/spinner"
-	"github.com/bishopfox/sliver/client/transport"
-	"github.com/bishopfox/sliver/protobuf/rpcpb"
-	"google.golang.org/grpc"
-)
-
-const (
-	minConnectSpinnerDuration = 900 * time.Millisecond
-	minConnectStatusDuration  = 350 * time.Millisecond
-)
-
-type connectResult struct {
-	rpc  rpcpb.SliverRPCClient
-	conn *grpc.ClientConn
-	err  error
-}
-
-func connectWithSpinner(out io.Writer, target string, connect func(transport.ConnectStatusFn) (rpcpb.SliverRPCClient, *grpc.ClientConn, error)) (rpcpb.SliverRPCClient, *grpc.ClientConn, error) {
-	statusCh := make(chan string, 8)
-	resultCh := make(chan connectResult, 1)
-
-	go func() {
-		rpc, conn, err := connect(func(status string) {
-			sendStatus(statusCh, status)
-		})
-		resultCh <- connectResult{rpc: rpc, conn: conn, err: err}
-	}()
-
-	currentStatus := ""
-	currentStatusSince := time.Time{}
-	queuedStatus := ""
-	lastWidth := 0
-	spinner := bspinner.New(bspinner.WithSpinner(bspinner.Line))
-	ticker := time.NewTicker(spinner.Spinner.FPS)
-	defer ticker.Stop()
-	startedAt := time.Now()
-	var pendingResult *connectResult
-
-	setStatus := func(status string) {
-		status = strings.TrimSpace(status)
-		if status == "" || status == currentStatus {
-			return
-		}
-		currentStatus = status
-		currentStatusSince = time.Now()
-	}
-
-	stageStatus := func(status string) {
-		status = strings.TrimSpace(status)
-		if status == "" {
-			return
-		}
-		if currentStatus == "" || time.Since(currentStatusSince) >= minConnectStatusDuration {
-			queuedStatus = ""
-			setStatus(status)
-			return
-		}
-		queuedStatus = status
-	}
-
-	flushQueuedStatus := func() {
-		if queuedStatus == "" || time.Since(currentStatusSince) < minConnectStatusDuration {
-			return
-		}
-		nextStatus := queuedStatus
-		queuedStatus = ""
-		setStatus(nextStatus)
-	}
-
-	canReturnPendingResult := func() bool {
-		if pendingResult == nil {
-			return false
-		}
-		if pendingResult.err != nil {
-			return true
-		}
-		if time.Since(startedAt) < minConnectSpinnerDuration {
-			return false
-		}
-		if queuedStatus != "" {
-			return false
-		}
-		if !currentStatusSince.IsZero() && time.Since(currentStatusSince) < minConnectStatusDuration {
-			return false
-		}
-		return true
-	}
-
-	render := func() {
-		line := fmt.Sprintf("%s %s", spinner.View(), formatConnectSpinnerMessage(target, currentStatus))
-		lastWidth = writeSpinnerLine(out, line, lastWidth)
-	}
-
-	render()
-	for {
-		select {
-		case status := <-statusCh:
-			stageStatus(status)
-			spinner, _ = spinner.Update(spinner.Tick())
-			render()
-
-		case result := <-resultCh:
-			pendingResult = &result
-
-		case <-ticker.C:
-			spinner, _ = spinner.Update(spinner.Tick())
-			flushQueuedStatus()
-			render()
-			if canReturnPendingResult() {
-				result := *pendingResult
-				pendingResult = nil
-				clearSpinnerLine(out, lastWidth)
-				return result.rpc, result.conn, result.err
-			}
-		}
-
-		if pendingResult != nil && pendingResult.err != nil {
-			result := *pendingResult
-			pendingResult = nil
-			clearSpinnerLine(out, lastWidth)
-			return result.rpc, result.conn, result.err
-		}
-	}
-}
-
-func sendStatus(statusCh chan string, status string) {
-	status = strings.TrimSpace(status)
-	if status == "" {
-		return
-	}
-	statusCh <- status
-}
-
-func formatConnectSpinnerMessage(target string, status string) string {
-	target = strings.TrimSpace(target)
-	status = strings.TrimSpace(status)
-
-	if target == "" {
-		if status == "" {
-			return "Connecting ..."
-		}
-		return fmt.Sprintf("Connecting (%s) ...", status)
-	}
-	if status == "" {
-		return fmt.Sprintf("Connecting to %s ...", target)
-	}
-	return fmt.Sprintf("Connecting to %s (%s) ...", target, status)
-}
-
-func writeSpinnerLine(out io.Writer, line string, lastWidth int) int {
-	width := utf8.RuneCountInString(line)
-	padding := ""
-	if lastWidth > width {
-		padding = strings.Repeat(" ", lastWidth-width)
-	}
-	fmt.Fprintf(out, "\r%s%s", line, padding)
-	if width > lastWidth {
-		return width
-	}
-	return lastWidth
-}
-
-func clearSpinnerLine(out io.Writer, lastWidth int) {
-	if lastWidth <= 0 {
-		return
-	}
-	fmt.Fprintf(out, "\r%s\r", strings.Repeat(" ", lastWidth))
-}

client/cli/connect_spinner_test.go

@@ -1,132 +0,0 @@
-package cli
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/bishopfox/sliver/client/transport"
-	"github.com/bishopfox/sliver/protobuf/rpcpb"
-	"google.golang.org/grpc"
-)
-
-func TestFormatConnectSpinnerMessage(t *testing.T) {
-	tests := []struct {
-		name   string
-		target string
-		status string
-		want   string
-	}{
-		{
-			name:   "target only",
-			target: "127.0.0.1:31337",
-			want:   "Connecting to 127.0.0.1:31337 ...",
-		},
-		{
-			name:   "target with status",
-			target: "127.0.0.1:31337",
-			status: "wireguard",
-			want:   "Connecting to 127.0.0.1:31337 (wireguard) ...",
-		},
-		{
-			name:   "status without target",
-			status: "grpc/mtls",
-			want:   "Connecting (grpc/mtls) ...",
-		},
-		{
-			name:   "trim whitespace",
-			target: " 127.0.0.1:31337 ",
-			status: " grpc/mtls over wireguard ",
-			want:   "Connecting to 127.0.0.1:31337 (grpc/mtls over wireguard) ...",
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			if got := formatConnectSpinnerMessage(test.target, test.status); got != test.want {
-				t.Fatalf("expected %q, got %q", test.want, got)
-			}
-		})
-	}
-}
-
-func TestConnectWithSpinnerOutput(t *testing.T) {
-	var out bytes.Buffer
-	spinnerDelay := 2 * (100 * time.Millisecond)
-
-	_, _, err := connectWithSpinner(&out, "127.0.0.1:31337", func(statusFn transport.ConnectStatusFn) (rpcpb.SliverRPCClient, *grpc.ClientConn, error) {
-		statusFn("wireguard")
-		time.Sleep(spinnerDelay)
-		statusFn("grpc/mtls over wireguard")
-		time.Sleep(spinnerDelay)
-		return nil, nil, nil
-	})
-	if err != nil {
-		t.Fatalf("connectWithSpinner returned error: %v", err)
-	}
-
-	got := out.String()
-	if !strings.Contains(got, "Connecting to 127.0.0.1:31337 (wireguard) ...") {
-		t.Fatalf("expected wireguard status in output, got %q", got)
-	}
-	if !strings.Contains(got, "Connecting to 127.0.0.1:31337 (grpc/mtls over wireguard) ...") {
-		t.Fatalf("expected grpc over wireguard status in output, got %q", got)
-	}
-	frameCount := 0
-	for _, frame := range []string{"|", "/", "-", "\\"} {
-		if strings.Contains(got, frame+" Connecting to 127.0.0.1:31337") {
-			frameCount++
-		}
-	}
-	if frameCount < 2 {
-		t.Fatalf("expected multiple spinner frames in output, got %q", got)
-	}
-}
-
-func TestConnectWithSpinnerFastSuccessStillShowsMultipleFrames(t *testing.T) {
-	var out bytes.Buffer
-
-	_, _, err := connectWithSpinner(&out, "127.0.0.1:31337", func(statusFn transport.ConnectStatusFn) (rpcpb.SliverRPCClient, *grpc.ClientConn, error) {
-		statusFn("grpc/mtls")
-		return nil, nil, nil
-	})
-	if err != nil {
-		t.Fatalf("connectWithSpinner returned error: %v", err)
-	}
-
-	got := out.String()
-	frameCount := 0
-	for _, frame := range []string{"|", "/", "-", "\\"} {
-		if strings.Contains(got, frame+" Connecting to 127.0.0.1:31337 (grpc/mtls) ...") {
-			frameCount++
-		}
-	}
-	if frameCount < 2 {
-		t.Fatalf("expected multiple spinner frames for fast success, got %q", got)
-	}
-}
-
-func TestConnectWithSpinnerFastSuccessShowsEachStatus(t *testing.T) {
-	var out bytes.Buffer
-
-	_, _, err := connectWithSpinner(&out, "127.0.0.1:31337", func(statusFn transport.ConnectStatusFn) (rpcpb.SliverRPCClient, *grpc.ClientConn, error) {
-		statusFn("wireguard")
-		statusFn("grpc/mtls over wireguard")
-		return nil, nil, nil
-	})
-	if err != nil {
-		t.Fatalf("connectWithSpinner returned error: %v", err)
-	}
-
-	got := out.String()
-	if !strings.Contains(got, "Connecting to 127.0.0.1:31337 (wireguard) ...") {
-		t.Fatalf("expected fast success output to include wireguard status, got %q", got)
-	}
-	if !strings.Contains(got, "Connecting to 127.0.0.1:31337 (grpc/mtls over wireguard) ...") {
-		t.Fatalf("expected fast success output to include grpc over wireguard status, got %q", got)
-	}
-	if strings.Contains(got, "Connected to 127.0.0.1:31337") {
-		t.Fatalf("did not expect past-tense success output, got %q", got)
-	}
-}

client/cli/connection_lost.go

@@ -1,26 +0,0 @@
-package cli
-
-import (
-	"context"
-	"fmt"
-	"os"
-
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/connectivity"
-)
-
-func handleConnectionLost(ln *grpc.ClientConn) {
-	if ln == nil {
-		return
-	}
-	currentState := ln.GetState()
-	// currentState should be "Ready" when the connection is established.
-	if ln.WaitForStateChange(context.Background(), currentState) {
-		newState := ln.GetState()
-		// newState will be "Idle" if the connection is lost.
-		if newState == connectivity.Idle {
-			fmt.Println("\nLost connection to server. Exiting now.")
-			os.Exit(1)
-		}
-	}
-}

client/cli/console.go

@@ -19,6 +19,7 @@ package cli
 */
 
 import (
+	"context"
 	"fmt"
 	"os"
 
@@ -29,6 +30,7 @@ import (
 	"github.com/bishopfox/sliver/protobuf/rpcpb"
 	"github.com/spf13/cobra"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/connectivity"
 )
 
 // consoleCmd generates the console with required pre/post runners.
@@ -38,56 +40,66 @@ func consoleCmd(con *console.SliverClient) *cobra.Command {
 		Short: "Start the sliver client console",
 	}
 
-	consoleCmd.Flags().String(RCFlagName, "", "path to rc script file")
 	consoleCmd.RunE, consoleCmd.PersistentPostRunE = consoleRunnerCmd(con, true)
 	return consoleCmd
 }
 
 func consoleRunnerCmd(con *console.SliverClient, run bool) (pre, post func(cmd *cobra.Command, args []string) error) {
-	pre = func(cmd *cobra.Command, _ []string) error {
-		if err := applyMultiplayerConnectMode(cmd); err != nil {
-			return err
-		}
+	var ln *grpc.ClientConn
+
+	pre = func(_ *cobra.Command, _ []string) error {
 
 		configs := assets.GetConfigs()
 		if len(configs) == 0 {
 			fmt.Printf("No config files found at %s (see --help)\n", assets.GetConfigDir())
 			return nil
 		}
-		configKey, config := selectConfig()
+		config := selectConfig()
 		if config == nil {
 			return nil
 		}
 
-		rcScript, err := ReadRCScript(cmd)
-		if err != nil {
-			fmt.Printf("Failed to read rc script: %s\n", err)
-			return nil
-		}
-
-		target := fmt.Sprintf("%s:%d", config.LHost, config.LPort)
-		var rpc rpcpb.SliverRPCClient
-		var ln *grpc.ClientConn
-
 		// Don't clobber output when simply running an implant command from system shell.
 		if run {
-			rpc, ln, err = connectWithSpinner(os.Stdout, target, func(statusFn transport.ConnectStatusFn) (rpcpb.SliverRPCClient, *grpc.ClientConn, error) {
-				return transport.MTLSConnectWithStatus(config, statusFn)
-			})
-		} else {
-			rpc, ln, err = transport.MTLSConnect(config)
+			fmt.Printf("Connecting to %s:%d ...\n", config.LHost, config.LPort)
 		}
+
+		var rpc rpcpb.SliverRPCClient
+		var err error
+
+		rpc, ln, err = transport.MTLSConnect(config)
 		if err != nil {
-			fmt.Printf("Connection to server failed %s\n", err)
+			fmt.Printf("Connection to server failed %s", err)
 			return nil
 		}
-		return console.StartClient(con, rpc, ln, &console.ConnectionDetails{ConfigKey: configKey, Config: config}, command.ServerCommands(con, nil), command.SliverCommands(con), run, rcScript)
+
+		// Wait for any connection state changes and exit if the connection is lost.
+		go handleConnectionLost(ln)
+
+		return console.StartClient(con, rpc, command.ServerCommands(con, nil), command.SliverCommands(con), run)
 	}
 
 	// Close the RPC connection once exiting
 	post = func(_ *cobra.Command, _ []string) error {
-		return con.CloseConnection()
+		if ln != nil {
+			return ln.Close()
+		}
+
+		return nil
 	}
 
 	return pre, post
 }
+
+func handleConnectionLost(ln *grpc.ClientConn) {
+	currentState := ln.GetState()
+	// currentState should be "Ready" when the connection is established.
+	if ln.WaitForStateChange(context.Background(), currentState) {
+		newState := ln.GetState()
+		// newState will be "Idle" if the connection is lost.
+		if newState == connectivity.Idle {
+			fmt.Println("\nLost connection to server. Exiting now.")
+			os.Exit(1)
+		}
+	}
+}

client/cli/mcp.go

@@ -1,98 +0,0 @@
-package cli
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2023  Bishop Fox
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/bishopfox/sliver/client/assets"
-	"github.com/bishopfox/sliver/client/console"
-	clientmcp "github.com/bishopfox/sliver/client/mcp"
-	"github.com/bishopfox/sliver/client/transport"
-	"github.com/spf13/cobra"
-)
-
-func mcpCmd(con *console.SliverClient) *cobra.Command {
-	mcpCmd := &cobra.Command{
-		Use:   "mcp",
-		Short: "Start the MCP stdio server",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runMCP(cmd, con)
-		},
-	}
-	mcpCmd.Flags().String("config", "", "path to client config file")
-	return mcpCmd
-}
-
-func runMCP(cmd *cobra.Command, con *console.SliverClient) error {
-	if err := applyMultiplayerConnectMode(cmd); err != nil {
-		return err
-	}
-
-	configPath, _ := cmd.Flags().GetString("config")
-	config, err := loadMCPClientConfig(configPath)
-	if err != nil {
-		fmt.Printf("%s\n", err)
-		return nil
-	}
-
-	rpc, ln, err := transport.MTLSConnect(config)
-	if err != nil {
-		fmt.Printf("Connection to server failed %s\n", err)
-		return nil
-	}
-	defer transport.CloseGRPCConnection(ln)
-
-	con.Rpc = rpc
-	go handleConnectionLost(ln)
-
-	cfg := clientmcp.DefaultConfig()
-	if err := clientmcp.ServeStdio(cfg, con.Rpc); err != nil {
-		fmt.Printf("MCP server error: %s\n", err)
-		return nil
-	}
-	return nil
-}
-
-func loadMCPClientConfig(path string) (*assets.ClientConfig, error) {
-	if path != "" {
-		configPath := path
-		if !filepath.IsAbs(configPath) {
-			if _, err := os.Stat(configPath); err != nil {
-				configPath = filepath.Join(assets.GetConfigDir(), configPath)
-			}
-		}
-		return assets.ReadConfig(configPath)
-	}
-
-	configs := assets.GetConfigs()
-	switch len(configs) {
-	case 0:
-		return nil, fmt.Errorf("no config files found at %s (use --config)", assets.GetConfigDir())
-	case 1:
-		for _, config := range configs {
-			return config, nil
-		}
-	default:
-		return nil, fmt.Errorf("multiple configs found; use --config to select one")
-	}
-	return nil, fmt.Errorf("no config files found")
-}

client/cli/rc.go

@@ -1,31 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/spf13/cobra"
-)
-
-const RCFlagName = "rc"
-
-func ReadRCScript(cmd *cobra.Command) (string, error) {
-	if cmd == nil {
-		return "", nil
-	}
-	if cmd.Flags().Lookup(RCFlagName) == nil {
-		return "", nil
-	}
-	rcPath, err := cmd.Flags().GetString(RCFlagName)
-	if err != nil {
-		return "", err
-	}
-	if rcPath == "" {
-		return "", nil
-	}
-	data, err := os.ReadFile(rcPath)
-	if err != nil {
-		return "", fmt.Errorf("read rc script %q: %w", rcPath, err)
-	}
-	return string(data), nil
-}

client/cli/transport_mode.go

@@ -1,29 +0,0 @@
-package cli
-
-import (
-	"github.com/bishopfox/sliver/client/transport"
-	"github.com/spf13/cobra"
-)
-
-const (
-	enableWGFlag = "enable-wg"
-)
-
-func applyMultiplayerConnectMode(cmd *cobra.Command) error {
-	if cmd == nil {
-		transport.SetMultiplayerConnectMode(transport.MultiplayerConnectDirect)
-		return nil
-	}
-
-	enableWG, err := cmd.Flags().GetBool(enableWGFlag)
-	if err != nil {
-		return err
-	}
-
-	mode := transport.MultiplayerConnectDirect
-	if enableWG {
-		mode = transport.MultiplayerConnectEnableWG
-	}
-	transport.SetMultiplayerConnectMode(mode)
-	return nil
-}

client/command/README.md

@@ -1,68 +1,14 @@
-# client/command
+Command
+=======
 
-## Overview
+This package contains all of the client command implementations that are shared between the client and the server console.
 
-Shared registration glue, scaffolding, and helpers for Sliver client console command groups. Hosts common utilities for binding Cobra commands to RPC-backed actions. Core logic addresses sliver within the command package.
+### Developers
 
-## Go Files
-
-- `command.go` – Provides helpers for binding Cobra commands, flag sets, and visibility filters into the client command tree.
-- `server.go` – Defines the server menu composition, wiring each server-side command group onto the root console structure at runtime.
-- `main.go` – Builds the implant/Sliver menu, attaching per-target command groups and loading alias/extension manifests before exposure.
-
-## Sub-packages
-
-- `ai/` – Implements the 'ai' Bubble Tea layout preview command for the Sliver client console.
-- `alias/` – Implements the 'alias' command group for the Sliver client console.
-- `armory/` – Implements the 'armory' command group for the Sliver client console.
-- `backdoor/` – Implements the 'backdoor' command group for the Sliver client console.
-- `beacons/` – Implements the 'beacons' command group for the Sliver client console.
-- `builders/` – Implements the 'builders' command group for the Sliver client console.
-- `c2profiles/` – Implements the 'c2profiles' command group for the Sliver client console.
-- `certificates/` – Implements the 'certificates' command group for the Sliver client console.
-- `clean/` – Implements the 'clean' command group for the Sliver client console.
-- `completers/` – Implements the 'completers' command group for the Sliver client console.
-- `crack/` – Implements the 'crack' command group for the Sliver client console.
-- `creds/` – Implements the 'creds' command group for the Sliver client console.
-- `cursed/` – Implements the 'cursed' command group for the Sliver client console.
-- `dllhijack/` – Implements the 'dllhijack' command group for the Sliver client console.
-- `edit/` – Implements the 'edit' command for the Sliver client console.
-- `environment/` – Implements the 'environment' command group for the Sliver client console.
-- `exec/` – Implements the 'exec' command group for the Sliver client console.
-- `exit/` – Implements the 'exit' command group for the Sliver client console.
-- `extensions/` – Implements the 'extensions' command group for the Sliver client console.
-- `filesystem/` – Implements the 'filesystem' command group for the Sliver client console.
-- `flags/` – Implements the 'flags' command group for the Sliver client console.
-- `generate/` – Implements the 'generate' command group for the Sliver client console.
-- `help/` – Implements the 'help' command group for the Sliver client console.
-- `hosts/` – Implements the 'hosts' command group for the Sliver client console.
-- `info/` – Implements the 'info' command group for the Sliver client console.
-- `jobs/` – Implements the 'jobs' command group for the Sliver client console.
-- `kill/` – Implements the 'kill' command group for the Sliver client console.
-- `licenses/` – Implements the 'licenses' command group for the Sliver client console.
-- `loot/` – Implements the 'loot' command group for the Sliver client console.
-- `monitor/` – Implements the 'monitor' command group for the Sliver client console.
-- `mcp/` – Implements the 'mcp' command group for the Sliver client console.
-- `network/` – Implements the 'network' command group for the Sliver client console.
-- `operators/` – Implements the 'operators' command group for the Sliver client console.
-- `pivots/` – Implements the 'pivots' command group for the Sliver client console.
-- `portfwd/` – Implements the 'portfwd' command group for the Sliver client console.
-- `privilege/` – Implements the 'privilege' command group for the Sliver client console.
-- `processes/` – Implements the 'processes' command group for the Sliver client console.
-- `reaction/` – Implements the 'reaction' command group for the Sliver client console.
-- `reconfig/` – Implements the 'reconfig' command group for the Sliver client console.
-- `registry/` – Implements the 'registry' command group for the Sliver client console.
-- `rportfwd/` – Implements the 'rportfwd' command group for the Sliver client console.
-- `screenshot/` – Implements the 'screenshot' command group for the Sliver client console.
-- `sessions/` – Implements the 'sessions' command group for the Sliver client console.
-- `settings/` – Implements the 'settings' command group for the Sliver client console.
-- `shell/` – Implements the 'shell' command group for the Sliver client console.
-- `shikata-ga-nai/` – Implements the 'shikata-ga-nai' command group for the Sliver client console.
-- `socks/` – Implements the 'socks' command group for the Sliver client console.
-- `taskmany/` – Implements the 'taskmany' command group for the Sliver client console.
-- `tasks/` – Implements the 'tasks' command group for the Sliver client console.
-- `update/` – Implements the 'update' command group for the Sliver client console.
-- `use/` – Implements the 'use' command group for the Sliver client console.
-- `wasm/` – Implements the 'wasm' command group for the Sliver client console.
-- `websites/` – Implements the 'websites' command group for the Sliver client console.
-- `wireguard/` – Implements the 'wireguard' command group for the Sliver client console.
+General guidance on the structure of this package:
+ * One command per file and the name of the file should reflect the command it implements (or there about, trivial commands can go into the same file). This makes it easy to find where a command implementation lives within a package or to search by file name if it is not clear which package implements a given command.
+ * The root command, and reused code should go into the file named after the command
+   * For example, code shared between the `generate` and the `regenerate` command should go in `generate.go`, and any `regenerate` specific code should go in `regenerate.go`
+ * Command entrypoint functions should have the suffix `Cmd` e.g., `GenerateCmd` is the entrypoint for `generate`
+   * Command entrypoints should always a function signature of `func (ctx *grumble.Context, con *console.SliverConsoleClient)`
+ * Functions that are only ever exported for other commands to use should go in a `helpers.go`, if the function is used internally and exported follow the guidance above on shared code.

client/command/ai/README.md

@@ -1,5 +0,0 @@
-# client/command/ai
-
-Implements the `ai` command for the Sliver client console.
-
-The TUI loads server-backed AI conversation threads over gRPC, submits prompts to the server, and refreshes when `AIConversationEvent` updates arrive with assistant replies or failure messages.

client/command/ai/ai.go

@@ -1,242 +0,0 @@
-package ai
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2026  Bishop Fox
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-import (
-	"fmt"
-	"os"
-	"strings"
-	"time"
-
-	tea "charm.land/bubbletea/v2"
-	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/client/termio"
-	"github.com/bishopfox/sliver/protobuf/clientpb"
-	"github.com/charmbracelet/colorprofile"
-	"github.com/spf13/cobra"
-	"golang.org/x/term"
-)
-
-var openAIProgramTTY = tea.OpenTTY
-
-// AICmd launches the AI conversation TUI.
-func AICmd(_ *cobra.Command, con *console.SliverClient, _ []string) {
-	if con == nil || con.Rpc == nil {
-		if con != nil {
-			con.PrintErrorf("Connect to a server before using `ai`.\n")
-		}
-		return
-	}
-
-	listenerID, listener := con.CreateEventListener()
-	defer con.RemoveEventListener(listenerID)
-	restoreEventNotifications := con.SuppressEventNotifications()
-	defer restoreEventNotifications()
-
-	model := newAIModel(con, buildAIContext(con), listener)
-	model.showExperimentalWarningModal()
-
-	width, height := 100, 30
-	if w, h, err := term.GetSize(0); err == nil && w > 0 && h > 0 {
-		width, height = w, h
-	}
-
-	opts := []tea.ProgramOption{
-		tea.WithWindowSize(width, height),
-		tea.WithColorProfile(colorprofile.TrueColor),
-	}
-	ttyOpts, cleanup := configureAIProgramTTY()
-	if cleanup != nil {
-		defer cleanup()
-	}
-	opts = append(opts, ttyOpts...)
-
-	program := tea.NewProgram(model, opts...)
-	if _, err := program.Run(); err != nil {
-		con.PrintErrorf("AI TUI error: %s\n", err)
-	}
-}
-
-// Console logging can swap stdout/stderr to pipes so session output can be tee'd
-// to disk. Bubble Tea needs a real TTY output to enable terminal features like
-// mouse reporting, so bind the AI TUI back to the interactive terminal when
-// stdout is no longer the controlling TTY.
-func configureAIProgramTTY() ([]tea.ProgramOption, func()) {
-	stdinTTY := isAITTY(os.Stdin)
-	stdoutTTY := isAITTY(os.Stdout)
-
-	switch {
-	case !stdinTTY || stdoutTTY:
-		return nil, nil
-
-	case isAITTY(termio.InteractiveInput()) && isAITTY(termio.InteractiveOutput()):
-		return []tea.ProgramOption{
-			tea.WithInput(termio.InteractiveInput()),
-			tea.WithOutput(termio.InteractiveOutput()),
-		}, nil
-
-	default:
-		inTTY, outTTY, err := openAIProgramTTY()
-		if err != nil {
-			return nil, nil
-		}
-		return []tea.ProgramOption{
-				tea.WithInput(inTTY),
-				tea.WithOutput(outTTY),
-			}, func() {
-				_ = inTTY.Close()
-				if outTTY != inTTY {
-					_ = outTTY.Close()
-				}
-			}
-	}
-}
-
-func isAITTY(file *os.File) bool {
-	return file != nil && term.IsTerminal(int(file.Fd()))
-}
-
-type aiContext struct {
-	target     aiTargetSummary
-	connection aiConnectionSummary
-	status     string
-}
-
-type aiTargetSummary struct {
-	SessionID string
-	BeaconID  string
-	Label     string
-	Host      string
-	OS        string
-	Arch      string
-	C2        string
-	Mode      string
-	Details   []string
-}
-
-type aiConnectionSummary struct {
-	Profile  string
-	Server   string
-	Operator string
-	State    string
-}
-
-func defaultAITargetSummary() aiTargetSummary {
-	return aiTargetSummary{
-		Label: "No active target",
-		Host:  "Select a session or beacon with `use` or ctrl+s",
-		Mode:  "offline preview",
-		C2:    "n/a",
-		OS:    "unknown",
-		Arch:  "unknown",
-	}
-}
-
-func aiSessionTargetSummary(session *clientpb.Session) aiTargetSummary {
-	if session == nil {
-		return defaultAITargetSummary()
-	}
-
-	return aiTargetSummary{
-		SessionID: session.ID,
-		Label:     fmt.Sprintf("Session %s", fallback(session.Name, session.ID)),
-		Host:      fallback(session.Hostname, "<unknown host>"),
-		OS:        fallback(session.OS, "unknown"),
-		Arch:      fallback(session.Arch, "unknown"),
-		C2:        fallback(session.ActiveC2, "unknown"),
-		Mode:      "interactive session",
-		Details: []string{
-			fmt.Sprintf("User: %s", fallback(session.Username, "<unknown>")),
-			fmt.Sprintf("PID: %d", session.PID),
-			fmt.Sprintf("Remote: %s", fallback(session.RemoteAddress, "<unknown>")),
-		},
-	}
-}
-
-func aiBeaconTargetSummary(beacon *clientpb.Beacon) aiTargetSummary {
-	if beacon == nil {
-		return defaultAITargetSummary()
-	}
-
-	return aiTargetSummary{
-		BeaconID: beacon.ID,
-		Label:    fmt.Sprintf("Beacon %s", fallback(beacon.Name, beacon.ID)),
-		Host:     fallback(beacon.Hostname, "<unknown host>"),
-		OS:       fallback(beacon.OS, "unknown"),
-		Arch:     fallback(beacon.Arch, "unknown"),
-		C2:       fallback(beacon.ActiveC2, "unknown"),
-		Mode:     "asynchronous beacon",
-		Details: []string{
-			fmt.Sprintf("User: %s", fallback(beacon.Username, "<unknown>")),
-			fmt.Sprintf("PID: %d", beacon.PID),
-			fmt.Sprintf("Remote: %s", fallback(beacon.RemoteAddress, "<unknown>")),
-			fmt.Sprintf("Interval: %s", time.Duration(beacon.Interval).String()),
-			fmt.Sprintf("Next checkin: %s", formatUnix(beacon.NextCheckin)),
-		},
-	}
-}
-
-func buildAIContext(con *console.SliverClient) aiContext {
-	ctx := aiContext{
-		target: defaultAITargetSummary(),
-		connection: aiConnectionSummary{
-			Profile:  "<disconnected>",
-			Server:   "<unknown>",
-			Operator: "<unknown>",
-			State:    "idle",
-		},
-		status: "Loading AI conversations from the server...",
-	}
-
-	if con != nil {
-		if details, state, ok := con.CurrentConnection(); ok {
-			ctx.connection.State = strings.ToLower(state.String())
-			if details != nil && details.Config != nil {
-				ctx.connection.Profile = fallback(details.ConfigKey, "<profile unavailable>")
-				ctx.connection.Server = fmt.Sprintf("%s:%d", details.Config.LHost, details.Config.LPort)
-				ctx.connection.Operator = fallback(details.Config.Operator, "<unknown>")
-			}
-		}
-
-		session, beacon := con.ActiveTarget.Get()
-		switch {
-		case session != nil:
-			ctx.target = aiSessionTargetSummary(session)
-		case beacon != nil:
-			ctx.target = aiBeaconTargetSummary(beacon)
-		}
-	}
-
-	return ctx
-}
-
-func fallback(value, def string) string {
-	value = strings.TrimSpace(value)
-	if value == "" {
-		return def
-	}
-	return value
-}
-
-func formatUnix(ts int64) string {
-	if ts <= 0 {
-		return "<unknown>"
-	}
-	return time.Unix(ts, 0).Local().Format("2006-01-02 15:04:05")
-}

client/command/ai/commands.go

@@ -1,49 +0,0 @@
-package ai
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2026  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 (
-	"github.com/bishopfox/sliver/client/command/help"
-	"github.com/bishopfox/sliver/client/console"
-	consts "github.com/bishopfox/sliver/client/constants"
-	"github.com/spf13/cobra"
-)
-
-// Commands returns the ai command.
-func Commands(con *console.SliverClient) []*cobra.Command {
-	return []*cobra.Command{newAICommand(consts.SliverCoreHelpGroup, con)}
-}
-
-// ServerCommands returns the ai command for the top-level client REPL.
-func ServerCommands(con *console.SliverClient) []*cobra.Command {
-	return []*cobra.Command{newAICommand(consts.GenericHelpGroup, con)}
-}
-
-func newAICommand(groupID string, con *console.SliverClient) *cobra.Command {
-	return &cobra.Command{
-		Use:     consts.AIStr,
-		Short:   "Open the Sliver AI conversation TUI",
-		Long:    help.GetHelpFor([]string{consts.AIStr}),
-		Args:    cobra.NoArgs,
-		GroupID: groupID,
-		Run: func(cmd *cobra.Command, args []string) {
-			AICmd(cmd, con, args)
-		},
-	}
-}

client/command/ai/grpc_test.go

@@ -1,591 +0,0 @@
-package ai
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2026  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"
-	"net"
-	"sync"
-	"testing"
-
-	"github.com/bishopfox/sliver/client/console"
-	consts "github.com/bishopfox/sliver/client/constants"
-	"github.com/bishopfox/sliver/protobuf/clientpb"
-	"github.com/bishopfox/sliver/protobuf/commonpb"
-	"github.com/bishopfox/sliver/protobuf/rpcpb"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/insecure"
-	"google.golang.org/grpc/test/bufconn"
-	"google.golang.org/protobuf/proto"
-)
-
-func TestLoadAIStateCmdLoadsConversationOverRPC(t *testing.T) {
-	server := &aiRPCServer{
-		providersResp: &clientpb.AIProviderConfigs{
-			Providers: []*clientpb.AIProviderConfig{{Name: "openai", Configured: true}},
-			Config: &clientpb.AIConfigSummary{
-				Provider: "openai",
-				Model:    "gpt-test",
-				Valid:    true,
-			},
-		},
-		conversationsResp: &clientpb.AIConversations{
-			Conversations: []*clientpb.AIConversation{
-				{ID: "conv-1", Provider: "openai", Model: "gpt-test", Title: "First"},
-				{ID: "conv-2", Provider: "openai", Model: "gpt-test", Title: "Second"},
-			},
-		},
-		conversationByID: map[string]*clientpb.AIConversation{
-			"conv-1": {
-				ID:       "conv-1",
-				Provider: "openai",
-				Model:    "gpt-test",
-				Title:    "First",
-				Messages: []*clientpb.AIConversationMessage{
-					{Role: "user", Content: "Hello"},
-				},
-			},
-		},
-	}
-
-	rpcClient, cleanup := newAITestRPCClient(t, server)
-	defer cleanup()
-
-	cmd := loadAIStateCmd(&console.SliverClient{Rpc: rpcClient}, aiTargetSummary{}, "")
-	msg := cmd()
-
-	loaded, ok := msg.(aiLoadedMsg)
-	if !ok {
-		t.Fatalf("expected aiLoadedMsg, got %T", msg)
-	}
-	if loaded.selectedID != "conv-1" {
-		t.Fatalf("unexpected selected conversation id: got=%q want=%q", loaded.selectedID, "conv-1")
-	}
-	if loaded.conversation == nil || loaded.conversation.GetID() != "conv-1" {
-		t.Fatalf("unexpected loaded conversation: %+v", loaded.conversation)
-	}
-	if len(loaded.conversations) != 2 {
-		t.Fatalf("unexpected conversation count: got=%d want=%d", len(loaded.conversations), 2)
-	}
-
-	server.mu.Lock()
-	defer server.mu.Unlock()
-	if server.getProvidersCalls != 1 {
-		t.Fatalf("expected GetAIProviders to be called once, got %d", server.getProvidersCalls)
-	}
-	if server.getConversationsCalls != 1 {
-		t.Fatalf("expected GetAIConversations to be called once, got %d", server.getConversationsCalls)
-	}
-	if len(server.getConversationReqs) != 1 {
-		t.Fatalf("expected GetAIConversation to be called once, got %d", len(server.getConversationReqs))
-	}
-	if server.getConversationReqs[0].GetID() != "conv-1" || !server.getConversationReqs[0].GetIncludeMessages() {
-		t.Fatalf("unexpected GetAIConversation request: %+v", server.getConversationReqs[0])
-	}
-}
-
-func TestLoadAIStateCmdCreatesConversationWhenNoneExist(t *testing.T) {
-	server := &aiRPCServer{
-		providersResp: &clientpb.AIProviderConfigs{
-			Providers: []*clientpb.AIProviderConfig{{Name: "openai", Configured: true}},
-			Config: &clientpb.AIConfigSummary{
-				Provider:     "openai",
-				Model:        "gpt-test",
-				SystemPrompt: "Stay concise.",
-				Valid:        true,
-			},
-		},
-		conversationsResp: &clientpb.AIConversations{},
-		saveConversationResp: &clientpb.AIConversation{
-			ID:           "conv-created",
-			Provider:     "openai",
-			Model:        "gpt-test",
-			Title:        "New conversation",
-			SystemPrompt: "Stay concise.",
-		},
-		conversationByID: map[string]*clientpb.AIConversation{
-			"conv-created": {
-				ID:           "conv-created",
-				Provider:     "openai",
-				Model:        "gpt-test",
-				Title:        "New conversation",
-				SystemPrompt: "Stay concise.",
-			},
-		},
-	}
-
-	rpcClient, cleanup := newAITestRPCClient(t, server)
-	defer cleanup()
-
-	msg := loadAIStateCmd(&console.SliverClient{Rpc: rpcClient}, aiTargetSummary{}, "")()
-
-	loaded, ok := msg.(aiLoadedMsg)
-	if !ok {
-		t.Fatalf("expected aiLoadedMsg, got %T", msg)
-	}
-	if loaded.status != "Created a new AI conversation." {
-		t.Fatalf("unexpected status: %q", loaded.status)
-	}
-	if loaded.selectedID != "conv-created" {
-		t.Fatalf("unexpected selected conversation id: %q", loaded.selectedID)
-	}
-
-	server.mu.Lock()
-	defer server.mu.Unlock()
-	if len(server.saveConversationReqs) != 1 {
-		t.Fatalf("expected SaveAIConversation to be called once, got %d", len(server.saveConversationReqs))
-	}
-	request := server.saveConversationReqs[0]
-	if request.GetProvider() != "openai" || request.GetModel() != "gpt-test" || request.GetTitle() != "New conversation" {
-		t.Fatalf("unexpected SaveAIConversation request: %+v", request)
-	}
-	if request.GetSystemPrompt() != "Stay concise." {
-		t.Fatalf("unexpected SaveAIConversation system prompt: %q", request.GetSystemPrompt())
-	}
-}
-
-func TestSubmitPromptCmdCreatesConversationAndSavesUserMessage(t *testing.T) {
-	server := &aiRPCServer{
-		saveConversationResp: &clientpb.AIConversation{
-			ID:       "conv-created",
-			Provider: "openai",
-			Model:    "gpt-test",
-			Title:    "Explain the workflow.",
-		},
-		saveMessageResp: &clientpb.AIConversationMessage{
-			ID:             "msg-1",
-			ConversationID: "conv-created",
-			Role:           "user",
-			Content:        "Explain the workflow.\n\nWith details.",
-		},
-	}
-
-	rpcClient, cleanup := newAITestRPCClient(t, server)
-	defer cleanup()
-
-	msg := submitPromptCmd(
-		&console.SliverClient{Rpc: rpcClient},
-		aiTargetSummary{SessionID: "session-1"},
-		nil,
-		"openai",
-		"gpt-test",
-		"Stay concise.",
-		"Explain the workflow.\n\nWith details.",
-	)()
-
-	submitted, ok := msg.(aiPromptSubmittedMsg)
-	if !ok {
-		t.Fatalf("expected aiPromptSubmittedMsg, got %T", msg)
-	}
-	if submitted.conversationID != "conv-created" {
-		t.Fatalf("unexpected conversation id: %q", submitted.conversationID)
-	}
-
-	server.mu.Lock()
-	defer server.mu.Unlock()
-	if len(server.saveConversationReqs) != 1 {
-		t.Fatalf("expected SaveAIConversation to be called once, got %d", len(server.saveConversationReqs))
-	}
-	if server.saveConversationReqs[0].GetTitle() != "Explain the workflow." {
-		t.Fatalf("unexpected conversation title: %q", server.saveConversationReqs[0].GetTitle())
-	}
-	if server.saveConversationReqs[0].GetTargetSessionID() != "session-1" {
-		t.Fatalf("expected target session to be forwarded, got %+v", server.saveConversationReqs[0])
-	}
-	if server.saveConversationReqs[0].GetSystemPrompt() != "Stay concise." {
-		t.Fatalf("unexpected conversation system prompt: %q", server.saveConversationReqs[0].GetSystemPrompt())
-	}
-	if len(server.saveMessageReqs) != 1 {
-		t.Fatalf("expected SaveAIConversationMessage to be called once, got %d", len(server.saveMessageReqs))
-	}
-	request := server.saveMessageReqs[0]
-	if request.GetConversationID() != "conv-created" || request.GetProvider() != "openai" || request.GetModel() != "gpt-test" || request.GetRole() != "user" {
-		t.Fatalf("unexpected SaveAIConversationMessage request: %+v", request)
-	}
-	if request.GetContent() != "Explain the workflow.\n\nWith details." {
-		t.Fatalf("unexpected prompt content: %q", request.GetContent())
-	}
-}
-
-func TestSubmitPromptCmdUsesExistingConversationSettings(t *testing.T) {
-	server := &aiRPCServer{
-		saveMessageResp: &clientpb.AIConversationMessage{
-			ID:             "msg-1",
-			ConversationID: "conv-1",
-			Role:           "user",
-			Content:        "hello",
-		},
-	}
-
-	rpcClient, cleanup := newAITestRPCClient(t, server)
-	defer cleanup()
-
-	msg := submitPromptCmd(
-		&console.SliverClient{Rpc: rpcClient},
-		aiTargetSummary{},
-		&clientpb.AIConversation{ID: "conv-1", Provider: "anthropic", Model: "claude-test", Title: "Thread"},
-		"openai",
-		"gpt-test",
-		"Stay concise.",
-		"hello",
-	)()
-
-	if _, ok := msg.(aiPromptSubmittedMsg); !ok {
-		t.Fatalf("expected aiPromptSubmittedMsg, got %T", msg)
-	}
-
-	server.mu.Lock()
-	defer server.mu.Unlock()
-	if len(server.saveConversationReqs) != 0 {
-		t.Fatalf("did not expect SaveAIConversation to be called, got %d calls", len(server.saveConversationReqs))
-	}
-	if len(server.saveMessageReqs) != 1 {
-		t.Fatalf("expected SaveAIConversationMessage to be called once, got %d", len(server.saveMessageReqs))
-	}
-	request := server.saveMessageReqs[0]
-	if request.GetProvider() != "anthropic" || request.GetModel() != "claude-test" {
-		t.Fatalf("unexpected conversation settings in message request: %+v", request)
-	}
-}
-
-func TestDeleteConversationCmdSendsDeleteRequest(t *testing.T) {
-	server := &aiRPCServer{}
-
-	rpcClient, cleanup := newAITestRPCClient(t, server)
-	defer cleanup()
-
-	msg := deleteConversationCmd(
-		&console.SliverClient{Rpc: rpcClient},
-		"conv-1",
-		"conv-2",
-		`Deleted "Thread".`,
-	)()
-
-	deleted, ok := msg.(aiConversationDeletedMsg)
-	if !ok {
-		t.Fatalf("expected aiConversationDeletedMsg, got %T", msg)
-	}
-	if deleted.conversationID != "conv-1" || deleted.selectedID != "conv-2" {
-		t.Fatalf("unexpected delete message: %+v", deleted)
-	}
-
-	server.mu.Lock()
-	defer server.mu.Unlock()
-	if len(server.deleteConversationReqs) != 1 {
-		t.Fatalf("expected DeleteAIConversation to be called once, got %d", len(server.deleteConversationReqs))
-	}
-	if server.deleteConversationReqs[0].GetID() != "conv-1" {
-		t.Fatalf("unexpected DeleteAIConversation request: %+v", server.deleteConversationReqs[0])
-	}
-}
-
-func TestWaitForAIConversationEventCmdFiltersForAIEvents(t *testing.T) {
-	eventPayload := &clientpb.AIConversationEvent{
-		EventType: clientpb.AIConversationEventType_AI_CONVERSATION_EVENT_TYPE_CONVERSATION_UPDATED,
-		Conversation: &clientpb.AIConversation{
-			ID:           "conv-1",
-			OperatorName: "alice",
-		},
-	}
-	data, err := proto.Marshal(eventPayload)
-	if err != nil {
-		t.Fatalf("marshal conversation event: %v", err)
-	}
-
-	listener := make(chan *clientpb.Event, 2)
-	listener <- &clientpb.Event{EventType: consts.WatchtowerEvent}
-	listener <- &clientpb.Event{EventType: consts.AIConversationEvent, Data: data}
-
-	msg := waitForAIConversationEventCmd(listener)()
-
-	aiEvent, ok := msg.(aiConversationEventMsg)
-	if !ok {
-		t.Fatalf("expected aiConversationEventMsg, got %T", msg)
-	}
-	if aiEvent.event == nil || aiEvent.event.GetConversation() == nil || aiEvent.event.GetConversation().GetID() != "conv-1" {
-		t.Fatalf("unexpected AI conversation event payload: %+v", aiEvent.event)
-	}
-}
-
-func TestWaitForAIConversationEventCmdReturnsToastMessages(t *testing.T) {
-	listener := make(chan *clientpb.Event, 1)
-	listener <- &clientpb.Event{
-		EventType: consts.ClientToastEvent,
-		Data:      []byte("Session alpha connected"),
-		Err:       "info",
-	}
-
-	msg := waitForAIConversationEventCmd(listener)()
-
-	toast, ok := msg.(aiToastMsg)
-	if !ok {
-		t.Fatalf("expected aiToastMsg, got %T", msg)
-	}
-	if toast.level != "info" || toast.message != "Session alpha connected" {
-		t.Fatalf("unexpected toast payload: %+v", toast)
-	}
-}
-
-func TestWaitForAIConversationEventCmdReturnsClosedMessage(t *testing.T) {
-	listener := make(chan *clientpb.Event)
-	close(listener)
-
-	msg := waitForAIConversationEventCmd(listener)()
-	if _, ok := msg.(aiListenerClosedMsg); !ok {
-		t.Fatalf("expected aiListenerClosedMsg, got %T", msg)
-	}
-}
-
-func TestAIModelAppliesSharedConversationEventsWithoutReload(t *testing.T) {
-	listener := make(chan *clientpb.Event)
-	close(listener)
-
-	model := newAIModel(nil, aiContext{
-		connection: aiConnectionSummary{Operator: "alice"},
-	}, listener)
-	model.loading = false
-	model.conversations = []*clientpb.AIConversation{{ID: "conv-1", Title: "First"}}
-
-	updated, cmd := model.Update(aiConversationEventMsg{event: &clientpb.AIConversationEvent{
-		EventType: clientpb.AIConversationEventType_AI_CONVERSATION_EVENT_TYPE_CONVERSATION_UPDATED,
-		Conversation: &clientpb.AIConversation{
-			ID:           "conv-2",
-			OperatorName: "bob",
-			Title:        "Shared thread",
-		},
-	}})
-
-	nextModel := updated.(*aiModel)
-	if nextModel.loading {
-		t.Fatal("did not expect shared conversation event to trigger a reload")
-	}
-	if conversationIndexByID(nextModel.conversations, "conv-2") < 0 {
-		t.Fatalf("expected shared conversation to be merged locally, got %+v", nextModel.conversations)
-	}
-	if cmd == nil {
-		t.Fatal("expected shared conversation event to continue listening for events")
-	}
-}
-
-func TestAIModelAppliesDeleteEventsWhileAwaitingResponse(t *testing.T) {
-	listener := make(chan *clientpb.Event)
-	close(listener)
-
-	model := newAIModel(nil, aiContext{
-		connection: aiConnectionSummary{Operator: "alice"},
-	}, listener)
-	model.loading = false
-	model.awaitingResponse = true
-	model.currentConversation = &clientpb.AIConversation{
-		ID:           "conv-2",
-		OperatorName: "alice",
-		UpdatedAt:    100,
-		TurnState:    clientpb.AIConversationTurnState_AI_TURN_STATE_IN_PROGRESS,
-		Messages: []*clientpb.AIConversationMessage{
-			{Role: "user", Content: "still waiting"},
-		},
-	}
-	model.conversations = []*clientpb.AIConversation{
-		{ID: "conv-2", Title: "Current"},
-		{ID: "conv-1", Title: "Fallback"},
-	}
-
-	updated, cmd := model.Update(aiConversationEventMsg{event: &clientpb.AIConversationEvent{
-		EventType:      clientpb.AIConversationEventType_AI_CONVERSATION_EVENT_TYPE_CONVERSATION_DELETED,
-		ConversationID: "conv-2",
-		Conversation: &clientpb.AIConversation{
-			ID: "conv-2",
-		},
-	}})
-
-	nextModel := updated.(*aiModel)
-	if nextModel.loading {
-		t.Fatal("did not expect delete tombstone to trigger a reload")
-	}
-	if nextModel.currentConversation != nil {
-		t.Fatalf("expected deleted conversation to be cleared, got %+v", nextModel.currentConversation)
-	}
-	if conversationIndexByID(nextModel.conversations, "conv-2") >= 0 {
-		t.Fatalf("expected deleted conversation to be removed, got %+v", nextModel.conversations)
-	}
-	if cmd == nil {
-		t.Fatal("expected delete tombstone to continue listening for events")
-	}
-}
-
-type aiRPCServer struct {
-	rpcpb.UnimplementedSliverRPCServer
-
-	mu sync.Mutex
-
-	providersResp        *clientpb.AIProviderConfigs
-	conversationsResp    *clientpb.AIConversations
-	conversationByID     map[string]*clientpb.AIConversation
-	saveConversationResp *clientpb.AIConversation
-	saveMessageResp      *clientpb.AIConversationMessage
-	sessionsResp         *clientpb.Sessions
-	beaconsResp          *clientpb.Beacons
-
-	getProvidersCalls      int
-	getConversationsCalls  int
-	getSessionsCalls       int
-	getBeaconsCalls        int
-	getConversationReqs    []*clientpb.AIConversationReq
-	deleteConversationReqs []*clientpb.AIConversationReq
-	saveConversationReqs   []*clientpb.AIConversation
-	saveMessageReqs        []*clientpb.AIConversationMessage
-	getConversationStart   chan struct{}
-	getConversationWait    <-chan struct{}
-	saveMessageStarted     chan struct{}
-	saveMessageRelease     <-chan struct{}
-}
-
-func (s *aiRPCServer) GetAIProviders(context.Context, *commonpb.Empty) (*clientpb.AIProviderConfigs, error) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.getProvidersCalls++
-	if s.providersResp == nil {
-		return &clientpb.AIProviderConfigs{}, nil
-	}
-	return proto.Clone(s.providersResp).(*clientpb.AIProviderConfigs), nil
-}
-
-func (s *aiRPCServer) GetAIConversations(context.Context, *commonpb.Empty) (*clientpb.AIConversations, error) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.getConversationsCalls++
-	if s.conversationsResp == nil {
-		return &clientpb.AIConversations{}, nil
-	}
-	return proto.Clone(s.conversationsResp).(*clientpb.AIConversations), nil
-}
-
-func (s *aiRPCServer) GetSessions(context.Context, *commonpb.Empty) (*clientpb.Sessions, error) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.getSessionsCalls++
-	if s.sessionsResp == nil {
-		return &clientpb.Sessions{}, nil
-	}
-	return proto.Clone(s.sessionsResp).(*clientpb.Sessions), nil
-}
-
-func (s *aiRPCServer) GetBeacons(context.Context, *commonpb.Empty) (*clientpb.Beacons, error) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.getBeaconsCalls++
-	if s.beaconsResp == nil {
-		return &clientpb.Beacons{}, nil
-	}
-	return proto.Clone(s.beaconsResp).(*clientpb.Beacons), nil
-}
-
-func (s *aiRPCServer) GetAIConversation(_ context.Context, req *clientpb.AIConversationReq) (*clientpb.AIConversation, error) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.getConversationReqs = append(s.getConversationReqs, proto.Clone(req).(*clientpb.AIConversationReq))
-	if s.getConversationStart != nil {
-		select {
-		case s.getConversationStart <- struct{}{}:
-		default:
-		}
-	}
-	if s.getConversationWait != nil {
-		s.mu.Unlock()
-		<-s.getConversationWait
-		s.mu.Lock()
-	}
-	if s.conversationByID == nil {
-		return &clientpb.AIConversation{}, nil
-	}
-	conversation := s.conversationByID[req.GetID()]
-	if conversation == nil {
-		return &clientpb.AIConversation{}, nil
-	}
-	return proto.Clone(conversation).(*clientpb.AIConversation), nil
-}
-
-func (s *aiRPCServer) SaveAIConversation(_ context.Context, req *clientpb.AIConversation) (*clientpb.AIConversation, error) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.saveConversationReqs = append(s.saveConversationReqs, proto.Clone(req).(*clientpb.AIConversation))
-	if s.saveConversationResp == nil {
-		return proto.Clone(req).(*clientpb.AIConversation), nil
-	}
-	return proto.Clone(s.saveConversationResp).(*clientpb.AIConversation), nil
-}
-
-func (s *aiRPCServer) DeleteAIConversation(_ context.Context, req *clientpb.AIConversationReq) (*commonpb.Empty, error) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.deleteConversationReqs = append(s.deleteConversationReqs, proto.Clone(req).(*clientpb.AIConversationReq))
-	return &commonpb.Empty{}, nil
-}
-
-func (s *aiRPCServer) SaveAIConversationMessage(_ context.Context, req *clientpb.AIConversationMessage) (*clientpb.AIConversationMessage, error) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.saveMessageReqs = append(s.saveMessageReqs, proto.Clone(req).(*clientpb.AIConversationMessage))
-	if s.saveMessageStarted != nil {
-		select {
-		case s.saveMessageStarted <- struct{}{}:
-		default:
-		}
-	}
-	if s.saveMessageRelease != nil {
-		s.mu.Unlock()
-		<-s.saveMessageRelease
-		s.mu.Lock()
-	}
-	if s.saveMessageResp == nil {
-		return proto.Clone(req).(*clientpb.AIConversationMessage), nil
-	}
-	return proto.Clone(s.saveMessageResp).(*clientpb.AIConversationMessage), nil
-}
-
-func newAITestRPCClient(t *testing.T, srv rpcpb.SliverRPCServer) (rpcpb.SliverRPCClient, func()) {
-	t.Helper()
-
-	listener := bufconn.Listen(1024 * 1024)
-	grpcServer := grpc.NewServer()
-	rpcpb.RegisterSliverRPCServer(grpcServer, srv)
-
-	go func() {
-		_ = grpcServer.Serve(listener)
-	}()
-
-	dialer := func(context.Context, string) (net.Conn, error) { return listener.Dial() }
-	conn, err := grpc.DialContext(context.Background(), "bufnet",
-		grpc.WithContextDialer(dialer),
-		grpc.WithTransportCredentials(insecure.NewCredentials()),
-	)
-	if err != nil {
-		grpcServer.Stop()
-		_ = listener.Close()
-		t.Fatalf("dial bufconn: %v", err)
-	}
-
-	cleanup := func() {
-		_ = conn.Close()
-		grpcServer.Stop()
-		_ = listener.Close()
-	}
-
-	return rpcpb.NewSliverRPCClient(conn), cleanup
-}

client/command/aka/README.md

@@ -1,23 +0,0 @@
-# client/command/aka
-
-## Overview
-
-Implements the 'aka' command group for the Sliver client console. "Aka"s are
-command aliases (like 'alias' in 'bash') that allow operators to specify
-shorthand commands and default arguments for commonly used commands.
-
-### Examples:
-
-- `aka create bg background`: Allows an operator to run `bg` from the implant 
-menu to quickly move back to the server menu
-- `aka create execw execute -o "C:\Windows\System32\cmd.exe" /c`: Shorthand for
-  executing binaries on Windows targets like: `execw arp -a`
-
-## Go Files
-
-- `commands.go` – Wires Cobra commands for listing, creating, and deleting command aliases in the client console.
-- `create.go` – Handles creating command aliases to use by the client.
-- `delete.go` – Removes command aliases currently tracked by the client. 
-- `hook.go` – The main hooking logic to intercept commands ran by the client console. The hook will intercept processing before hitting the Cobra tree to transform the command alias to a full command with default arguments from the command alias and user-provided arguments to the alias.
-- `list.go` - Lists the current command aliases tracked by the client.
-- `storage.go` - Supports the saving of aliases to disk to keep between runs of the client. 

client/command/aka/commands.go

@@ -1,59 +0,0 @@
-package aka
-
-import (
-	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/client/constants"
-	"github.com/spf13/cobra"
-)
-
-func ServerCommands(con *console.SliverClient) []*cobra.Command {
-	return commands(con, constants.GenericHelpGroup)
-}
-
-func ImplantCommands(con *console.SliverClient) []*cobra.Command {
-	return commands(con, constants.SliverCoreHelpGroup)
-}
-
-func commands(con *console.SliverClient, group string) []*cobra.Command {
-	akaCommand := &cobra.Command{
-		Use:   "aka",
-		Short: "Manage command aliases (aka's)",
-		Run: func(cmd *cobra.Command, args []string) {
-			AkaListCmd(cmd, con, args)
-		},
-		GroupID: group,
-	}
-
-	createAka := &cobra.Command{
-		Use:                   "create <alias> <command> [args...]",
-		Short:                 "Create a new command alias (aka)",
-		Args:                  cobra.MinimumNArgs(2),
-		DisableFlagParsing:    true, // No flags with aka create so we capture flags to other commands
-		DisableFlagsInUseLine: true,
-		Run: func(cmd *cobra.Command, args []string) {
-			AkaCreateCmd(cmd, con, args)
-		},
-	}
-	createAka.InitDefaultHelpFlag()
-	createAka.Flags().Lookup("help").Hidden = true
-	akaCommand.AddCommand(createAka)
-
-	deleteAka := &cobra.Command{
-		Use:   "delete <alias>",
-		Short: "Delete a command alias (aka)",
-		Args:  cobra.MinimumNArgs(1),
-		Run: func(cmd *cobra.Command, args []string) {
-			AkaDeleteCmd(cmd, con, args)
-		},
-	}
-	akaCommand.AddCommand(deleteAka)
-
-	con.App.PreCmdRunLineHooks = append(con.App.PreCmdRunLineHooks, Cmdhook)
-
-	err := LoadAkaAliases()
-	if err != nil {
-		con.PrintErrorf("Failed to load aka alises: %s\n", err)
-	}
-
-	return []*cobra.Command{akaCommand}
-}

client/command/aka/create.go

@@ -1,46 +0,0 @@
-package aka
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/bishopfox/sliver/client/console"
-	"github.com/spf13/cobra"
-)
-
-func AkaCreateCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
-	aliasName := args[0]
-	command := args[1]
-	defaultArgs := args[2:] // anything else is going to be the default args to the alias
-
-	if _, exists := akaAliases[aliasName]; exists {
-		con.PrintErrorf("Alias '%s' already exists\n", aliasName)
-		return
-	}
-
-	var desc string
-	if len(defaultArgs) == 0 {
-		desc = fmt.Sprintf("%s", command)
-	} else {
-		desc = fmt.Sprintf("%s %s", command, strings.Join(defaultArgs, " "))
-	}
-
-	alias := &AkaAlias{
-		Name:        aliasName,
-		Command:     command,
-		DefaultArgs: defaultArgs,
-		Description: desc,
-	}
-
-	akaAliases[aliasName] = alias
-
-	// save this new alias to disk
-	err := SaveAkaAliases()
-	if err != nil {
-		con.PrintErrorf("Failed to save alias '%s' to disk: %s\n", aliasName, err)
-		// we still technically added it to the map, so the alias did get created in
-		// memory so we should still print the Info message below
-	}
-
-	con.PrintInfof("Create alias for '%s' -> '%v'\n", aliasName, alias.Description)
-}

client/command/aka/delete.go

@@ -1,25 +0,0 @@
-package aka
-
-import (
-	"github.com/bishopfox/sliver/client/console"
-	"github.com/spf13/cobra"
-)
-
-func AkaDeleteCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
-	aliasName := args[0]
-	if _, exists := akaAliases[aliasName]; !exists {
-		con.PrintErrorf("Alias '%s' does not exist\n", aliasName)
-		return
-	}
-
-	delete(akaAliases, aliasName)
-
-	// Save updated map to disk
-	err := SaveAkaAliases()
-	if err != nil {
-		con.PrintErrorf("Failed to save aliases to disk: %s\n", err)
-		return
-	}
-
-	con.PrintInfof("Deleted alias '%s'\n", aliasName)
-}

client/command/aka/hook.go

@@ -1,27 +0,0 @@
-package aka
-
-import (
-	"strings"
-)
-
-func Cmdhook(args []string) ([]string, error) {
-	if len(args) == 0 {
-		return args, nil
-	}
-
-	if aliasArgs, exists := akaAliases[args[0]]; exists {
-		var expandedArgs []string
-
-		expandedArgs = append(expandedArgs, aliasArgs.Command)
-		expandedArgs = append(expandedArgs, aliasArgs.DefaultArgs...)
-		// join the user passed args so the shell processes it without flags if
-		// available
-		if len(args[1:]) > 0 {
-			expandedArgs = append(expandedArgs, strings.Join(args[1:], " "))
-		}
-
-		return expandedArgs, nil
-	}
-
-	return args, nil
-}

client/command/aka/list.go

@@ -1,31 +0,0 @@
-package aka
-
-import (
-	"github.com/bishopfox/sliver/client/command/settings"
-	"github.com/bishopfox/sliver/client/console"
-	"github.com/jedib0t/go-pretty/v6/table"
-	"github.com/spf13/cobra"
-)
-
-func AkaListCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
-	if len(akaAliases) == 0 {
-		con.PrintInfof("No command aliases created. Use `aka create` to create one.\n")
-		return
-	}
-
-	tw := table.NewWriter()
-	tw.SetStyle(settings.GetTableStyle(con))
-	tw.AppendHeader(table.Row{
-		"Alias",
-		"Command",
-	})
-
-	for alias, cmd := range akaAliases {
-		tw.AppendRow(table.Row{
-			alias,
-			cmd.Description,
-		})
-	}
-
-	con.Printf("%s\n", tw.Render())
-}

client/command/aka/storage.go

@@ -1,68 +0,0 @@
-package aka
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-
-	"github.com/bishopfox/sliver/client/assets"
-)
-
-type AkaAlias struct {
-	Name        string   `json:"name"`         // alias Name
-	Command     string   `json:"command"`      // command being aliased
-	DefaultArgs []string `json:"default_args"` // args passed by the user
-	Description string   `json:"description"`
-}
-
-var akaAliases = make(map[string]*AkaAlias)
-
-const (
-	akaAliasFileName = "aka-aliases.json"
-)
-
-func GetAkaAliasesFilePath() string {
-	return filepath.Join(assets.GetRootAppDir(), akaAliasFileName)
-}
-
-func LoadAkaAliases() error {
-	filepath := GetAkaAliasesFilePath()
-	data, err := os.ReadFile(filepath)
-	if err != nil {
-		// if file hasn't been created yet, we fail gracefully
-		if os.IsNotExist(err) {
-			return nil
-		}
-		// otherwise, return the actual error; something else went wrong
-		return err
-	}
-
-	aliases := []AkaAlias{}
-	err = json.Unmarshal(data, &aliases)
-	if err != nil {
-		return err
-	}
-
-	akaAliases = make(map[string]*AkaAlias)
-
-	for _, alias := range aliases {
-		akaAliases[alias.Name] = &alias
-	}
-
-	return nil
-}
-
-func SaveAkaAliases() error {
-	filepath := GetAkaAliasesFilePath()
-	aliases := make([]*AkaAlias, 0, len(akaAliases))
-	for _, alias := range akaAliases {
-		aliases = append(aliases, alias)
-	}
-
-	data, err := json.MarshalIndent(aliases, "", "  ")
-	if err != nil {
-		return err
-	}
-
-	return os.WriteFile(filepath, data, 0o600)
-}

client/command/alias/README.md

@@ -1,14 +1,11 @@
-# client/command/alias
+Alias
+===========
 
-## Overview
+Wraps external DLLs/tool in Sliver console commands.
 
-Implements the 'alias' command group for the Sliver client console. Handlers map Cobra invocations to alias workflows such as install, load, and remove.
 
-## Go Files
 
-- `alias.go` – Implements runtime alias management, printing installed aliases and exposing tab-completion helpers.
-- `alias_test.go` *(tests)* – Exercises manifest parsing logic to ensure alias metadata is interpreted correctly.
-- `commands.go` – Wires Cobra commands for listing, installing, loading, and removing aliases into the client console.
-- `install.go` – Handles installing alias bundles from directories or archives, writing manifests and payload artifacts to disk.
-- `load.go` – Loads alias manifests, validates target compatibility, and registers commands against the active console.
-- `remove.go` – Removes installed aliases, prompting for confirmation and deleting associated on-disk assets.
+### Format
+
+* `alias-dir/`
+* * `manifest.json` - 

client/command/alias/args.go

@@ -1,251 +0,0 @@
-package alias
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2021  Bishop Fox
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/spf13/cobra"
-)
-
-// Alias commands run with cobra's DisableFlagParsing enabled (see LoadAlias),
-// the same treatment extension commands received for their arguments. Before
-// that, an unknown flag such as the payload's own `-pid` was rejected outright
-// by pflag ("unknown flag"), and operators had to inject cobra's "--"
-// separator (documented on the wiki) to pass arguments through at all (#2264).
-//
-// With flag parsing disabled cobra hands Run the raw, unstripped slice, and we
-// extract the Sliver-owned flags ourselves here. Everything we do not own is
-// passed to the payload untouched, so all of these now work:
-//
-//	amsi-bypass -pid 6969
-//	fakealias --process notepad.exe arg1 arg2
-//	fakealias -- --anything still-here     (existing workaround, unchanged)
-type ownedFlagKind int
-
-const (
-	ownedBool ownedFlagKind = iota
-	ownedString
-	ownedUint32
-	ownedInt64
-)
-
-// ownedFlagSpec describes one Sliver-owned flag that splitAliasArgs extracts
-// from the raw argument slice before the rest is handed to the alias payload.
-type ownedFlagSpec struct {
-	long  string        // canonical pflag name, e.g. "process-arguments"
-	short string        // shorthand letter, e.g. "A" ("" if the flag has none)
-	kind  ownedFlagKind // how the value is consumed and validated
-}
-
-// baseAliasOwnedFlags are registered for every alias command.
-var baseAliasOwnedFlags = []ownedFlagSpec{
-	{long: "process", short: "p", kind: ownedString},
-	{long: "process-arguments", short: "A", kind: ownedString},
-	{long: "ppid", short: "P", kind: ownedUint32},
-	{long: "save", short: "s", kind: ownedBool},
-	{long: "timeout", short: "t", kind: ownedInt64},
-}
-
-// assemblyAliasOwnedFlags are only owned when the alias wraps a .NET assembly;
-// for every other alias they are unknown tokens and pass through to the payload.
-var assemblyAliasOwnedFlags = []ownedFlagSpec{
-	{long: "method", short: "m", kind: ownedString},
-	{long: "class", short: "c", kind: ownedString},
-	{long: "app-domain", short: "d", kind: ownedString},
-	{long: "arch", short: "a", kind: ownedString},
-	{long: "in-process", short: "i", kind: ownedBool},
-	{long: "runtime", short: "r", kind: ownedString},
-	{long: "amsi-bypass", short: "M", kind: ownedBool},
-	{long: "etw-bypass", short: "E", kind: ownedBool},
-}
-
-// aliasOwnedFlagSpecs returns the flag set owned by a particular alias.
-func aliasOwnedFlagSpecs(isAssembly bool) []ownedFlagSpec {
-	if !isAssembly {
-		return baseAliasOwnedFlags
-	}
-	specs := make([]ownedFlagSpec, 0, len(baseAliasOwnedFlags)+len(assemblyAliasOwnedFlags))
-	specs = append(specs, baseAliasOwnedFlags...)
-	return append(specs, assemblyAliasOwnedFlags...)
-}
-
-// ownedFlagMatch is a raw token that spelled one of the Sliver-owned flags.
-type ownedFlagMatch struct {
-	spec   ownedFlagSpec
-	value  string // value from a "--flag=value" / "-f=value" spelling
-	inline bool   // whether the token carried its value inline
-}
-
-// splitAliasArgs separates the Sliver-owned flags from the alias payload's own
-// arguments in a raw (DisableFlagParsing) argument slice. It accepts the long
-// forms --flag, --flag=value, --flag value and the shorthand forms -f, -f=value,
-// -f value, mirroring pflag. Two deliberate differences from pflag:
-//
-//   - a glued shorthand value (-pnotepad) does NOT match --process: tokens
-//     like the payload's own "-pid" must survive intact (#2264);
-//   - after a literal "--" every token is copied through verbatim, preserving
-//     the long-standing separator workaround.
-//
-// The returned map holds the raw string value of each flag that was provided;
-// callers re-publish the values with applyOwnedAliasFlags.
-func splitAliasArgs(raw []string, specs []ownedFlagSpec) (map[string]string, bool, []string, error) {
-	values := make(map[string]string)
-	extArgs := make([]string, 0, len(raw))
-	byLong, byShort := ownedFlagTables(specs)
-
-	passthrough := false
-	for i := 0; i < len(raw); i++ {
-		tok := raw[i]
-
-		// Once we have seen "--", copy everything through untouched.
-		if passthrough {
-			extArgs = append(extArgs, tok)
-			continue
-		}
-		if tok == "--" {
-			passthrough = true
-			continue
-		}
-		if tok == "--help" || tok == "-h" {
-			return values, true, extArgs, nil
-		}
-
-		match, ok := matchOwnedFlag(tok, byLong, byShort)
-		if !ok {
-			// Not one of ours (including glued shorthands and the payload's
-			// own flags): the alias owns the token, pass it through untouched.
-			extArgs = append(extArgs, tok)
-			continue
-		}
-		i = takeOwnedValue(match, raw, i, values)
-	}
-
-	if err := validateOwnedValues(specs, values); err != nil {
-		return nil, false, nil, err
-	}
-	return values, false, extArgs, nil
-}
-
-// ownedFlagTables indexes the specs by long name and shorthand.
-func ownedFlagTables(specs []ownedFlagSpec) (byLong, byShort map[string]ownedFlagSpec) {
-	byLong = make(map[string]ownedFlagSpec, len(specs))
-	byShort = make(map[string]ownedFlagSpec, len(specs))
-	for _, spec := range specs {
-		byLong[spec.long] = spec
-		if spec.short != "" {
-			byShort[spec.short] = spec
-		}
-	}
-	return byLong, byShort
-}
-
-// matchOwnedFlag checks whether tok spells one of the Sliver-owned flags, in
-// the long form (--name, --name=value) or shorthand form (-f, -f=value). A
-// glued shorthand value (-pnotepad) deliberately does not match: pflag would
-// read "-pid" as -p with value "id", which is exactly the mangling that broke
-// #2264, so such tokens must fall through to the payload.
-func matchOwnedFlag(tok string, byLong, byShort map[string]ownedFlagSpec) (ownedFlagMatch, bool) {
-	var match ownedFlagMatch
-	var name, value string
-	var hasValue, isShort bool
-
-	switch {
-	case strings.HasPrefix(tok, "--"):
-		name, value, hasValue = strings.Cut(tok[2:], "=")
-	case strings.HasPrefix(tok, "-") && len(tok) > 1:
-		name, value, hasValue = strings.Cut(tok[1:], "=")
-		isShort = len(name) == 1
-	default:
-		return match, false
-	}
-
-	spec, ok := byLong[name]
-	if isShort {
-		spec, ok = byShort[name]
-	}
-	if !ok {
-		return match, false
-	}
-	match.spec, match.value, match.inline = spec, value, hasValue
-	return match, true
-}
-
-// takeOwnedValue records the flag's value in values and returns the index of
-// the last raw token it consumed. The "--flag value" / "-f value" spellings
-// consume the following token; a bool without an inline value defaults to
-// true; a value flag as the very last token is dropped and keeps its default,
-// mirroring the extension behaviour.
-func takeOwnedValue(match ownedFlagMatch, raw []string, i int, values map[string]string) int {
-	switch {
-	case match.spec.kind == ownedBool:
-		if !match.inline {
-			match.value = "true"
-		}
-		values[match.spec.long] = match.value
-	case match.inline:
-		values[match.spec.long] = match.value
-	case i+1 < len(raw):
-		values[match.spec.long] = raw[i+1]
-		return i + 1
-	}
-	return i
-}
-
-// validateOwnedValues rejects non-numeric values for the numeric flag kinds,
-// the way pflag's typed values would have.
-func validateOwnedValues(specs []ownedFlagSpec, values map[string]string) error {
-	for _, spec := range specs {
-		value, provided := values[spec.long]
-		if !provided {
-			continue
-		}
-		var err error
-		switch spec.kind {
-		case ownedUint32:
-			_, err = strconv.ParseUint(value, 10, 32)
-		case ownedInt64:
-			_, err = strconv.ParseInt(value, 10, 64)
-		}
-		if err != nil {
-			return fmt.Errorf("invalid value %q for --%s", value, spec.long)
-		}
-	}
-	return nil
-}
-
-// applyOwnedAliasFlags republishes the manually parsed Sliver-owned flag values
-// onto the command's flag set. DisableFlagParsing prevents pflag from
-// populating them, so readers such as runAliasCommand's Get* calls and
-// ActiveTarget.Request (which derives the gRPC timeout from --timeout) would
-// otherwise observe only the defaults.
-func applyOwnedAliasFlags(cmd *cobra.Command, values map[string]string) error {
-	for name, value := range values {
-		flag := cmd.Flags().Lookup(name)
-		if flag == nil {
-			continue // e.g. an assembly flag on a non-assembly alias
-		}
-		if err := flag.Value.Set(value); err != nil {
-			return fmt.Errorf("invalid value %q for --%s: %w", value, name, err)
-		}
-	}
-	return nil
-}

client/command/alias/args_test.go

@@ -1,259 +0,0 @@
-package alias
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2021  Bishop Fox
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-)
-
-// TestSplitAliasArgs covers the argument passthrough regression from #2264:
-// the alias payload's own flags must reach the payload intact, while the
-// Sliver-owned flags are extracted and validated.
-func TestSplitAliasArgs(t *testing.T) {
-	base := aliasOwnedFlagSpecs(false)
-	assembly := aliasOwnedFlagSpecs(true)
-
-	cases := []struct {
-		name    string
-		specs   []ownedFlagSpec
-		in      []string
-		values  map[string]string
-		help    bool
-		extArgs []string
-		wantErr bool
-	}{
-		{
-			name:    "payload flag without -- separator (#2264 regression)",
-			specs:   base,
-			in:      []string{"-pid", "6969"},
-			values:  map[string]string{},
-			extArgs: []string{"-pid", "6969"},
-		},
-		{
-			name:    "glued shorthand is not ours and passes through",
-			specs:   base,
-			in:      []string{"-pid"},
-			values:  map[string]string{},
-			extArgs: []string{"-pid"},
-		},
-		{
-			name:    "payload flag with -- separator (existing workaround)",
-			specs:   base,
-			in:      []string{"--", "--pid", "6969"},
-			values:  map[string]string{},
-			extArgs: []string{"--pid", "6969"},
-		},
-		{
-			name:    "owned flag after -- belongs to the payload",
-			specs:   base,
-			in:      []string{"--", "--save"},
-			values:  map[string]string{},
-			extArgs: []string{"--save"},
-		},
-		{
-			name:    "long flag with separate value, then payload args",
-			specs:   base,
-			in:      []string{"--process", "notepad.exe", "arg1", "arg2"},
-			values:  map[string]string{"process": "notepad.exe"},
-			extArgs: []string{"arg1", "arg2"},
-		},
-		{
-			name:    "long flag with equals value",
-			specs:   base,
-			in:      []string{"--process=notepad.exe", "arg1"},
-			values:  map[string]string{"process": "notepad.exe"},
-			extArgs: []string{"arg1"},
-		},
-		{
-			name:    "shorthand with separate value",
-			specs:   base,
-			in:      []string{"-p", "notepad.exe", "arg1"},
-			values:  map[string]string{"process": "notepad.exe"},
-			extArgs: []string{"arg1"},
-		},
-		{
-			name:    "shorthand with equals value",
-			specs:   base,
-			in:      []string{"-p=notepad.exe"},
-			values:  map[string]string{"process": "notepad.exe"},
-			extArgs: []string{},
-		},
-		{
-			name:    "bool shorthand and long false form",
-			specs:   base,
-			in:      []string{"-s", "--save=false", "arg1"},
-			values:  map[string]string{"save": "false"},
-			extArgs: []string{"arg1"},
-		},
-		{
-			name:    "quoted value containing spaces stays a single argument",
-			specs:   base,
-			in:      []string{"-A", "-kalc -kdisable", "arg1"},
-			values:  map[string]string{"process-arguments": "-kalc -kdisable"},
-			extArgs: []string{"arg1"},
-		},
-		{
-			name:    "valid uint32 and int64 values",
-			specs:   base,
-			in:      []string{"-P", "1234", "--timeout=90"},
-			values:  map[string]string{"ppid": "1234", "timeout": "90"},
-			extArgs: []string{},
-		},
-		{
-			name:    "invalid uint32 value errors",
-			specs:   base,
-			in:      []string{"--ppid", "notanumber"},
-			wantErr: true,
-		},
-		{
-			name:    "invalid int64 value errors",
-			specs:   base,
-			in:      []string{"--timeout=x"},
-			wantErr: true,
-		},
-		{
-			name:  "assembly flags are owned for assembly aliases",
-			specs: assembly,
-			in:    []string{"--method", "Run", "--class", "Prog", "-i", "-M", "--arch", "x64", "payloadArg"},
-			values: map[string]string{
-				"method": "Run", "class": "Prog", "in-process": "true",
-				"amsi-bypass": "true", "arch": "x64",
-			},
-			extArgs: []string{"payloadArg"},
-		},
-		{
-			name:    "assembly flags pass through for non-assembly aliases",
-			specs:   base,
-			in:      []string{"--method", "Run"},
-			values:  map[string]string{},
-			extArgs: []string{"--method", "Run"},
-		},
-		{
-			name:    "help flags are detected",
-			specs:   base,
-			in:      []string{"--help"},
-			help:    true,
-			values:  map[string]string{},
-			extArgs: []string{},
-		},
-		{
-			name:    "short help is detected",
-			specs:   base,
-			in:      []string{"-h"},
-			help:    true,
-			values:  map[string]string{},
-			extArgs: []string{},
-		},
-		{
-			name:    "value flag as last token keeps its default",
-			specs:   base,
-			in:      []string{"arg1", "--process"},
-			values:  map[string]string{},
-			extArgs: []string{"arg1"},
-		},
-		{
-			name:    "empty input",
-			specs:   base,
-			in:      nil,
-			values:  map[string]string{},
-			extArgs: []string{},
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			values, help, extArgs, err := splitAliasArgs(tc.in, tc.specs)
-
-			if tc.wantErr {
-				if err == nil {
-					t.Fatalf("expected error, got values=%#v help=%v extArgs=%#v", values, help, extArgs)
-				}
-				return
-			}
-			if err != nil {
-				t.Fatalf("unexpected error: %s", err)
-			}
-			if help != tc.help {
-				t.Errorf("help: got %v, want %v", help, tc.help)
-			}
-			if !reflect.DeepEqual(values, tc.values) {
-				t.Errorf("values: got %#v, want %#v", values, tc.values)
-			}
-			if !reflect.DeepEqual(extArgs, tc.extArgs) {
-				t.Errorf("extArgs: got %#v, want %#v", extArgs, tc.extArgs)
-			}
-		})
-	}
-}
-
-// TestApplyOwnedAliasFlags checks that manually parsed values are re-published
-// on the command's flag set for every value type an alias can own.
-func TestApplyOwnedAliasFlags(t *testing.T) {
-	cmd := &cobra.Command{}
-	f := pflag.NewFlagSet("alias-test", pflag.ContinueOnError)
-	f.StringP("process", "p", "", "host process")
-	f.StringP("process-arguments", "A", "", "host process arguments")
-	f.Uint32P("ppid", "P", 0, "parent pid")
-	f.BoolP("save", "s", false, "save output")
-	f.Int64P("timeout", "t", 60, "timeout")
-	f.BoolP("amsi-bypass", "M", false, "amsi bypass")
-	cmd.Flags().AddFlagSet(f)
-
-	err := applyOwnedAliasFlags(cmd, map[string]string{
-		"process":           "notepad.exe",
-		"process-arguments": "-k foo",
-		"ppid":              "1234",
-		"save":              "true",
-		"timeout":           "90",
-		"amsi-bypass":       "true",
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %s", err)
-	}
-
-	for name, want := range map[string]interface{}{
-		"process": "notepad.exe", "process-arguments": "-k foo",
-	} {
-		got, _ := cmd.Flags().GetString(name)
-		if got != want.(string) {
-			t.Errorf("%s: got %q, want %q", name, got, want)
-		}
-	}
-	if ppid, _ := cmd.Flags().GetUint32("ppid"); ppid != 1234 {
-		t.Errorf("ppid: got %d, want 1234", ppid)
-	}
-	if save, _ := cmd.Flags().GetBool("save"); !save {
-		t.Error("save: got false, want true")
-	}
-	if timeout, _ := cmd.Flags().GetInt64("timeout"); timeout != 90 {
-		t.Errorf("timeout: got %d, want 90", timeout)
-	}
-	if amsi, _ := cmd.Flags().GetBool("amsi-bypass"); !amsi {
-		t.Error("amsi-bypass: got false, want true")
-	}
-
-	// Unset flags keep their defaults.
-	if inProc := cmd.Flags().Lookup("in-process"); inProc != nil {
-		t.Error("in-process should not be registered on this command")
-	}
-}

client/command/alias/commands.go

@@ -1,7 +1,6 @@
 package alias
 
 import (
-	"github.com/bishopfox/sliver/client/command/completers"
 	"github.com/bishopfox/sliver/client/command/flags"
 	"github.com/bishopfox/sliver/client/command/help"
 	"github.com/bishopfox/sliver/client/console"
@@ -33,7 +32,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 	}
 	aliasCmd.AddCommand(aliasLoadCmd)
 	flags.NewCompletions(aliasLoadCmd).PositionalCompletion(carapace.ActionDirectories().Tag("alias directory").Usage("path to the alias directory"))
-	completers.RegisterLocalFilePathPositionalCompletion(aliasLoadCmd, 0)
 
 	aliasInstallCmd := &cobra.Command{
 		Use:   consts.InstallStr + " [ALIAS]",
@@ -46,7 +44,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 	}
 	aliasCmd.AddCommand(aliasInstallCmd)
 	flags.NewCompletions(aliasInstallCmd).PositionalCompletion(carapace.ActionFiles().Tag("alias file"))
-	completers.RegisterLocalFilePathPositionalCompletion(aliasInstallCmd, 0)
 
 	aliasRemove := &cobra.Command{
 		Use:   consts.RmStr + " [ALIAS]",

client/command/alias/install.go

@@ -24,9 +24,9 @@ import (
 	"path/filepath"
 	"strings"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/util"
 	"github.com/spf13/cobra"
 )
@@ -62,7 +62,8 @@ func installFromDir(aliasLocalPath string, con *console.SliverClient) {
 	if _, err := os.Stat(installPath); !os.IsNotExist(err) {
 		con.PrintInfof("Alias '%s' already exists", manifest.CommandName)
 		confirm := false
-		_ = forms.Confirm("Overwrite current install?", &confirm)
+		prompt := &survey.Confirm{Message: "Overwrite current install?"}
+		survey.AskOne(prompt, &confirm)
 		if !confirm {
 			return
 		}
@@ -113,7 +114,7 @@ func InstallFromFile(aliasGzFilePath string, aliasName string, promptToOverwrite
 		} else {
 			errorMsg = fmt.Sprintf("Failed to parse %s: %s\n", ManifestFileName, err)
 		}
-		con.PrintErrorf("%s", errorMsg)
+		con.PrintErrorf(errorMsg)
 		return nil
 	}
 	installPath := filepath.Join(assets.GetAliasesDir(), filepath.Base(manifest.CommandName))
@@ -121,7 +122,8 @@ func InstallFromFile(aliasGzFilePath string, aliasName string, promptToOverwrite
 		if promptToOverwrite {
 			con.PrintInfof("Alias '%s' already exists\n", manifest.CommandName)
 			confirm := false
-			_ = forms.Confirm("Overwrite current install?", &confirm)
+			prompt := &survey.Confirm{Message: "Overwrite current install?"}
+			survey.AskOne(prompt, &confirm)
 			if !confirm {
 				return nil
 			}

client/command/alias/load.go

@@ -27,16 +27,15 @@ import (
 	"path/filepath"
 	"strings"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/command/help"
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/client/packages"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/bishopfox/sliver/util"
-	"github.com/carapace-sh/carapace"
 	app "github.com/reeflective/console"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
@@ -77,16 +76,6 @@ type AliasFile struct {
 	Path string `json:"path"`
 }
 
-// AliasArgument - An argument for an alias command.
-type AliasArgument struct {
-	Name     string      `json:"name"`
-	Type     string      `json:"type"`
-	Desc     string      `json:"desc"`
-	Optional bool        `json:"optional"`
-	Default  interface{} `json:"default,omitempty"`
-	Choices  []string    `json:"choices,omitempty"`
-}
-
 // AliasManifest - The manifest for an alias, contains metadata.
 type AliasManifest struct {
 	Name           string `json:"name"`
@@ -100,7 +89,6 @@ type AliasManifest struct {
 	Entrypoint   string                 `json:"entrypoint"`
 	AllowArgs    bool                   `json:"allow_args"`
 	DefaultArgs  string                 `json:"default_args"`
-	Arguments    []*AliasArgument       `json:"arguments"`
 	Files        []*AliasFile           `json:"files"`
 	IsReflective bool                   `json:"is_reflective"`
 	IsAssembly   bool                   `json:"is_assembly"`
@@ -170,69 +158,21 @@ func LoadAlias(manifestPath string, cmd *cobra.Command, con *console.SliverClien
 	}
 	aliasManifest.RootPath = filepath.Dir(manifestPath)
 
-	// Build usage string including arguments
-	usage := strings.Builder{}
-	usage.WriteString(aliasManifest.CommandName)
-	for _, arg := range aliasManifest.Arguments {
-		usage.WriteString(" ")
-		if arg.Optional {
-			usage.WriteString("[")
-		}
-		usage.WriteString(strings.ToUpper(arg.Name))
-		if arg.Optional {
-			usage.WriteString("]")
-		}
-	}
-
-	// Build long help message
-	longHelp := strings.Builder{}
-	longHelp.WriteString("[[.Bold]]Command:[[.Normal]]")
-	longHelp.WriteString(usage.String())
-	longHelp.WriteString("\n")
-	if len(aliasManifest.Help) > 0 || len(aliasManifest.LongHelp) > 0 {
-		longHelp.WriteString("[[.Bold]]About:[[.Normal]]")
-		if len(aliasManifest.Help) > 0 {
-			longHelp.WriteString(aliasManifest.Help)
-			longHelp.WriteString("\n")
-		}
-		if len(aliasManifest.LongHelp) > 0 {
-			longHelp.WriteString(aliasManifest.LongHelp)
-			longHelp.WriteString("\n")
-		}
-	}
-	if len(aliasManifest.Arguments) > 0 {
-		longHelp.WriteString("[[.Bold]]Arguments:[[.Normal]]")
-		for _, arg := range aliasManifest.Arguments {
-			longHelp.WriteString("\n\t")
-			optStr := ""
-			if arg.Optional {
-				optStr = "[OPTIONAL]"
-			}
-			aType := arg.Type
-			if aType == "wstring" {
-				aType = "string"
-			}
-			longHelp.WriteString(fmt.Sprintf("%s (%s):\t%s%s", strings.ToUpper(arg.Name), aType, optStr, arg.Desc))
-		}
-	}
-
 	// for each alias command, add a new app command
 	helpMsg := fmt.Sprintf("[%s] %s", aliasManifest.Name, aliasManifest.Help)
+	longHelpMsg := help.FormatHelpTmpl(aliasManifest.LongHelp)
+	longHelpMsg += "\n\n⚠️  If you're having issues passing arguments to the alias please read:\n"
+	longHelpMsg += "https://github.com/BishopFox/sliver/wiki/Aliases-&-Extensions#aliases-command-parsing"
 	addAliasCmd := &cobra.Command{
-		Use:   usage.String(),
+		Use:   aliasManifest.CommandName,
 		Short: helpMsg,
-		Long:  help.FormatHelpTmpl(longHelp.String()),
+		Long:  longHelpMsg,
 		Run: func(cmd *cobra.Command, args []string) {
 			runAliasCommand(cmd, con, args)
 		},
-		Args: cobra.ArbitraryArgs, // 	a.StringList("arguments", "arguments", grumble.Default([]string{}))
-		// DisableFlagParsing keeps the alias payload's own flags (which are
-		// unknown to pflag) from being rejected or swallowed; we split the
-		// Sliver-owned flags out of the raw slice ourselves in
-		// runAliasCommand (#2264, same treatment as extensions).
-		DisableFlagParsing: true,
-		GroupID:            consts.AliasHelpGroup,
-		Annotations:        makeAliasPlatformFilters(aliasManifest),
+		Args:        cobra.ArbitraryArgs, // 	a.StringList("arguments", "arguments", grumble.Default([]string{}))
+		GroupID:     consts.AliasHelpGroup,
+		Annotations: makeAliasPlatformFilters(aliasManifest),
 	}
 
 	if aliasManifest.IsAssembly {
@@ -242,9 +182,9 @@ func LoadAlias(manifestPath string, cmd *cobra.Command, con *console.SliverClien
 		f.StringP("app-domain", "d", "", "AppDomain name to create for .NET assembly. Generated randomly if not set.")
 		f.StringP("arch", "a", "x84", "Assembly target architecture: x86, x64, x84 (x86+x64)")
 		f.BoolP("in-process", "i", false, "Run in the current sliver process")
-		f.StringP("runtime", "r", "v4.0.30319", "Runtime to use for running the assembly")
-		f.BoolP("amsi-bypass", "M", false, "Bypass AMSI on Windows")
-		f.BoolP("etw-bypass", "E", false, "Bypass ETW on Windows")
+		f.StringP("runtime", "r", "", "Runtime to use for running the assembly (only supported when used with --in-process)")
+		f.BoolP("amsi-bypass", "M", false, "Bypass AMSI on Windows (only supported when used with --in-process)")
+		f.BoolP("etw-bypass", "E", false, "Bypass ETW on Windows (only supported when used with --in-process)")
 		addAliasCmd.Flags().AddFlagSet(f)
 	}
 
@@ -253,13 +193,9 @@ func LoadAlias(manifestPath string, cmd *cobra.Command, con *console.SliverClien
 	f.StringP("process-arguments", "A", "", "arguments to pass to the hosting process")
 	f.Uint32P("ppid", "P", 0, "parent process ID to use when creating the hosting process (Windows only)")
 	f.BoolP("save", "s", false, "Save output to disk")
-	f.Int64P("timeout", "t", defaultTimeout, "command timeout in seconds")
+	f.IntP("timeout", "t", defaultTimeout, "command timeout in seconds")
 	addAliasCmd.Flags().AddFlagSet(f)
 
-	// Setup completions for alias arguments
-	comps := carapace.Gen(addAliasCmd)
-	makeAliasArgCompleter(aliasManifest, comps)
-
 	cmd.AddCommand(addAliasCmd)
 
 	// Have to use a global map here, as passing the aliasCmd
@@ -336,27 +272,6 @@ func runAliasCommand(cmd *cobra.Command, con *console.SliverClient, args []strin
 		return
 	}
 	aliasManifest := loadedAlias.Manifest
-
-	// The command runs with DisableFlagParsing, so args is the raw, unstripped
-	// slice. Separate the Sliver-owned flags from the payload's own arguments
-	// and re-publish them on the flag set (so the Get* readers below and
-	// Request()'s --timeout still work), then hand only the payload arguments
-	// to the execution paths (#2264, same treatment as extensions in #2323).
-	ownedValues, helpRequested, payloadArgs, err := splitAliasArgs(args, aliasOwnedFlagSpecs(aliasManifest.IsAssembly))
-	if err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-	if helpRequested {
-		_ = cmd.Help()
-		return
-	}
-	if err := applyOwnedAliasFlags(cmd, ownedValues); err != nil {
-		con.PrintErrorf("%s\n", err)
-		return
-	}
-	args = payloadArgs
-
 	binPath, err := aliasManifest.getFileForTarget(cmd.Name(), goos, goarch)
 	if err != nil {
 		con.PrintErrorf("Fail to find alias file: %s\n", err)
@@ -396,9 +311,10 @@ func runAliasCommand(cmd *cobra.Command, con *console.SliverClient, args []strin
 		} 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("%s", msgStr)
+		con.PrintWarnf(msgStr)
 		confirm := false
-		forms.Confirm("Do you want to continue?", &confirm)
+		prompt := &survey.Confirm{Message: "Do you want to continue?"}
+		survey.AskOne(prompt, &confirm, nil)
 		if !confirm {
 			return
 		}
@@ -424,13 +340,7 @@ func runAliasCommand(cmd *cobra.Command, con *console.SliverClient, args []strin
 
 	var outFilePath *os.File
 	if save, _ := cmd.Flags().GetBool("save"); save {
-		hostname := ""
-		if session != nil {
-			hostname = session.GetHostname()
-		} else if beacon != nil {
-			hostname = beacon.GetHostname()
-		}
-		outFile := filepath.Base(fmt.Sprintf("%s_%s*.log", filepath.Base(cmd.Name()), filepath.Base(hostname)))
+		outFile := filepath.Base(fmt.Sprintf("%s_%s*.log", filepath.Base(cmd.Name()), filepath.Base(session.GetHostname())))
 		outFilePath, err = os.CreateTemp("", outFile)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
@@ -680,105 +590,3 @@ func makeAliasPlatformFilters(alias *AliasManifest) map[string]string {
 		app.CommandFilterKey: strings.Join(all, ","),
 	}
 }
-
-// makeAliasArgCompleter builds the positional and dash arguments completer for the alias.
-// It provides completion for:
-// 1. Positional arguments (before --)
-// 2. Flag-style arguments after -- (e.g., --target, --port)
-func makeAliasArgCompleter(alias *AliasManifest, comps *carapace.Carapace) {
-	if len(alias.Arguments) == 0 {
-		return
-	}
-
-	var actions []carapace.Action
-
-	for _, arg := range alias.Arguments {
-		var action carapace.Action
-
-		// If choices are defined, use them for completion
-		if len(arg.Choices) > 0 {
-			action = carapace.ActionValues(arg.Choices...).Tag("choices")
-		} else {
-			// Fall back to type-based completion
-			switch arg.Type {
-			case "file":
-				action = carapace.ActionFiles().Tag("alias data")
-			default:
-				action = carapace.ActionValues()
-			}
-		}
-
-		usage := fmt.Sprintf("(%s) %s", arg.Type, arg.Desc)
-		if arg.Optional {
-			usage += " (optional)"
-		}
-
-		actions = append(actions, action.Usage("%s", usage))
-	}
-
-	comps.PositionalCompletion(actions...)
-
-	// Add dash completion for flag-style arguments after --
-	// Pre-build the flag completions at registration time (not in a callback)
-	flagCompletion := makeAliasFlagNameCompletion(alias)
-
-	// Build value completions for each argument type
-	valueCompletions := make(map[string]carapace.Action)
-	for _, arg := range alias.Arguments {
-		// If choices are defined, use them for completion
-		if len(arg.Choices) > 0 {
-			valueCompletions[arg.Name] = carapace.ActionValues(arg.Choices...).Tag("choices")
-		} else {
-			// Fall back to type-based completion
-			switch arg.Type {
-			case "file":
-				valueCompletions[arg.Name] = carapace.ActionFiles().Tag("file path")
-			case "bool":
-				valueCompletions[arg.Name] = carapace.ActionValues("true", "false").Tag("boolean")
-			default:
-				valueCompletions[arg.Name] = carapace.ActionValues()
-			}
-		}
-	}
-
-	// Use DashAnyCompletion with a smart action that determines context
-	comps.DashAnyCompletion(
-		carapace.ActionCallback(func(c carapace.Context) carapace.Action {
-			// If typing a flag (starts with -)
-			if strings.HasPrefix(c.Value, "-") {
-				return flagCompletion
-			}
-
-			// If previous arg was a flag, complete its value
-			if len(c.Args) > 0 {
-				lastArg := c.Args[len(c.Args)-1]
-				if strings.HasPrefix(lastArg, "-") {
-					flagName := strings.TrimLeft(lastArg, "-")
-					if action, ok := valueCompletions[flagName]; ok {
-						return action
-					}
-				}
-			}
-
-			// Default: show flag names
-			return flagCompletion
-		}),
-	)
-}
-
-// makeAliasFlagNameCompletion creates completion for flag names
-func makeAliasFlagNameCompletion(alias *AliasManifest) carapace.Action {
-	var results []string
-
-	for _, arg := range alias.Arguments {
-		flagName := fmt.Sprintf("--%s", arg.Name)
-		desc := arg.Desc
-		if arg.Optional {
-			desc = fmt.Sprintf("[optional] %s", desc)
-		}
-		desc = fmt.Sprintf("(%s) %s", arg.Type, desc)
-		results = append(results, flagName, desc)
-	}
-
-	return carapace.ActionValuesDescribed(results...).Tag("alias arguments")
-}

client/command/alias/remove.go

@@ -24,9 +24,9 @@ import (
 	"os"
 	"path/filepath"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/spf13/cobra"
 )
 
@@ -39,7 +39,8 @@ func AliasesRemoveCmd(cmd *cobra.Command, con *console.SliverClient, args []stri
 		return
 	}
 	confirm := false
-	_ = forms.Confirm(fmt.Sprintf("Remove '%s' alias?", name), &confirm)
+	prompt := &survey.Confirm{Message: fmt.Sprintf("Remove '%s' alias?", name)}
+	survey.AskOne(prompt, &confirm)
 	if !confirm {
 		return
 	}

client/command/armory/README.md

@@ -1,16 +0,0 @@
-# client/command/armory
-
-## Overview
-
-Implements the 'armory' command group for the Sliver client console. Handlers map Cobra invocations to armory workflows such as install, manage, parsers, and search.
-
-## Go Files
-
-- `armory.go` – Maintains the armory cache lifecycle, fetching package metadata, verifying signatures, and presenting bundle listings.
-- `armory_test.go` *(tests)* – Placeholder for armory command tests; currently used to keep the package's test harness wired up.
-- `commands.go` – Declares the Cobra command hierarchy for armory actions and binds shared flag/completion plumbing.
-- `install.go` – Resolves dependencies and installs aliases or extensions from cached metadata, prompting when overwriting existing packages.
-- `manage.go` – Implements management helpers for viewing, adding, verifying, and persisting armory configurations.
-- `parsers.go` – Provides parsers and HTTP helpers for retrieving armory indexes and packages, including Minisign verification.
-- `search.go` – Implements the regex-driven search command that filters cached armory packages.
-- `update.go` – Calculates available package updates, presents options to the user, and orchestrates update installation.

client/command/armory/armory.go

@@ -164,7 +164,7 @@ func ArmoryCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 			cacheEntry, ok := value.(pkgCacheEntry)
 			if !ok {
 				// Something is wrong with this entry
-				pkgCache.Delete(key)
+				pkgCache.Delete(value)
 				return true
 			}
 			if cacheEntry.ArmoryConfig.PublicKey != index.ArmoryConfig.PublicKey {
@@ -428,7 +428,7 @@ func PrintArmoryPackages(aliases []*alias.AliasManifest, exts []*extensions.Exte
 
 	tw := table.NewWriter()
 	tw.SetStyle(settings.GetTableStyle(con))
-	tw.SetTitle(console.StyleBold.Render("Packages"))
+	tw.SetTitle(console.Bold + "Packages" + console.Normal)
 
 	urlMargin := 150 // Extra margin needed to show URL column
 
@@ -493,26 +493,26 @@ func PrintArmoryPackages(aliases []*alias.AliasManifest, exts []*extensions.Exte
 
 	rows := []table.Row{}
 	for _, pkg := range entries {
-		style := console.StyleNormal
+		color := console.Normal
 		if extensions.CmdExists(pkg.CommandName, sliverMenu.Command) {
-			style = console.StyleGreen
+			color = console.Green
 		}
 		if con.Settings.SmallTermWidth+urlMargin < width {
 			rows = append(rows, table.Row{
-				style.Render(pkg.ArmoryName),
-				style.Render(pkg.CommandName),
-				style.Render(pkg.Version),
-				style.Render(pkg.Type),
-				style.Render(pkg.Help),
-				style.Render(pkg.URL),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.ArmoryName),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.CommandName),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.Version),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.Type),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.Help),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.URL),
 			})
 		} else {
 			rows = append(rows, table.Row{
-				style.Render(pkg.ArmoryName),
-				style.Render(pkg.CommandName),
-				style.Render(pkg.Version),
-				style.Render(pkg.Type),
-				style.Render(pkg.Help),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.ArmoryName),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.CommandName),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.Version),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.Type),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.Help),
 			})
 		}
 	}
@@ -524,7 +524,7 @@ func PrintArmoryPackages(aliases []*alias.AliasManifest, exts []*extensions.Exte
 func PrintArmoryBundles(bundles []*ArmoryBundle, con *console.SliverClient) {
 	tw := table.NewWriter()
 	tw.SetStyle(settings.GetTableStyle(con))
-	tw.SetTitle(console.StyleBold.Render("Bundles"))
+	tw.SetTitle(console.Bold + "Bundles" + console.Normal)
 	tw.AppendHeader(table.Row{
 		"Armory Name",
 		"Name",

client/command/armory/commands.go

@@ -1,23 +1,5 @@
 package armory
 
-/*
-	Sliver Implant Framework
-	Copyright (C) 2026  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 (
 	"github.com/rsteube/carapace"
 	"github.com/spf13/cobra"
@@ -55,7 +37,7 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		Use:   consts.InstallStr,
 		Short: "Install an alias or extension",
 		Long:  help.GetHelpFor([]string{consts.ArmoryStr, consts.InstallStr}),
-		Args:  cobra.RangeArgs(0, 1),
+		Args:  cobra.ExactArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
 			ArmoryInstallCmd(cmd, con, args)
 		},

client/command/armory/install.go

@@ -26,9 +26,8 @@ import (
 	"os"
 	"path/filepath"
 	"slices"
-	"sort"
-	"strings"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/spf13/cobra"
 
 	"github.com/bishopfox/sliver/client/assets"
@@ -36,7 +35,6 @@ import (
 	"github.com/bishopfox/sliver/client/command/extensions"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/constants"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/util"
 	"github.com/bishopfox/sliver/util/minisign"
 )
@@ -53,9 +51,10 @@ const (
 // ArmoryInstallCmd - The armory install command
 func ArmoryInstallCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	var promptToOverwrite bool
-	names := []string{}
-	if len(args) > 0 {
-		names = []string{args[0]}
+	name := args[0]
+	if name == "" {
+		con.PrintErrorf("A package or bundle name is required")
+		return
 	}
 	forceInstallation, err := cmd.Flags().GetBool("force")
 	if err != nil {
@@ -84,92 +83,51 @@ func ArmoryInstallCmd(cmd *cobra.Command, con *console.SliverClient, args []stri
 
 	clientConfig := parseArmoryHTTPConfig(cmd)
 	refresh(clientConfig)
-
-	if len(names) == 0 {
-		armoryFilterName := ""
-		if armoryPK != "" {
-			armoryFilterName = armoryName
+	if name == "all" {
+		aliases, extensions := packageManifestsInCache()
+		aliasCount, extCount := countUniqueCommandsFromManifests(aliases, extensions)
+		confirm := false
+		pluralAliases := "es"
+		if aliasCount == 1 {
+			pluralAliases = ""
 		}
-		options := armoryInstallOptions(armoryPK, armoryFilterName)
-		if len(options) == 0 {
-			con.PrintInfof("No packages or bundles found\n")
+		pluralExtensions := "s"
+		if extCount == 1 {
+			pluralExtensions = ""
+		}
+		prompt := &survey.Confirm{
+			Message: fmt.Sprintf("Install %d alias%s and %d extension%s?",
+				aliasCount, pluralAliases, extCount, pluralExtensions,
+			),
+		}
+		survey.AskOne(prompt, &confirm)
+		if !confirm {
 			return
 		}
-		result, err := forms.ArmoryInstallForm(options)
-		if err != nil {
-			if errors.Is(err, forms.ErrUserAborted) {
-				return
-			}
-			con.PrintErrorf("Armory install form failed: %s\n", err)
-			return
-		}
-		if len(result.SelectedNames) == 0 {
-			return
-		}
-		names = result.SelectedNames
+		promptToOverwrite = false
 	}
-	if len(names) == 0 {
-		con.PrintErrorf("A package or bundle name is required")
+	err = installPackageByName(name, armoryPK, forceInstallation, promptToOverwrite, clientConfig, con)
+	if err == nil {
 		return
 	}
-	if slices.Contains(names, "all") {
-		names = []string{"all"}
-	}
-
-	for _, name := range names {
-		if name == "" {
-			continue
-		}
-
-		promptOverwrite := promptToOverwrite
-		if name == "all" {
-			aliases, extensions := packageManifestsInCache()
-			aliasCount, extCount := countUniqueCommandsFromManifests(aliases, extensions)
-			confirm := false
-			pluralAliases := "es"
-			if aliasCount == 1 {
-				pluralAliases = ""
-			}
-			pluralExtensions := "s"
-			if extCount == 1 {
-				pluralExtensions = ""
-			}
-			forms.Confirm(fmt.Sprintf("Install %d alias%s and %d extension%s?",
-				aliasCount, pluralAliases, extCount, pluralExtensions,
-			), &confirm)
-			if !confirm {
+	if errors.Is(err, ErrPackageNotFound) {
+		bundles := bundlesInCache()
+		for _, bundle := range bundles {
+			if bundle.Name == name {
+				installBundle(bundle, armoryPK, forceInstallation, clientConfig, con)
 				return
 			}
-			promptOverwrite = false
 		}
-
-		err = installPackageByName(name, armoryPK, forceInstallation, promptOverwrite, clientConfig, con)
-		if err == nil {
-			continue
-		}
-		if errors.Is(err, ErrPackageNotFound) {
-			bundles := bundlesInCache()
-			for _, bundle := range bundles {
-				if bundle.Name == name {
-					installBundle(bundle, armoryPK, forceInstallation, clientConfig, con)
-					err = nil
-					break
-				}
-			}
-			if err == nil {
-				continue
-			}
-			// If we have made it here, then there was not a bundle or package that matched the provided name
-			if armoryPK == "" {
-				con.PrintErrorf("No package or bundle named %q was found\n", name)
-			} else {
-				con.PrintErrorf("No package or bundle named %q was found in armory %s\n", name, armoryName)
-			}
-		} else if errors.Is(err, ErrPackageAlreadyInstalled) {
-			con.PrintErrorf("Package %q is already installed - use the force option to overwrite it\n", name)
+		// If we have made it here, then there was not a bundle or package that matched the provided name
+		if armoryPK == "" {
+			con.PrintErrorf("No package or bundle named %q was found\n", name)
 		} else {
-			con.PrintErrorf("Could not install package: %s\n", err)
+			con.PrintErrorf("No package or bundle named %q was found in armory %s\n", name, armoryName)
 		}
+	} else if errors.Is(err, ErrPackageAlreadyInstalled) {
+		con.PrintErrorf("Package %q is already installed - use the force option to overwrite it\n", name)
+	} else {
+		con.PrintErrorf("Could not install package: %s\n", err)
 	}
 
 }
@@ -274,22 +232,19 @@ func getInstalledPackageNames() []string {
 }
 
 // This is a convenience function to get the names of the commands in the cache
-func getCommandsInCache(armoryPK string) []string {
+func getCommandsInCache() []string {
 	commandNames := []string{}
 
 	pkgCache.Range(func(key, value interface{}) bool {
 		cacheEntry := value.(pkgCacheEntry)
 		if cacheEntry.LastErr == nil {
-			if armoryPK != "" && cacheEntry.ArmoryConfig.PublicKey != armoryPK {
-				return true
-			}
 			if cacheEntry.Pkg.IsAlias {
-				if cacheEntry.Alias.CommandName != "" && !slices.Contains(commandNames, cacheEntry.Alias.CommandName) {
+				if !slices.Contains(commandNames, cacheEntry.Alias.CommandName) {
 					commandNames = append(commandNames, cacheEntry.Alias.CommandName)
 				}
 			} else {
 				for _, command := range cacheEntry.Extension.ExtCommand {
-					if command.CommandName != "" && !slices.Contains(commandNames, command.CommandName) {
+					if !slices.Contains(commandNames, command.CommandName) {
 						commandNames = append(commandNames, command.CommandName)
 					}
 				}
@@ -341,7 +296,11 @@ func getPackageIDFromUser(name string, options map[string]string) string {
 	// Add a cancel option
 	optionKeys = append(optionKeys, doNotInstallOption)
 	options[doNotInstallOption] = doNotInstallPackageName
-	forms.Select(fmt.Sprintf("More than one package contains the command %s. Please choose an option from the list below:", name), optionKeys, &selectedPackageKey)
+	prompt := &survey.Select{
+		Message: fmt.Sprintf("More than one package contains the command %s. Please choose an option from the list below:", name),
+		Options: optionKeys,
+	}
+	survey.AskOne(prompt, &selectedPackageKey)
 	selectedPackageID := options[selectedPackageKey]
 
 	return selectedPackageID
@@ -401,7 +360,7 @@ func buildInstallList(name, armoryPK string, forceInstallation bool, pendingPack
 	var requestedPackageList []string
 	if name == "all" {
 		requestedPackageList = []string{}
-		allCommands := getCommandsInCache(armoryPK)
+		allCommands := getCommandsInCache()
 		for _, cmdName := range allCommands {
 			if !slices.Contains(installedPackages, cmdName) || forceInstallation {
 				// Check to see if there is a package pending with that name
@@ -461,15 +420,6 @@ func installPackageByName(name, armoryPK string, forceInstallation, promptToOver
 	if err != nil {
 		return err
 	}
-	if len(packageInstallList) == 0 && name == "all" {
-		availableCommands := getCommandsInCache(armoryPK)
-		if len(availableCommands) == 0 {
-			con.PrintInfof("No packages or bundles found\n")
-		} else {
-			con.PrintInfof("All available packages are already installed\n")
-		}
-		return nil
-	}
 	if len(packageInstallList) > 0 {
 		for _, packageID := range packageInstallList {
 			entry := packageCacheLookupByID(packageID)
@@ -494,114 +444,12 @@ func installPackageByName(name, armoryPK string, forceInstallation, promptToOver
 
 	if name == "all" {
 		con.Printf("\n")
-		con.PrintSuccessf("Operation complete\n")
+		con.PrintInfof("Operation complete\n")
 	}
 
 	return nil
 }
 
-func armoryInstallOptions(armoryPK, armoryName string) []forms.ArmoryInstallOption {
-	options := []forms.ArmoryInstallOption{}
-	seen := make(map[string]bool)
-	packageCount := 0
-
-	pkgCache.Range(func(key, value interface{}) bool {
-		cacheEntry, ok := value.(pkgCacheEntry)
-		if !ok {
-			return true
-		}
-		if cacheEntry.LastErr != nil {
-			return true
-		}
-		if armoryPK != "" && cacheEntry.ArmoryConfig.PublicKey != armoryPK {
-			return true
-		}
-
-		if cacheEntry.Pkg.IsAlias {
-			name := cacheEntry.Alias.CommandName
-			if name == "" {
-				return true
-			}
-			if seen[name] {
-				return true
-			}
-			label := formatArmoryInstallLabel("alias", name, cacheEntry.Alias.Help)
-			options = append(options, forms.ArmoryInstallOption{
-				Value: name,
-				Label: label,
-			})
-			seen[name] = true
-			packageCount++
-			return true
-		}
-
-		for _, command := range cacheEntry.Extension.ExtCommand {
-			name := command.CommandName
-			if name == "" {
-				continue
-			}
-			if seen[name] {
-				continue
-			}
-			label := formatArmoryInstallLabel("extension", name, command.Help)
-			options = append(options, forms.ArmoryInstallOption{
-				Value: name,
-				Label: label,
-			})
-			seen[name] = true
-			packageCount++
-		}
-
-		return true
-	})
-
-	for _, bundle := range bundlesInCache() {
-		if bundle.Name == "" {
-			continue
-		}
-		if armoryName != "" && bundle.ArmoryName != armoryName {
-			continue
-		}
-		if seen[bundle.Name] {
-			continue
-		}
-		label := fmt.Sprintf("bundle: %s (%d packages)", bundle.Name, len(bundle.Packages))
-		options = append(options, forms.ArmoryInstallOption{
-			Value: bundle.Name,
-			Label: label,
-		})
-		seen[bundle.Name] = true
-	}
-
-	if len(options) == 0 {
-		return options
-	}
-
-	sort.Slice(options, func(i, j int) bool {
-		return options[i].Label < options[j].Label
-	})
-
-	if packageCount > 0 {
-		options = append([]forms.ArmoryInstallOption{
-			{
-				Value: "all",
-				Label: "all packages (aliases + extensions)",
-			},
-		}, options...)
-	}
-
-	return options
-}
-
-func formatArmoryInstallLabel(kind, name, help string) string {
-	help = strings.TrimSpace(help)
-	if help == "" {
-		return fmt.Sprintf("%s: %s", kind, name)
-	}
-	help = strings.Join(strings.Fields(help), " ")
-	return fmt.Sprintf("%s: %s - %s", kind, name, help)
-}
-
 func installAliasPackage(entry *pkgCacheEntry, promptToOverwrite bool, clientConfig ArmoryHTTPConfig, con *console.SliverClient) error {
 	if entry == nil {
 		return errors.New("package not found")
@@ -635,15 +483,20 @@ func installAliasPackage(entry *pkgCacheEntry, promptToOverwrite bool, clientCon
 		return errors.New("signature verification failed")
 	}
 
-	tmpFileName, err := writeArmoryTempFile(tarGz)
+	tmpFile, err := os.CreateTemp("", "sliver-armory-")
 	if err != nil {
 		return err
 	}
-	defer os.Remove(tmpFileName)
+	defer os.Remove(tmpFile.Name())
+	_, err = tmpFile.Write(tarGz)
+	if err != nil {
+		return err
+	}
+	tmpFile.Close()
 
 	con.Printf(console.Clearln + "\r") // Clear the line
 
-	installPath := alias.InstallFromFile(tmpFileName, entry.Alias.CommandName, promptToOverwrite, con)
+	installPath := alias.InstallFromFile(tmpFile.Name(), entry.Alias.CommandName, promptToOverwrite, con)
 	if installPath == nil {
 		return errors.New("failed to install alias")
 	}
@@ -724,45 +577,23 @@ func installExtensionPackage(entry *pkgCacheEntry, promptToOverwrite bool, clien
 		return errors.New("signature verification failed")
 	}
 
-	tmpFileName, err := writeArmoryTempFile(tarGz)
+	tmpFile, err := os.CreateTemp("", "sliver-armory-")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(tmpFile.Name())
+	_, err = tmpFile.Write(tarGz)
+	if err != nil {
+		return err
+	}
+	err = tmpFile.Sync()
 	if err != nil {
 		return err
 	}
-	defer os.Remove(tmpFileName)
 
 	con.Printf(console.Clearln + "\r") // Clear download message
 
-	extensions.InstallFromDir(tmpFileName, promptToOverwrite, con, true)
+	extensions.InstallFromDir(tmpFile.Name(), promptToOverwrite, con, true)
 
 	return nil
 }
-
-func writeArmoryTempFile(data []byte) (string, error) {
-	if len(data) == 0 {
-		return "", errors.New("downloaded archive is empty")
-	}
-	tmpFile, err := os.CreateTemp("", "sliver-armory-")
-	if err != nil {
-		return "", err
-	}
-	tmpFileName := tmpFile.Name()
-	for len(data) > 0 {
-		n, err := tmpFile.Write(data)
-		if err != nil {
-			tmpFile.Close()
-			os.Remove(tmpFileName)
-			return "", err
-		}
-		data = data[n:]
-	}
-	if err := tmpFile.Sync(); err != nil {
-		tmpFile.Close()
-		os.Remove(tmpFileName)
-		return "", err
-	}
-	if err := tmpFile.Close(); err != nil {
-		os.Remove(tmpFileName)
-		return "", err
-	}
-	return tmpFileName, nil
-}

client/command/armory/manage.go

@@ -1,23 +1,5 @@
 package armory
 
-/*
-	Sliver Implant Framework
-	Copyright (C) 2026  Bishop Fox
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
 import (
 	"fmt"
 	"os"
@@ -26,10 +8,10 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/assets"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/jedib0t/go-pretty/v6/table"
 	"github.com/spf13/cobra"
 )
@@ -620,7 +602,8 @@ func ModifyArmoryCmd(cmd *cobra.Command, con *console.SliverClient, args []strin
 	if err != nil {
 		con.PrintErrorf("could not modify armory: %s\n", err)
 		confirm := false
-		_ = forms.Confirm("Would you like to revert the properties of the armory back to their previous values?", &confirm)
+		prompt := &survey.Confirm{Message: "Would you like to revert the properties of the armory back to their previous values?"}
+		survey.AskOne(prompt, &confirm, nil)
 		if !confirm {
 			return
 		} else {

client/command/armory/update.go

@@ -19,11 +19,13 @@ package armory
 */
 
 import (
-	"errors"
 	"fmt"
 	"os"
 	"sort"
+	"strconv"
+	"strings"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/jedib0t/go-pretty/v6/table"
 	"github.com/spf13/cobra"
 
@@ -32,7 +34,6 @@ import (
 	"github.com/bishopfox/sliver/client/command/extensions"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/util"
 )
 
@@ -86,19 +87,16 @@ func ArmoryUpdateCmd(cmd *cobra.Command, con *console.SliverClient, args []strin
 	if len(aliasUpdates) > 0 || len(extUpdates) > 0 {
 		updateKeys := sortUpdateIdentifiers(aliasUpdates, extUpdates)
 		displayAvailableUpdates(con, updateKeys, aliasUpdates, extUpdates)
-		selectedUpdates, err = getUpdatesFromUser(updateKeys)
+		selectedUpdates, err = getUpdatesFromUser(con, updateKeys)
 		if err != nil {
-			if errors.Is(err, forms.ErrUserAborted) {
-				return
-			}
-			con.PrintErrorf("%s\n", err.Error())
+			con.PrintErrorf(err.Error() + "\n")
 			return
 		}
 		if len(selectedUpdates) == 0 {
 			return
 		}
 	} else {
-		con.PrintSuccessf("All packages are up to date\n")
+		con.PrintSuccessf("All packages are up to date")
 		return
 	}
 
@@ -257,7 +255,7 @@ func displayAvailableUpdates(con *console.SliverClient, updateKeys []UpdateIdent
 	if len(extensionUpdates) != 1 {
 		extensionSuffix = "s"
 	}
-	tw.SetTitle(console.StyleBold.Render(fmt.Sprintf(title, len(aliasUpdates), aliasSuffix, len(extensionUpdates), extensionSuffix)))
+	tw.SetTitle(console.Bold + fmt.Sprintf(title, len(aliasUpdates), aliasSuffix, len(extensionUpdates), extensionSuffix) + console.Normal)
 	tw.AppendHeader(table.Row{
 		"Package Name",
 		"Package Type",
@@ -301,35 +299,76 @@ func displayAvailableUpdates(con *console.SliverClient, updateKeys []UpdateIdent
 	con.Printf("%s\n\n", tw.Render())
 }
 
-func getUpdatesFromUser(updateKeys []UpdateIdentifier) ([]UpdateIdentifier, error) {
-	options := make([]forms.ArmoryUpdateOption, 0, len(updateKeys))
-	optionIndex := make(map[string]UpdateIdentifier, len(updateKeys))
+func getUpdatesFromUser(con *console.SliverClient, updateKeys []UpdateIdentifier) (chosenUpdates []UpdateIdentifier, selectionError error) {
+	chosenUpdates = []UpdateIdentifier{}
 
-	for _, key := range updateKeys {
-		packageType := "Alias"
-		if key.Type == ExtensionPackage {
-			packageType = "Extension"
-		}
-		optionID := fmt.Sprintf("%d:%s", key.Type, key.Name)
-		optionLabel := fmt.Sprintf("%s (%s)", key.Name, packageType)
-		options = append(options, forms.ArmoryUpdateOption{
-			ID:    optionID,
-			Label: optionLabel,
-		})
-		optionIndex[optionID] = key
-	}
+	var updateResponse string
 
-	result, err := forms.ArmoryUpdateForm(options)
+	con.Println("You can apply all, none, or some updates.\nTo apply some updates, specify the number of a single update, a range (1-3), or a combination of the two (1, 3-5, 7)\n")
+	err := survey.AskOne(&survey.Input{
+		Message: "Which updates would you like to apply? [A]ll, [N]one, or some:",
+	}, &updateResponse)
 	if err != nil {
-		return nil, err
+		// We do not need to set selectionError because an error here means the same thing as responding with "none"
+		return
 	}
 
-	chosenUpdates := make([]UpdateIdentifier, 0, len(result.SelectedIDs))
-	for _, selectedID := range result.SelectedIDs {
-		if update, ok := optionIndex[selectedID]; ok {
-			chosenUpdates = append(chosenUpdates, update)
+	updateResponse = strings.ToLower(updateResponse)
+	updateResponse = strings.Replace(updateResponse, " ", "", -1)
+	if updateResponse == "n" || updateResponse == "none" {
+		return
+	}
+
+	if updateResponse == "a" || updateResponse == "all" {
+		chosenUpdates = updateKeys
+		return
+	}
+
+	selections := strings.Split(updateResponse, ",")
+
+	for _, selection := range selections {
+		// Handle a range
+		if strings.Contains(selection, "-") {
+			rangeParts := strings.Split(selection, "-")
+			start, err := strconv.Atoi(rangeParts[0])
+			if err != nil {
+				selectionError = fmt.Errorf("%s is not a valid range", rangeParts[0])
+				return
+			}
+			end, err := strconv.Atoi(rangeParts[1])
+			if err != nil {
+				selectionError = fmt.Errorf("%s is not a valid range", rangeParts[1])
+				return
+			}
+			// Adjust for the 0 indexed slice we are working with
+			start -= 1
+			end -= 1
+			if start < 0 {
+				start = 0
+			}
+			if start > end {
+				selectionError = fmt.Errorf("%s is not a valid range", selection)
+				return
+			}
+			if end >= len(updateKeys) {
+				end = len(updateKeys) - 1
+			}
+
+			for i := start; i <= end; i++ {
+				chosenUpdates = append(chosenUpdates, updateKeys[i])
+			}
+		} else {
+			// Single entry
+			index, err := strconv.Atoi(selection)
+			if err != nil {
+				selectionError = fmt.Errorf("%s is not a valid range", selection)
+				return
+			}
+			index -= 1
+			if index >= 0 && index < len(updateKeys) {
+				chosenUpdates = append(chosenUpdates, updateKeys[index])
+			}
 		}
 	}
-
-	return chosenUpdates, nil
+	return
 }

client/command/backdoor/README.md

@@ -1,10 +1,4 @@
-# client/command/backdoor
+Backdoor
+========
 
-## Overview
-
-Implements the 'backdoor' command group for the Sliver client console.
-
-## Go Files
-
-- `backdoor.go` – Implements the RPC workflow that backdoors a remote binary with Sliver shellcode for the active session.
-- `commands.go` – Registers the Cobra command, binds flags/completions, and restricts usage to applicable targets.
+Implements command related to `backdoor`

client/command/beacons/README.md

@@ -1,14 +1,4 @@
-# client/command/beacons
+Beacons
+========
 
-## Overview
-
-Implements the 'beacons' command group for the Sliver client console. Handlers map Cobra invocations to beacons workflows such as prune, RM, and watch.
-
-## Go Files
-
-- `beacons.go` – Retrieves beacon inventories and renders them in tabular form with optional filtering.
-- `commands.go` – Declares the beacons command set, binds flags/completions, and wires subcommands like prune, rm, and watch.
-- `helpers.go` – Provides helper RPC wrappers for selecting, fetching, and listing beacons.
-- `prune.go` – Implements the prune routine that removes stale beacon entries via the backend API.
-- `rm.go` – Removes a specific beacon by ID, coordinating confirmation and RPC teardown.
-- `watch.go` – Streams beacon events in a watch loop, handling cancellation and console interaction.
+This package implements the beacons command, which can be used to list and interact with beacons.

client/command/beacons/beacons.go

@@ -39,7 +39,6 @@ import (
 func BeaconsCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	killFlag, _ := cmd.Flags().GetString("kill")
 	killAll, _ := cmd.Flags().GetBool("kill-all")
-	interact, _ := cmd.Flags().GetString("interact")
 
 	// Handle kill
 	if killFlag != "" {
@@ -73,18 +72,6 @@ func BeaconsCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 			con.PrintInfof("Killed %s (%s)\n", beacon.Name, beacon.ID)
 		}
 	}
-
-	if interact != "" {
-		beacon, err := GetBeacon(con, interact)
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-		con.ActiveTarget.Set(nil, beacon)
-		con.PrintInfof("Active beacon %s (%s)\n", beacon.Name, strings.Split(beacon.ID, "-")[0])
-		return
-	}
-
 	filter, _ := cmd.Flags().GetString("filter")
 	var filterRegex *regexp.Regexp
 	if filterRe, _ := cmd.Flags().GetString("filter-re"); filterRe != "" {
@@ -178,10 +165,10 @@ func renderBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regex
 	}
 
 	for _, beacon := range beacons {
-		style := console.StyleNormal
+		color := console.Normal
 		activeBeacon := con.ActiveTarget.GetBeacon()
 		if activeBeacon != nil && activeBeacon.ID == beacon.ID {
-			style = console.StyleGreen
+			color = console.Green
 		}
 		if beacon.Integrity == "" {
 			beacon.Integrity = "-"
@@ -192,34 +179,34 @@ func renderBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regex
 
 		if wideTermWidth {
 			rowEntries = []string{
-				style.Render(strings.Split(beacon.ID, "-")[0]),
-				style.Render(beacon.Name),
-				style.Render(fmt.Sprintf("%d/%d", beacon.TasksCountCompleted, beacon.TasksCount)),
-				style.Render(beacon.Transport),
-				style.Render(beacon.RemoteAddress),
-				style.Render(beacon.Hostname),
-				style.Render(strings.TrimPrefix(beacon.Username, beacon.Hostname+"\\")),
-				style.Render(fmt.Sprintf("%s (%d)", beacon.Filename, beacon.PID)),
+				fmt.Sprintf(color+"%s"+console.Normal, strings.Split(beacon.ID, "-")[0]),
+				fmt.Sprintf(color+"%s"+console.Normal, beacon.Name),
+				fmt.Sprintf(color+"%d/%d"+console.Normal, beacon.TasksCountCompleted, beacon.TasksCount),
+				fmt.Sprintf(color+"%s"+console.Normal, beacon.Transport),
+				fmt.Sprintf(color+"%s"+console.Normal, beacon.RemoteAddress),
+				fmt.Sprintf(color+"%s"+console.Normal, beacon.Hostname),
+				fmt.Sprintf(color+"%s"+console.Normal, strings.TrimPrefix(beacon.Username, beacon.Hostname+"\\")),
+				fmt.Sprintf(color+"%s (%d)"+console.Normal, beacon.Filename, beacon.PID),
 			}
 
 			if windowsBeaconInList {
-				rowEntries = append(rowEntries, style.Render(beacon.Integrity))
+				rowEntries = append(rowEntries, fmt.Sprintf(color+"%s"+console.Normal, beacon.Integrity))
 			}
 
 			rowEntries = append(rowEntries, []string{
-				style.Render(fmt.Sprintf("%s/%s", beacon.OS, beacon.Arch)),
-				style.Render(beacon.Locale),
+				fmt.Sprintf(color+"%s/%s"+console.Normal, beacon.OS, beacon.Arch),
+				fmt.Sprintf(color+"%s"+console.Normal, beacon.Locale),
 				con.FormatDateDelta(time.Unix(beacon.LastCheckin, 0), wideTermWidth, false),
 				con.FormatDateDelta(time.Unix(beacon.NextCheckin, 0), wideTermWidth, true),
 			}...)
 		} else {
 			rowEntries = []string{
-				style.Render(strings.Split(beacon.ID, "-")[0]),
-				style.Render(beacon.Name),
-				style.Render(beacon.Transport),
-				style.Render(beacon.Hostname),
-				style.Render(strings.TrimPrefix(beacon.Username, beacon.Hostname+"\\")),
-				style.Render(fmt.Sprintf("%s/%s", beacon.OS, beacon.Arch)),
+				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),
 				con.FormatDateDelta(time.Unix(beacon.NextCheckin, 0), wideTermWidth, true),
 			}

client/command/beacons/commands.go

@@ -28,12 +28,11 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		},
 	}
 	flags.Bind("beacons", true, beaconsCmd, func(f *pflag.FlagSet) {
-		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
+		f.IntP("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
 	})
 	flags.Bind("beacons", false, beaconsCmd, func(f *pflag.FlagSet) {
 		f.StringP("kill", "k", "", "kill the designated beacon")
 		f.BoolP("kill-all", "K", false, "kill all beacons")
-		f.StringP("interact", "i", "", "interact with a beacon")
 		f.BoolP("force", "F", false, "force killing the beacon")
 
 		f.StringP("filter", "f", "", "filter beacons by substring")
@@ -41,9 +40,7 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 	})
 	flags.BindFlagCompletions(beaconsCmd, func(comp *carapace.ActionMap) {
 		(*comp)["kill"] = BeaconIDCompleter(con)
-		(*comp)["interact"] = BeaconIDCompleter(con)
 	})
-	registerBeaconIDFlagCompletion(beaconsCmd, "interact", con)
 	beaconsRmCmd := &cobra.Command{
 		Use:   consts.RmStr,
 		Short: "Remove a beacon",
@@ -84,74 +81,22 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 // BeaconIDCompleter completes beacon IDs
 func BeaconIDCompleter(con *console.SliverClient) carapace.Action {
 	callback := func(_ carapace.Context) carapace.Action {
-		return carapace.ActionValuesDescribed(beaconCompletionPairs(con)...).Tag("beacons")
+		results := make([]string, 0)
+
+		beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+		if err == nil {
+			for _, b := range beacons.Beacons {
+				link := fmt.Sprintf("[%s <- %s]", b.ActiveC2, b.RemoteAddress)
+				id := fmt.Sprintf("%s (%d)", b.Name, b.PID)
+				userHost := fmt.Sprintf("%s@%s", b.Username, b.Hostname)
+				desc := strings.Join([]string{id, userHost, link}, " ")
+
+				results = append(results, b.ID[:8])
+				results = append(results, desc)
+			}
+		}
+		return carapace.ActionValuesDescribed(results...).Tag("beacons")
 	}
 
 	return carapace.ActionCallback(callback)
 }
-
-func registerBeaconIDFlagCompletion(cmd *cobra.Command, name string, con *console.SliverClient) {
-	if cmd == nil {
-		return
-	}
-	if _, ok := cmd.GetFlagCompletionFunc(name); ok {
-		return
-	}
-	if cmd.Flags().Lookup(name) == nil && cmd.PersistentFlags().Lookup(name) == nil {
-		return
-	}
-	_ = cmd.RegisterFlagCompletionFunc(name, func(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		values := describedValuesToTabs(beaconCompletionPairs(con))
-		return filterCompletionValues(values, toComplete), cobra.ShellCompDirectiveNoFileComp
-	})
-}
-
-func beaconCompletionPairs(con *console.SliverClient) []string {
-	results := make([]string, 0)
-	if con == nil || con.Rpc == nil {
-		return results
-	}
-
-	beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
-	if err != nil {
-		return results
-	}
-
-	for _, b := range beacons.Beacons {
-		link := fmt.Sprintf("[%s <- %s]", b.ActiveC2, b.RemoteAddress)
-		id := fmt.Sprintf("%s (%d)", b.Name, b.PID)
-		userHost := fmt.Sprintf("%s@%s", b.Username, b.Hostname)
-		desc := strings.Join([]string{id, userHost, link}, " ")
-
-		results = append(results, b.ID[:8], desc)
-	}
-
-	return results
-}
-
-func describedValuesToTabs(values []string) []string {
-	tabbed := make([]string, 0, len(values)/2)
-	for i := 0; i+1 < len(values); i += 2 {
-		tabbed = append(tabbed, fmt.Sprintf("%s\t%s", values[i], values[i+1]))
-	}
-	return tabbed
-}
-
-func filterCompletionValues(values []string, prefix string) []string {
-	if prefix == "" {
-		return values
-	}
-
-	filtered := make([]string, 0, len(values))
-	for _, value := range values {
-		candidate := value
-		if tab := strings.IndexByte(value, '\t'); tab >= 0 {
-			candidate = value[:tab]
-		}
-		if strings.HasPrefix(candidate, prefix) {
-			filtered = append(filtered, value)
-		}
-	}
-
-	return filtered
-}

client/command/beacons/helpers.go

@@ -26,8 +26,9 @@ import (
 	"strings"
 	"text/tabwriter"
 
+	"github.com/AlecAivazis/survey/v2"
+
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 )
@@ -82,8 +83,12 @@ func SelectBeacon(con *console.SliverClient) (*clientpb.Beacon, error) {
 
 	options := strings.Split(outputBuf.String(), "\n")
 	options = options[:len(options)-1] // Remove the last empty option
+	prompt := &survey.Select{
+		Message: "Select a beacon:",
+		Options: options,
+	}
 	selected := ""
-	_ = forms.Select("Select a beacon:", options, &selected)
+	survey.AskOne(prompt, &selected)
 	if selected == "" {
 		return nil, ErrNoSelection
 	}

client/command/beacons/prune.go

@@ -21,10 +21,10 @@ package beacons
 import (
 	"time"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/spf13/cobra"
 
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 )
@@ -71,7 +71,8 @@ func BeaconsPruneCmd(cmd *cobra.Command, con *console.SliverClient, args []strin
 	}
 	con.Println()
 	confirm := false
-	_ = forms.Confirm("Prune these beacons?", &confirm)
+	prompt := &survey.Confirm{Message: "Prune these beacons?"}
+	survey.AskOne(prompt, &confirm)
 	if !confirm {
 		return
 	}

client/command/builders/README.md

@@ -1,10 +0,0 @@
-# client/command/builders
-
-## Overview
-
-Implements the 'builders' command group for the Sliver client console.
-
-## Go Files
-
-- `builders.go` – Fetches external builder metadata and formats it for console display.
-- `commands.go` – Registers the builders CLI command with its flags and completion helpers.

client/command/c2profiles/README.md

@@ -1,10 +0,0 @@
-# client/command/c2profiles
-
-## Overview
-
-Implements the 'c2profiles' command group for the Sliver client console. Handlers map Cobra invocations to c2profiles workflows such as C2 profiles.
-
-## Go Files
-
-- `c2profiles.go` – Implements listing, import/export, and generation routines for HTTP C2 profiles, including protobuf/JSON conversion helpers.
-- `commands.go` – Binds the c2profiles command suite with flag handling and completions for profile management operations.

client/command/c2profiles/c2profiles.go

@@ -21,15 +21,16 @@ package c2profiles
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
+	"math/rand"
 	"net/url"
 	"os"
 	"path"
 	"path/filepath"
 	"strings"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/jedib0t/go-pretty/v6/table"
 	"github.com/spf13/cobra"
 	"golang.org/x/exp/slices"
@@ -38,15 +39,10 @@ import (
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/constants"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 )
 
-var (
-	ErrNoSelection = errors.New("no selection")
-)
-
 // C2ProfileCmd list available http profiles
 func C2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	profileName, _ := cmd.Flags().GetString("name")
@@ -58,11 +54,7 @@ func C2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []string)
 			return
 		}
 		if len(httpC2Profiles.Configs) != 1 {
-			profileName, err = selectC2Profile(httpC2Profiles.Configs)
-			if err != nil {
-				con.PrintErrorf("%s\n", err)
-				return
-			}
+			profileName = selectC2Profile(httpC2Profiles.Configs)
 		}
 	}
 
@@ -75,6 +67,7 @@ func C2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []string)
 }
 
 func ImportC2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
+	protocols := []string{constants.HttpStr, constants.HttpsStr}
 	profileName, _ := cmd.Flags().GetString("name")
 	if profileName == "" {
 		con.PrintErrorf("Invalid c2 profile name\n")
@@ -110,6 +103,29 @@ func ImportC2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []st
 		con.PrintErrorf("%s\n", err)
 		return
 	}
+	confirm := false
+	prompt := &survey.Confirm{Message: "Restart HTTP/S jobs?"}
+	survey.AskOne(prompt, &confirm)
+	if confirm {
+		var restartJobReq clientpb.RestartJobReq
+		jobs, err := con.Rpc.GetJobs(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		// reload jobs to include new profile
+		for _, job := range jobs.Active {
+			if job != nil && slices.Contains(protocols, job.Name) {
+				restartJobReq.JobIDs = append(restartJobReq.JobIDs, job.ID)
+			}
+		}
+
+		_, err = con.Rpc.RestartJobs(context.Background(), &restartJobReq)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+	}
 }
 
 func ExportC2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
@@ -133,11 +149,7 @@ func ExportC2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []st
 			return
 		}
 		if len(httpC2Profiles.Configs) != 1 {
-			profileName, err = selectC2Profile(httpC2Profiles.Configs)
-			if err != nil {
-				con.PrintErrorf("%s\n", err)
-				return
-			}
+			profileName = selectC2Profile(httpC2Profiles.Configs)
 		}
 	}
 
@@ -189,6 +201,23 @@ func GenerateC2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []
 		return
 	}
 
+	c2Profiles, err := con.Rpc.GetHTTPC2Profiles(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	var extensions []string
+	for _, c2profile := range c2Profiles.Configs {
+		confProfile, err := con.Rpc.GetHTTPC2ProfileByName(context.Background(), &clientpb.C2ProfileReq{Name: c2profile.Name})
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		extensions = append(extensions, confProfile.ImplantConfig.StagerFileExtension)
+		extensions = append(extensions, confProfile.ImplantConfig.StartSessionFileExtension)
+	}
+
 	config, err := C2ConfigToJSON(profileName, profile)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
@@ -214,7 +243,7 @@ func GenerateC2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []
 	}
 	urls := strings.Split(string(fileContent), "\n")
 
-	jsonProfile, err := updateC2Profile(config, urls)
+	jsonProfile, err := updateC2Profile(extensions, config, urls)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return
@@ -235,26 +264,26 @@ func GenerateC2ProfileCmd(cmd *cobra.Command, con *console.SliverClient, args []
 		}
 		con.Println("C2 profile generated and saved as ", profileName)
 	} else {
-		PrintC2Profiles(C2ConfigToProtobuf(profileName, jsonProfile), con)
+		PrintC2Profiles(profile, con)
 	}
 }
 
 // convert protobuf to json
 func C2ConfigToJSON(profileName string, profile *clientpb.HTTPC2Config) (*assets.HTTPC2Config, error) {
 	implantConfig := assets.HTTPC2ImplantConfig{
-		UserAgent:          profile.ImplantConfig.UserAgent,
-		ChromeBaseVersion:  int(profile.ImplantConfig.ChromeBaseVersion),
-		MacOSVersion:       profile.ImplantConfig.MacOSVersion,
-		NonceQueryArgChars: profile.ImplantConfig.NonceQueryArgChars,
-		NonceQueryLength:   int(profile.ImplantConfig.NonceQueryLength),
-		NonceMode:          profile.ImplantConfig.NonceMode,
-		MaxFileGen:         int(profile.ImplantConfig.MaxFileGen),
-		MinFileGen:         int(profile.ImplantConfig.MinFileGen),
-		MaxPathGen:         int(profile.ImplantConfig.MaxPathGen),
-		MinPathGen:         int(profile.ImplantConfig.MinFileGen),
-		MaxPathLength:      int(profile.ImplantConfig.MaxPathLength),
-		MinPathLength:      int(profile.ImplantConfig.MinPathLength),
-		Extensions:         profile.ImplantConfig.Extensions,
+		UserAgent:           profile.ImplantConfig.UserAgent,
+		ChromeBaseVersion:   int(profile.ImplantConfig.ChromeBaseVersion),
+		MacOSVersion:        profile.ImplantConfig.MacOSVersion,
+		NonceQueryArgChars:  profile.ImplantConfig.NonceQueryArgChars,
+		MaxFiles:            int(profile.ImplantConfig.MaxFiles),
+		MinFiles:            int(profile.ImplantConfig.MinFiles),
+		MaxPaths:            int(profile.ImplantConfig.MaxPaths),
+		MinPaths:            int(profile.ImplantConfig.MinFiles),
+		StagerFileExt:       profile.ImplantConfig.StagerFileExtension,
+		PollFileExt:         profile.ImplantConfig.PollFileExtension,
+		StartSessionFileExt: profile.ImplantConfig.StartSessionFileExtension,
+		SessionFileExt:      profile.ImplantConfig.SessionFileExtension,
+		CloseFileExt:        profile.ImplantConfig.CloseFileExtension,
 	}
 
 	var headers []assets.NameValueProbability
@@ -279,19 +308,50 @@ func C2ConfigToJSON(profileName string, profile *clientpb.HTTPC2Config) (*assets
 	implantConfig.URLParameters = urlParameters
 
 	var (
-		files []string
-		paths []string
+		stagerFiles  []string
+		pollFiles    []string
+		sessionFiles []string
+		closeFiles   []string
+		stagerPaths  []string
+		pollPaths    []string
+		sessionPaths []string
+		closePaths   []string
 	)
 
 	for _, pathSegment := range profile.ImplantConfig.PathSegments {
 		if pathSegment.IsFile {
-			files = append(files, pathSegment.Value)
+			switch pathSegment.SegmentType {
+			case 0:
+				pollFiles = append(pollFiles, pathSegment.Value)
+			case 1:
+				sessionFiles = append(sessionFiles, pathSegment.Value)
+			case 2:
+				closeFiles = append(closeFiles, pathSegment.Value)
+			case 3:
+				stagerFiles = append(stagerFiles, pathSegment.Value)
+			}
 		} else {
-			paths = append(paths, pathSegment.Value)
+			switch pathSegment.SegmentType {
+			case 0:
+				pollPaths = append(pollPaths, pathSegment.Value)
+			case 1:
+				sessionPaths = append(sessionPaths, pathSegment.Value)
+			case 2:
+				closePaths = append(closePaths, pathSegment.Value)
+			case 3:
+				stagerPaths = append(stagerPaths, pathSegment.Value)
+			}
 		}
 	}
-	implantConfig.Files = files
-	implantConfig.Paths = paths
+
+	implantConfig.PollFiles = pollFiles
+	implantConfig.SessionFiles = sessionFiles
+	implantConfig.CloseFiles = closeFiles
+	implantConfig.StagerFiles = stagerFiles
+	implantConfig.PollPaths = pollPaths
+	implantConfig.SessionPaths = sessionPaths
+	implantConfig.ClosePaths = closePaths
+	implantConfig.StagerPaths = stagerPaths
 
 	var serverHeaders []assets.NameValueProbability
 	for _, header := range profile.ServerConfig.Headers {
@@ -330,17 +390,68 @@ func C2ConfigToProtobuf(profileName string, config *assets.HTTPC2Config) *client
 	pathSegments := []*clientpb.HTTPC2PathSegment{}
 
 	// files
-	for _, file := range config.ImplantConfig.Files {
+	for _, poll := range config.ImplantConfig.PollFiles {
 		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
-			IsFile: true,
-			Value:  file,
+			IsFile:      true,
+			SegmentType: 0,
+			Value:       poll,
 		})
 	}
 
-	for _, path := range config.ImplantConfig.Paths {
+	for _, session := range config.ImplantConfig.SessionFiles {
 		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
-			IsFile: false,
-			Value:  path,
+			IsFile:      true,
+			SegmentType: 1,
+			Value:       session,
+		})
+	}
+
+	for _, close := range config.ImplantConfig.CloseFiles {
+		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
+			IsFile:      true,
+			SegmentType: 2,
+			Value:       close,
+		})
+	}
+
+	for _, stager := range config.ImplantConfig.StagerFiles {
+		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
+			IsFile:      true,
+			SegmentType: 3,
+			Value:       stager,
+		})
+	}
+
+	// paths
+	for _, poll := range config.ImplantConfig.PollPaths {
+		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
+			IsFile:      false,
+			SegmentType: 0,
+			Value:       poll,
+		})
+	}
+
+	for _, session := range config.ImplantConfig.SessionPaths {
+		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
+			IsFile:      false,
+			SegmentType: 1,
+			Value:       session,
+		})
+	}
+
+	for _, close := range config.ImplantConfig.ClosePaths {
+		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
+			IsFile:      false,
+			SegmentType: 2,
+			Value:       close,
+		})
+	}
+
+	for _, stager := range config.ImplantConfig.StagerPaths {
+		pathSegments = append(pathSegments, &clientpb.HTTPC2PathSegment{
+			IsFile:      false,
+			SegmentType: 3,
+			Value:       stager,
 		})
 	}
 
@@ -363,22 +474,22 @@ func C2ConfigToProtobuf(profileName string, config *assets.HTTPC2Config) *client
 	}
 
 	implantConfig := &clientpb.HTTPC2ImplantConfig{
-		UserAgent:          config.ImplantConfig.UserAgent,
-		ChromeBaseVersion:  int32(config.ImplantConfig.ChromeBaseVersion),
-		MacOSVersion:       config.ImplantConfig.MacOSVersion,
-		NonceQueryArgChars: config.ImplantConfig.NonceQueryArgChars,
-		NonceQueryLength:   int32(config.ImplantConfig.NonceQueryLength),
-		NonceMode:          config.ImplantConfig.NonceMode,
-		ExtraURLParameters: httpC2UrlParameters,
-		Headers:            httpC2Headers,
-		MaxFileGen:         int32(config.ImplantConfig.MaxFileGen),
-		MinFileGen:         int32(config.ImplantConfig.MinFileGen),
-		MaxPathGen:         int32(config.ImplantConfig.MaxPathGen),
-		MinPathGen:         int32(config.ImplantConfig.MinPathGen),
-		MaxPathLength:      int32(config.ImplantConfig.MaxPathLength),
-		MinPathLength:      int32(config.ImplantConfig.MinPathLength),
-		Extensions:         config.ImplantConfig.Extensions,
-		PathSegments:       pathSegments,
+		UserAgent:                 config.ImplantConfig.UserAgent,
+		ChromeBaseVersion:         int32(config.ImplantConfig.ChromeBaseVersion),
+		MacOSVersion:              config.ImplantConfig.MacOSVersion,
+		NonceQueryArgChars:        config.ImplantConfig.NonceQueryArgChars,
+		ExtraURLParameters:        httpC2UrlParameters,
+		Headers:                   httpC2Headers,
+		MaxFiles:                  int32(config.ImplantConfig.MaxFiles),
+		MinFiles:                  int32(config.ImplantConfig.MinFiles),
+		MaxPaths:                  int32(config.ImplantConfig.MaxPaths),
+		MinPaths:                  int32(config.ImplantConfig.MinFiles),
+		StagerFileExtension:       config.ImplantConfig.StagerFileExt,
+		PollFileExtension:         config.ImplantConfig.PollFileExt,
+		StartSessionFileExtension: config.ImplantConfig.StartSessionFileExt,
+		SessionFileExtension:      config.ImplantConfig.SessionFileExt,
+		CloseFileExtension:        config.ImplantConfig.CloseFileExt,
+		PathSegments:              pathSegments,
 	}
 
 	// Server Config
@@ -488,94 +599,126 @@ func PrintC2Profiles(profile *clientpb.HTTPC2Config, con *console.SliverClient)
 		"Nonce query arg chars",
 		profile.ImplantConfig.NonceQueryArgChars,
 	})
-	tw.AppendRow(table.Row{
-		"Nonce query length",
-		profile.ImplantConfig.NonceQueryLength,
-	})
-	tw.AppendRow(table.Row{
-		"Nonce mode",
-		profile.ImplantConfig.NonceMode,
-	})
 	tw.AppendRow(table.Row{
 		"Max files",
-		profile.ImplantConfig.MaxFileGen,
+		profile.ImplantConfig.MaxFiles,
 	})
 	tw.AppendRow(table.Row{
 		"Min files",
-		profile.ImplantConfig.MinFileGen,
+		profile.ImplantConfig.MinFiles,
 	})
 	tw.AppendRow(table.Row{
 		"Max paths",
-		profile.ImplantConfig.MaxPathGen,
+		profile.ImplantConfig.MaxPaths,
 	})
 	tw.AppendRow(table.Row{
 		"Min paths",
-		profile.ImplantConfig.MinPathGen,
+		profile.ImplantConfig.MinPaths,
 	})
 
 	tw.AppendRow(table.Row{
-		"Max path length",
-		profile.ImplantConfig.MaxPathLength,
+		"Stager file extension",
+		profile.ImplantConfig.StagerFileExtension,
 	})
-
 	tw.AppendRow(table.Row{
-		"Min path length",
-		profile.ImplantConfig.MinPathLength,
+		"Start session file extension",
+		profile.ImplantConfig.StartSessionFileExtension,
 	})
-
 	tw.AppendRow(table.Row{
-		"File extensions",
-		strings.Join(profile.ImplantConfig.Extensions, ","),
+		"Session file extension",
+		profile.ImplantConfig.SessionFileExtension,
+	})
+	tw.AppendRow(table.Row{
+		"Poll file extension",
+		profile.ImplantConfig.PollFileExtension,
+	})
+	tw.AppendRow(table.Row{
+		"Close file extension",
+		profile.ImplantConfig.CloseFileExtension,
 	})
 
 	var (
-		paths []string
-		files []string
+		pollPaths    []string
+		pollFiles    []string
+		sessionPaths []string
+		sessionFiles []string
+		closePaths   []string
+		closeFiles   []string
 	)
 	for _, segment := range profile.ImplantConfig.PathSegments {
 		if segment.IsFile {
-			files = append(files, segment.Value)
+			switch segment.SegmentType {
+			case 0:
+				pollFiles = append(pollFiles, segment.Value)
+			case 1:
+				sessionFiles = append(sessionFiles, segment.Value)
+			case 2:
+				closeFiles = append(closeFiles, segment.Value)
+			}
 		} else {
-			paths = append(paths, segment.Value)
+			switch segment.SegmentType {
+			case 0:
+				pollPaths = append(pollPaths, segment.Value)
+			case 1:
+				sessionPaths = append(sessionPaths, segment.Value)
+			case 2:
+				closePaths = append(closePaths, segment.Value)
+			}
 		}
 	}
-
 	tw.AppendRow(table.Row{
-		"Paths",
-		strings.Join(paths[:], ",")[:50] + "...",
+		"Poll paths",
+		strings.Join(pollPaths[:], ","),
 	})
 	tw.AppendRow(table.Row{
-		"Files",
-		strings.Join(files[:], ",")[:50] + "...",
+		"Poll files",
+		strings.Join(pollFiles[:], ","),
+	})
+	tw.AppendRow(table.Row{
+		"Session paths",
+		strings.Join(sessionPaths[:], ","),
+	})
+	tw.AppendRow(table.Row{
+		"Session files",
+		strings.Join(sessionFiles[:], ","),
+	})
+	tw.AppendRow(table.Row{
+		"Close paths",
+		strings.Join(closePaths[:], ","),
+	})
+	tw.AppendRow(table.Row{
+		"Close files",
+		strings.Join(closeFiles[:], ","),
 	})
 
 	con.Println(tw.Render())
 	con.Println("\n")
 }
 
-func selectC2Profile(c2profiles []*clientpb.HTTPC2Config) (string, error) {
+func selectC2Profile(c2profiles []*clientpb.HTTPC2Config) string {
 	c2profile := ""
 	var choices []string
 	for _, c2profile := range c2profiles {
 		choices = append(choices, c2profile.Name)
 	}
 
-	_ = forms.Select("Select a c2 profile", choices, &c2profile)
-
-	if c2profile == "" {
-		return "", ErrNoSelection
+	prompt := &survey.Select{
+		Message: "Select a c2 profile",
+		Options: choices,
 	}
+	survey.AskOne(prompt, &c2profile, nil)
 
-	return c2profile, nil
+	return c2profile
 }
 
-func updateC2Profile(template *assets.HTTPC2Config, urls []string) (*assets.HTTPC2Config, error) {
+func updateC2Profile(usedExtensions []string, template *assets.HTTPC2Config, urls []string) (*assets.HTTPC2Config, error) {
 	// update the template with the urls
 
 	var (
-		paths      []string
-		filenames  []string
-		extensions []string
+		paths              []string
+		filenames          []string
+		extensions         []string
+		filteredExtensions []string
 	)
 
 	for _, urlPath := range urls {
@@ -604,13 +747,23 @@ func updateC2Profile(template *assets.HTTPC2Config, urls []string) (*assets.HTTP
 	slices.Sort(extensions)
 	extensions = slices.Compact(extensions)
 
+	for _, extension := range extensions {
+		if !slices.Contains(usedExtensions, extension) {
+			filteredExtensions = append(filteredExtensions, extension)
+		}
+	}
+
 	slices.Sort(paths)
 	paths = slices.Compact(paths)
 
 	slices.Sort(filenames)
 	filenames = slices.Compact(filenames)
 
-	// 5 is arbitrarily used as a minimum value
+	// 5 is arbitrarily used as a minimum value, it only has to be 5 for the extensions, the others can be lower
+	if len(filteredExtensions) < 5 {
+		return nil, fmt.Errorf("got %d unused extensions, need at least 5", len(filteredExtensions))
+	}
+
 	if len(paths) < 5 {
 		return nil, fmt.Errorf("got %d paths need at least 5", len(paths))
 	}
@@ -619,8 +772,53 @@ func updateC2Profile(template *assets.HTTPC2Config, urls []string) (*assets.HTTP
 		return nil, fmt.Errorf("got %d paths need at least 5", len(filenames))
 	}
 
-	template.ImplantConfig.Extensions = extensions
-	template.ImplantConfig.Paths = paths
-	template.ImplantConfig.Files = filenames
+	// shuffle extensions
+	for i := len(extensions) - 1; i > 0; i-- {
+		j := rand.Intn(i + 1)
+		extensions[i], extensions[j] = extensions[j], extensions[i]
+	}
+
+	template.ImplantConfig.PollFileExt = extensions[0]
+	template.ImplantConfig.StagerFileExt = extensions[1]
+	template.ImplantConfig.StartSessionFileExt = extensions[2]
+	template.ImplantConfig.SessionFileExt = extensions[3]
+	template.ImplantConfig.CloseFileExt = extensions[4]
+
+	// randomly distribute the paths and filenames into the different segment types
+	template.ImplantConfig.CloseFiles = []string{}
+	template.ImplantConfig.SessionFiles = []string{}
+	template.ImplantConfig.PollFiles = []string{}
+	template.ImplantConfig.StagerFiles = []string{}
+	template.ImplantConfig.ClosePaths = []string{}
+	template.ImplantConfig.SessionPaths = []string{}
+	template.ImplantConfig.PollPaths = []string{}
+	template.ImplantConfig.StagerPaths = []string{}
+
+	for _, path := range paths {
+		switch rand.Intn(4) {
+		case 0:
+			template.ImplantConfig.PollPaths = append(template.ImplantConfig.PollPaths, path)
+		case 1:
+			template.ImplantConfig.SessionPaths = append(template.ImplantConfig.SessionPaths, path)
+		case 2:
+			template.ImplantConfig.ClosePaths = append(template.ImplantConfig.ClosePaths, path)
+		case 3:
+			template.ImplantConfig.StagerPaths = append(template.ImplantConfig.StagerPaths, path)
+		}
+	}
+
+	for _, filename := range filenames {
+		switch rand.Intn(4) {
+		case 0:
+			template.ImplantConfig.PollFiles = append(template.ImplantConfig.PollFiles, filename)
+		case 1:
+			template.ImplantConfig.SessionFiles = append(template.ImplantConfig.SessionFiles, filename)
+		case 2:
+			template.ImplantConfig.CloseFiles = append(template.ImplantConfig.CloseFiles, filename)
+		case 3:
+			template.ImplantConfig.StagerFiles = append(template.ImplantConfig.StagerFiles, filename)
+		}
+	}
+
 	return template, nil
 }

client/command/c2profiles/commands.go

@@ -1,7 +1,6 @@
 package c2profiles
 
 import (
-	"github.com/bishopfox/sliver/client/command/completers"
 	"github.com/bishopfox/sliver/client/command/flags"
 	"github.com/bishopfox/sliver/client/command/generate"
 	"github.com/bishopfox/sliver/client/command/help"
@@ -28,7 +27,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		f.StringP("file", "f", "", "Path to C2 configuration file to import")
 		f.BoolP("overwrite", "o", false, "Overwrite profile if it exists")
 	})
-	completers.RegisterLocalFilePathFlagCompletion(importC2ProfileCmd, "file")
 
 	exportC2ProfileCmd := &cobra.Command{
 		Use:   consts.ExportC2ProfileStr,
@@ -42,7 +40,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		f.StringP("file", "f", "", "Path to file to export C2 configuration to")
 		f.StringP("name", "n", consts.DefaultC2Profile, "HTTP C2 Profile name")
 	})
-	completers.RegisterLocalFilePathFlagCompletion(exportC2ProfileCmd, "file")
 	flags.BindFlagCompletions(exportC2ProfileCmd, func(comp *carapace.ActionMap) {
 		(*comp)["name"] = generate.HTTPC2Completer(con)
 	})
@@ -79,7 +76,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		f.StringP("name", "n", "", "HTTP C2 Profile name to save C2Profile as")
 		f.StringP("template", "t", consts.DefaultC2Profile, "HTTP C2 Profile to use as a template for the new profile")
 	})
-	completers.RegisterLocalFilePathFlagCompletion(generateC2ProfileCmd, "file")
 
 	flags.BindFlagCompletions(generateC2ProfileCmd, func(comp *carapace.ActionMap) {
 		(*comp)["template"] = generate.HTTPC2Completer(con)

client/command/certificates/README.md

@@ -1,12 +0,0 @@
-# client/command/certificates
-
-## Overview
-
-Implements the 'certificates' command group for the Sliver client console.
-
-## Go Files
-
-- `authorities.go` – Retrieves certificate authority metadata from the server and prints it in a table.
-- `completions.go` – Provides tab completion helpers for certificate common names.
-- `certificates.go` – Retrieves certificate metadata from the server, formats expiration status, and prints results to the console.
-- `commands.go` – Registers the certificates command and binds the flags needed to query certificate inventories.

client/command/certificates/authorities.go

@@ -1,89 +0,0 @@
-package certificates
-
-import (
-	"context"
-	"time"
-
-	"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/jedib0t/go-pretty/v6/table"
-	"github.com/spf13/cobra"
-	"golang.org/x/term"
-)
-
-func CertificateAuthoritiesCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
-	authorityInfo, err := con.Rpc.GetCertificateAuthorityInfo(context.Background(), &commonpb.Empty{})
-	if err != nil {
-		con.PrintErrorf("could not get certificate authority information from database: %s", err.Error())
-		return
-	}
-
-	printCertificateAuthorityInfo(con, authorityInfo.Info)
-}
-
-func printCertificateAuthorityInfo(con *console.SliverClient, authData []*clientpb.CertificateAuthorityData) {
-	width, _, err := term.GetSize(0)
-	if err != nil {
-		width = 999
-	}
-
-	if len(authData) == 0 {
-		con.PrintWarnf("There are no certificate authorities in the database.\n")
-		return
-	}
-
-	tw := table.NewWriter()
-	tw.SetStyle(settings.GetTableStyle(con))
-	wideTermWidth := con.Settings.SmallTermWidth < width
-
-	if wideTermWidth {
-		tw.AppendHeader(table.Row{
-			"ID",
-			"Common Name",
-			"Creation Time",
-			"Authority Type",
-			"Key Algorithm",
-			"Validity Start",
-			"Expires",
-		})
-	} else {
-		tw.AppendHeader(table.Row{
-			"ID",
-			"Common Name",
-			"Expires",
-		})
-	}
-
-	for _, authority := range authData {
-		rowStyle := console.StyleNormal
-
-		expiry, err := time.Parse(timeFormat, authority.ValidityExpiry)
-		if err == nil {
-			rowStyle = checkCertExpiry(expiry)
-		}
-
-		if wideTermWidth {
-			tw.AppendRow(table.Row{
-				rowStyle.Render(authority.ID),
-				rowStyle.Render(authority.CN),
-				rowStyle.Render(authority.CreationTime),
-				rowStyle.Render(authority.Type),
-				rowStyle.Render(authority.KeyAlgorithm),
-				rowStyle.Render(authority.ValidityStart),
-				rowStyle.Render(authority.ValidityExpiry),
-			})
-		} else {
-			tw.AppendRow(table.Row{
-				rowStyle.Render(authority.ID),
-				rowStyle.Render(authority.CN),
-				rowStyle.Render(authority.ValidityExpiry),
-			})
-		}
-	}
-
-	tw.SortBy([]table.SortBy{{Name: "Expires", Mode: table.Dsc}})
-
-	con.Printf("%s\n", tw.Render())
-}

client/command/certificates/certificates.go

@@ -2,6 +2,7 @@ package certificates
 
 import (
 	"context"
+	"fmt"
 	"time"
 
 	"github.com/bishopfox/sliver/client/command/settings"
@@ -94,22 +95,22 @@ func CertificateInfoCmd(cmd *cobra.Command, con *console.SliverClient, args []st
 	printCertificateInfo(con, certificateInfo.Info)
 }
 
-func checkCertExpiry(expiryTime time.Time) console.TextStyle {
+func checkCertExpiry(expiryTime time.Time) string {
 	if expiryTime.Before(time.Now()) || expiryTime.Equal(time.Now()) {
-		return console.StyleBoldRed
+		return console.Bold + console.Red
 	}
 
 	// One week is 168 hours - this is bad
 	if expiryTime.Before(time.Now().Add(168 * time.Hour)) {
-		return console.StyleBoldRed
+		return console.Bold + console.Red
 	}
 
 	// One month is approximately 730 hours - this is a warning
 	if expiryTime.Before(time.Now().Add(730 * time.Hour)) {
-		return console.StyleBoldOrange
+		return console.Bold + console.Orange
 	}
 
-	return console.StyleNormal
+	return console.Normal
 }
 
 func printCertificateInfo(con *console.SliverClient, certData []*clientpb.CertificateData) {
@@ -147,28 +148,28 @@ func printCertificateInfo(con *console.SliverClient, certData []*clientpb.Certif
 	}
 
 	for _, cert := range certData {
-		rowStyle := console.StyleNormal
+		rowColor := console.Normal
 
 		expiry, err := time.Parse(timeFormat, cert.ValidityExpiry)
 		// This should not error out, but if it does, the row will not be colored
 		if err == nil {
-			rowStyle = checkCertExpiry(expiry)
+			rowColor = checkCertExpiry(expiry)
 		}
 		if wideTermWidth {
 			tw.AppendRow(table.Row{
-				rowStyle.Render(cert.ID),
-				rowStyle.Render(cert.CN),
-				rowStyle.Render(cert.CreationTime),
-				rowStyle.Render(cert.Type),
-				rowStyle.Render(cert.KeyAlgorithm),
-				rowStyle.Render(cert.ValidityStart),
-				rowStyle.Render(cert.ValidityExpiry),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.ID),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.CN),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.CreationTime),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.Type),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.KeyAlgorithm),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.ValidityStart),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.ValidityExpiry),
 			})
 		} else {
 			tw.AppendRow(table.Row{
-				rowStyle.Render(cert.ID),
-				rowStyle.Render(cert.CN),
-				rowStyle.Render(cert.ValidityExpiry),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.ID),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.CN),
+				fmt.Sprintf(rowColor+"%s"+console.Normal, cert.ValidityExpiry),
 			})
 		}
 

client/command/certificates/commands.go

@@ -23,7 +23,6 @@ import (
 	"github.com/bishopfox/sliver/client/command/help"
 	"github.com/bishopfox/sliver/client/console"
 	consts "github.com/bishopfox/sliver/client/constants"
-	"github.com/rsteube/carapace"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 )
@@ -45,19 +44,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		f.BoolP("server", "s", false, "Show server certificates")
 		f.StringP("cn", "c", "", "Show certificate information for a provided common name")
 	})
-	flags.BindFlagCompletions(certificatesCmd, func(comp *carapace.ActionMap) {
-		(*comp)["cn"] = CertificateCommonNameCompleter(con)
-	})
-	registerCertificateCNFlagCompletion(certificatesCmd, "cn", con)
-
-	authoritiesCmd := &cobra.Command{
-		Use:   "authorities",
-		Short: "List certificate authorities",
-		Run: func(cmd *cobra.Command, args []string) {
-			CertificateAuthoritiesCmd(cmd, con, args)
-		},
-	}
-	certificatesCmd.AddCommand(authoritiesCmd)
 
 	return []*cobra.Command{
 		certificatesCmd,

client/command/certificates/completions.go

@@ -1,96 +0,0 @@
-package certificates
-
-import (
-	"context"
-	"sort"
-	"strings"
-
-	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/protobuf/clientpb"
-	"github.com/rsteube/carapace"
-	"github.com/spf13/cobra"
-)
-
-// CertificateCommonNameCompleter completes common names for stored certificates.
-func CertificateCommonNameCompleter(con *console.SliverClient) carapace.Action {
-	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
-		if con == nil || con.Rpc == nil {
-			return carapace.ActionMessage("not connected")
-		}
-
-		values, err := certificateCommonNameValues(con)
-		if err != nil {
-			return carapace.ActionMessage("failed to list certificates %s", err)
-		}
-		if len(values) == 0 {
-			return carapace.ActionMessage("no certificates")
-		}
-
-		return carapace.ActionValues(values...).Tag("common name").Usage("certificate common name")
-	})
-}
-
-func registerCertificateCNFlagCompletion(cmd *cobra.Command, name string, con *console.SliverClient) {
-	if cmd == nil {
-		return
-	}
-	if _, ok := cmd.GetFlagCompletionFunc(name); ok {
-		return
-	}
-	if cmd.Flags().Lookup(name) == nil && cmd.PersistentFlags().Lookup(name) == nil {
-		return
-	}
-	_ = cmd.RegisterFlagCompletionFunc(name, func(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		values, err := certificateCommonNameValues(con)
-		if err != nil {
-			return nil, cobra.ShellCompDirectiveNoFileComp
-		}
-		return filterCompletionValues(values, toComplete), cobra.ShellCompDirectiveNoFileComp
-	})
-}
-
-func certificateCommonNameValues(con *console.SliverClient) ([]string, error) {
-	if con == nil || con.Rpc == nil {
-		return nil, nil
-	}
-	certInfo, err := con.Rpc.GetCertificateInfo(context.Background(), &clientpb.CertificatesReq{
-		CategoryFilters: AllTransports | AllRoles,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	unique := map[string]struct{}{}
-	for _, cert := range certInfo.Info {
-		if cert.CN == "" {
-			continue
-		}
-		unique[cert.CN] = struct{}{}
-	}
-
-	values := make([]string, 0, len(unique))
-	for name := range unique {
-		values = append(values, name)
-	}
-	sort.Strings(values)
-	return values, nil
-}
-
-func filterCompletionValues(values []string, prefix string) []string {
-	if prefix == "" {
-		return values
-	}
-
-	filtered := make([]string, 0, len(values))
-	for _, value := range values {
-		candidate := value
-		if tab := strings.IndexByte(value, '\t'); tab >= 0 {
-			candidate = value[:tab]
-		}
-		if strings.HasPrefix(candidate, prefix) {
-			filtered = append(filtered, value)
-		}
-	}
-
-	return filtered
-}

client/command/clean/README.md

@@ -1,9 +0,0 @@
-# client/command/clean
-
-## Overview
-
-Implements the 'clean' command group for the Sliver client console.
-
-## Go Files
-
-- `clean.go` – Defines the clean command and its helpers that purge local build artifacts, cached profiles, and stale sessions.

client/command/clean/clean.go

@@ -21,10 +21,10 @@ package clean
 import (
 	"context"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/command/flags"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/constants"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
@@ -35,7 +35,8 @@ import (
 func CleanCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	con.Printf("This command will kill and remove all sessions, beacons and profiles \n")
 	confirm := false
-	_ = forms.Confirm("Are you sure you want to destroy everything?", &confirm)
+	prompt := &survey.Confirm{Message: "Are you sure you want to destroy everything?"}
+	survey.AskOne(prompt, &confirm)
 	if !confirm {
 		return
 	}

client/command/completers/README.md

@@ -1,9 +1,4 @@
-# client/command/completers
+Completers
+===========
 
-## Overview
-
-Implements the 'completers' command group for the Sliver client console.
-
-## Go Files
-
-- `completers.go` – Provides reusable carapace completion helpers for selecting client interfaces and proxy endpoints.
+This package contains general purpose completers for the console, note that some package also contain their own package-specific completers. 

client/command/completers/completers.go

@@ -22,7 +22,6 @@ import (
 	"net"
 
 	"github.com/rsteube/carapace"
-	"github.com/spf13/cobra"
 )
 
 // ClientInterfacesCompleter completes interface addresses on the client host.
@@ -85,60 +84,3 @@ func LocalProxyCompleter() carapace.Action {
 		}).Invoke(c).Prefix(prefix).ToA()
 	})
 }
-
-// LocalFilePathCompleter completes local file and directory paths.
-func LocalFilePathCompleter() carapace.Action {
-	return carapace.ActionFiles().Tag("local file path")
-}
-
-// RegisterLocalFilePathFlagCompletion registers local file-path completion for a flag.
-func RegisterLocalFilePathFlagCompletion(cmd *cobra.Command, name string) {
-	if cmd == nil {
-		return
-	}
-	if _, ok := cmd.GetFlagCompletionFunc(name); ok {
-		return
-	}
-	if cmd.Flags().Lookup(name) == nil && cmd.PersistentFlags().Lookup(name) == nil {
-		return
-	}
-	_ = cmd.RegisterFlagCompletionFunc(name, func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
-		return nil, cobra.ShellCompDirectiveDefault
-	})
-}
-
-// RegisterLocalFilePathFlagCompletions registers local file-path completion for a list of flags.
-func RegisterLocalFilePathFlagCompletions(cmd *cobra.Command, names ...string) {
-	for _, name := range names {
-		RegisterLocalFilePathFlagCompletion(cmd, name)
-	}
-}
-
-// RegisterLocalFilePathPositionalCompletion registers local file-path completion for a positional argument index.
-func RegisterLocalFilePathPositionalCompletion(cmd *cobra.Command, index int) {
-	if cmd == nil || index < 0 {
-		return
-	}
-	if cmd.ValidArgsFunction != nil {
-		return
-	}
-	cmd.ValidArgsFunction = func(_ *cobra.Command, args []string, _ string) ([]string, cobra.ShellCompDirective) {
-		if len(args) == index {
-			return nil, cobra.ShellCompDirectiveDefault
-		}
-		return nil, cobra.ShellCompDirectiveNoFileComp
-	}
-}
-
-// RegisterLocalFilePathPositionalAnyCompletion registers local file-path completion for all positional arguments.
-func RegisterLocalFilePathPositionalAnyCompletion(cmd *cobra.Command) {
-	if cmd == nil {
-		return
-	}
-	if cmd.ValidArgsFunction != nil {
-		return
-	}
-	cmd.ValidArgsFunction = func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
-		return nil, cobra.ShellCompDirectiveDefault
-	}
-}

client/command/crack/README.md

@@ -1,12 +0,0 @@
-# client/command/crack
-
-## Overview
-
-Implements the 'crack' command group for the Sliver client console. Handlers map Cobra invocations to crack workflows such as crack files.
-
-## Go Files
-
-- `commands.go` – Defines the crack command hierarchy, attaching operations for stations and file management.
-- `crack-files.go` – Manages cracking asset uploads, listings, and removals, handling streaming transfers and chunking.
-- `crack.go` – Implements station status reporting, health checks, and list rendering for distributed cracking nodes.
-- `helpers.go` – Supplies completion helpers and byte formatting utilities for crack subcommands.

client/command/crack/commands.go

@@ -1,7 +1,6 @@
 package crack
 
 import (
-	"github.com/bishopfox/sliver/client/command/completers"
 	"github.com/rsteube/carapace"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
@@ -25,7 +24,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 	}
 	flags.Bind("", true, crackCmd, func(f *pflag.FlagSet) {
 		f.Int64P("timeout", "t", flags.DefaultTimeout, "grpc timeout in seconds")
-		bindCrackFlags(f)
 	})
 
 	crackStationsCmd := &cobra.Command{
@@ -36,9 +34,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 			CrackStationsCmd(cmd, con, args)
 		},
 	}
-	flags.Bind("", false, crackStationsCmd, func(f *pflag.FlagSet) {
-		f.Bool("show-benchmarks", false, "show benchmark rates for crackstations")
-	})
 	crackCmd.AddCommand(crackStationsCmd)
 
 	wordlistsCmd := &cobra.Command{
@@ -62,7 +57,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		f.StringP("name", "n", "", "wordlist name (blank = filename)")
 	})
 	carapace.Gen(wordlistsAddCmd).PositionalCompletion(carapace.ActionFiles().Usage("path to local wordlist file"))
-	completers.RegisterLocalFilePathPositionalCompletion(wordlistsAddCmd, 0)
 	wordlistsCmd.AddCommand(wordlistsAddCmd)
 
 	wordlistsRmCmd := &cobra.Command{
@@ -97,7 +91,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		f.StringP("name", "n", "", "rules name (blank = filename)")
 	})
 	carapace.Gen(rulesAddCmd).PositionalCompletion(carapace.ActionFiles().Usage("path to local rules file"))
-	completers.RegisterLocalFilePathPositionalCompletion(rulesAddCmd, 0)
 	rulesCmd.AddCommand(rulesAddCmd)
 
 	rulesRmCmd := &cobra.Command{
@@ -133,7 +126,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		f.StringP("name", "n", "", "hcstat2 name (blank = filename)")
 	})
 	carapace.Gen(hcstat2AddCmd).PositionalCompletion(carapace.ActionFiles().Usage("path to local hcstat2 file"))
-	completers.RegisterLocalFilePathPositionalCompletion(hcstat2AddCmd, 0)
 	hcstat2Cmd.AddCommand(hcstat2AddCmd)
 
 	hcstat2RmCmd := &cobra.Command{

client/command/crack/crack-command.go

@@ -1,326 +0,0 @@
-package crack
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/bishopfox/sliver/protobuf/clientpb"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-)
-
-func shouldRunCrack(cmd *cobra.Command, args []string) bool {
-	if len(args) > 0 {
-		return true
-	}
-
-	hasFlag := false
-	cmd.Flags().VisitAll(func(flag *pflag.Flag) {
-		if flag.Changed && flag.Name != "timeout" {
-			hasFlag = true
-		}
-	})
-	return hasFlag
-}
-
-func buildCrackCommand(cmd *cobra.Command, args []string) (*clientpb.CrackCommand, error) {
-	flags := cmd.Flags()
-	req := &clientpb.CrackCommand{}
-
-	if flags.Changed("attack-mode") {
-		raw, _ := flags.GetString("attack-mode")
-		attackMode, err := parseCrackAttackMode(raw)
-		if err != nil {
-			return nil, err
-		}
-		req.AttackMode = attackMode
-	}
-
-	if flags.Changed("hash-type") {
-		raw, _ := flags.GetString("hash-type")
-		hashType, err := parseHashType(raw)
-		if err != nil {
-			return nil, err
-		}
-		req.HashType = hashType
-	}
-
-	hashes, _ := flags.GetStringSlice("hash")
-	if len(args) > 0 {
-		hashes = append(hashes, args...)
-	}
-	req.Hashes = hashes
-
-	req.Quiet, _ = flags.GetBool("quiet")
-	req.HexCharset, _ = flags.GetBool("hex-charset")
-	req.HexSalt, _ = flags.GetBool("hex-salt")
-	req.HexWordlist, _ = flags.GetBool("hex-wordlist")
-	req.Force, _ = flags.GetBool("force")
-	req.DeprecatedCheckDisable, _ = flags.GetBool("deprecated-check-disable")
-	req.Status, _ = flags.GetBool("status")
-	req.StatusJSON, _ = flags.GetBool("status-json")
-	req.StatusTimer, _ = flags.GetUint32("status-timer")
-	req.StdinTimeoutAbort, _ = flags.GetUint32("stdin-timeout-abort")
-	req.MachineReadable, _ = flags.GetBool("machine-readable")
-	req.KeepGuessing, _ = flags.GetBool("keep-guessing")
-	req.SelfTestDisable, _ = flags.GetBool("self-test-disable")
-	req.Loopback, _ = flags.GetBool("loopback")
-
-	if raw, _ := flags.GetString("markov-hcstat2"); raw != "" {
-		req.MarkovHcstat2 = []byte(raw)
-	}
-	req.MarkovDisable, _ = flags.GetBool("markov-disable")
-	req.MarkovClassic, _ = flags.GetBool("markov-classic")
-	req.MarkovInverse, _ = flags.GetBool("markov-inverse")
-	req.MarkovThreshold, _ = flags.GetUint32("markov-threshold")
-	req.Runtime, _ = flags.GetUint32("runtime")
-	req.Session, _ = flags.GetString("session")
-	req.Restore, _ = flags.GetBool("restore")
-	req.RestoreDisable, _ = flags.GetBool("restore-disable")
-	if raw, _ := flags.GetString("restore-file"); raw != "" {
-		req.RestoreFile = []byte(raw)
-	}
-
-	if formats, _ := flags.GetStringSlice("outfile-format"); len(formats) > 0 {
-		for _, raw := range formats {
-			format, err := parseCrackOutfileFormat(raw)
-			if err != nil {
-				return nil, err
-			}
-			req.OutfileFormat = append(req.OutfileFormat, format)
-		}
-	}
-	req.OutfileAutohexDisable, _ = flags.GetBool("outfile-autohex-disable")
-	req.OutfileCheckTimer, _ = flags.GetUint32("outfile-check-timer")
-	req.WordlistAutohexDisable, _ = flags.GetBool("wordlist-autohex-disable")
-	req.Separator, _ = flags.GetString("separator")
-	req.Stdout, _ = flags.GetBool("stdout")
-	req.Show, _ = flags.GetBool("show")
-	req.Left, _ = flags.GetBool("left")
-	req.Username, _ = flags.GetBool("username")
-	req.Remove, _ = flags.GetBool("remove")
-	req.RemoveTimer, _ = flags.GetUint32("remove-timer")
-	req.PotfileDisable, _ = flags.GetBool("potfile-disable")
-	if raw, _ := flags.GetString("potfile"); raw != "" {
-		req.Potfile = []byte(raw)
-	}
-
-	if flags.Changed("encoding-from") {
-		raw, _ := flags.GetString("encoding-from")
-		enc, err := parseCrackEncoding(raw)
-		if err != nil {
-			return nil, err
-		}
-		req.EncodingFrom = enc
-	}
-	if flags.Changed("encoding-to") {
-		raw, _ := flags.GetString("encoding-to")
-		enc, err := parseCrackEncoding(raw)
-		if err != nil {
-			return nil, err
-		}
-		req.EncodingTo = enc
-	}
-
-	req.DebugMode, _ = flags.GetUint32("debug-mode")
-	req.LogfileDisable, _ = flags.GetBool("logfile-disable")
-	req.HccapxMessagePair, _ = flags.GetUint32("hccapx-message-pair")
-	req.NonceErrorCorrections, _ = flags.GetUint32("nonce-error-corrections")
-	if raw, _ := flags.GetString("keyboard-layout-mapping"); raw != "" {
-		req.KeyboardLayoutMapping = []byte(raw)
-	}
-
-	req.Benchmark, _ = flags.GetBool("benchmark")
-	req.BenchmarkAll, _ = flags.GetBool("benchmark-all")
-	req.SpeedOnly, _ = flags.GetBool("speed-only")
-	req.ProgressOnly, _ = flags.GetBool("progress-only")
-	req.SegmentSize, _ = flags.GetUint32("segment-size")
-	req.BitmapMin, _ = flags.GetUint32("bitmap-min")
-	req.BitmapMax, _ = flags.GetUint32("bitmap-max")
-	req.CPUAffinity = uintSliceToUint32(flags, "cpu-affinity")
-	req.HookThreads, _ = flags.GetUint32("hook-threads")
-	req.HashInfo, _ = flags.GetBool("hash-info")
-	req.BackendIgnoreCUDA, _ = flags.GetBool("backend-ignore-cuda")
-	req.BackendIgnoreHip, _ = flags.GetBool("backend-ignore-hip")
-	req.BackendIgnoreMetal, _ = flags.GetBool("backend-ignore-metal")
-	req.BackendIgnoreOpenCL, _ = flags.GetBool("backend-ignore-opencl")
-	req.BackendInfo, _ = flags.GetBool("backend-info")
-	req.BackendDevices = uintSliceToUint32(flags, "backend-devices")
-	req.OpenCLDeviceTypes = uintSliceToUint32(flags, "opencl-device-types")
-	req.OptimizedKernelEnable, _ = flags.GetBool("optimized-kernel-enable")
-	req.MultiplyAccelDisabled, _ = flags.GetBool("multiply-accel-disabled")
-
-	if flags.Changed("workload-profile") {
-		raw, _ := flags.GetString("workload-profile")
-		profile, err := parseCrackWorkloadProfile(raw)
-		if err != nil {
-			return nil, err
-		}
-		req.WorkloadProfile = profile
-	}
-
-	req.KernelAccel, _ = flags.GetUint32("kernel-accel")
-	req.KernelLoops, _ = flags.GetUint32("kernel-loops")
-	req.KernelThreads, _ = flags.GetUint32("kernel-threads")
-	req.BackendVectorWidth, _ = flags.GetUint32("backend-vector-width")
-	req.SpinDamp, _ = flags.GetUint32("spin-damp")
-	req.HwmonDisable, _ = flags.GetBool("hwmon-disable")
-	req.HwmonTempAbort, _ = flags.GetUint32("hwmon-temp-abort")
-	req.ScryptTMTO, _ = flags.GetUint32("scrypt-tmto")
-	req.Skip, _ = flags.GetUint64("skip")
-	req.Limit, _ = flags.GetUint64("limit")
-	req.Keyspace, _ = flags.GetBool("keyspace")
-
-	if raw, _ := flags.GetString("rules-file"); raw != "" {
-		req.RulesFile = []byte(raw)
-	}
-	req.GenerateRules, _ = flags.GetUint32("generate-rules")
-	req.GenerateRulesFunMin, _ = flags.GetUint32("generate-rules-fun-min")
-	req.GenerateRulesFunMax, _ = flags.GetUint32("generate-rules-fun-max")
-	req.GenerateRulesFuncSel, _ = flags.GetString("generate-rules-func-sel")
-	req.GenerateRulesSeed, _ = flags.GetInt32("generate-rules-seed")
-	req.CustomCharset1, _ = flags.GetString("custom-charset1")
-	req.CustomCharset2, _ = flags.GetString("custom-charset2")
-	req.CustomCharset3, _ = flags.GetString("custom-charset3")
-	req.CustomCharset4, _ = flags.GetString("custom-charset4")
-	req.Identify, _ = flags.GetString("identify")
-	req.Increment, _ = flags.GetBool("increment")
-	req.IncrementMin, _ = flags.GetUint32("increment-min")
-	req.IncrementMax, _ = flags.GetUint32("increment-max")
-	req.SlowCandidates, _ = flags.GetBool("slow-candidates")
-	req.BrainServer, _ = flags.GetBool("brain-server")
-	req.BrainServerTimer, _ = flags.GetUint32("brain-server-timer")
-	req.BrainClient, _ = flags.GetBool("brain-client")
-	req.BrainClientFeatures, _ = flags.GetString("brain-client-features")
-	req.BrainHost, _ = flags.GetString("brain-host")
-	req.BrainPort, _ = flags.GetUint32("brain-port")
-	req.BrainPassword, _ = flags.GetString("brain-password")
-	req.BrainSession, _ = flags.GetString("brain-session")
-	req.BrainSessionWhitelist, _ = flags.GetString("brain-session-whitelist")
-
-	return req, nil
-}
-
-func uintSliceToUint32(flags *pflag.FlagSet, name string) []uint32 {
-	values, _ := flags.GetUintSlice(name)
-	if len(values) == 0 {
-		return nil
-	}
-	out := make([]uint32, len(values))
-	for i, value := range values {
-		out[i] = uint32(value)
-	}
-	return out
-}
-
-func parseCrackAttackMode(raw string) (clientpb.CrackAttackMode, error) {
-	if raw == "" {
-		return clientpb.CrackAttackMode_STRAIGHT, nil
-	}
-	if numeric, err := strconv.ParseInt(raw, 10, 32); err == nil {
-		return clientpb.CrackAttackMode(numeric), nil
-	}
-
-	normalized := strings.ToLower(strings.TrimSpace(raw))
-	normalized = strings.NewReplacer("-", "_", " ", "_").Replace(normalized)
-	switch normalized {
-	case "straight":
-		return clientpb.CrackAttackMode_STRAIGHT, nil
-	case "combination":
-		return clientpb.CrackAttackMode_COMBINATION, nil
-	case "bruteforce", "brute_force", "brute-force":
-		return clientpb.CrackAttackMode_BRUTEFORCE, nil
-	case "hybrid_wordlist_mask":
-		return clientpb.CrackAttackMode_HYBRID_WORDLIST_MASK, nil
-	case "hybrid_mask_wordlist":
-		return clientpb.CrackAttackMode_HYBRID_MASK_WORDLIST, nil
-	case "association":
-		return clientpb.CrackAttackMode_ASSOCIATION, nil
-	case "no_attack", "none":
-		return clientpb.CrackAttackMode_NO_ATTACK, nil
-	default:
-		return clientpb.CrackAttackMode_STRAIGHT, fmt.Errorf("unknown attack mode: %s", raw)
-	}
-}
-
-func parseHashType(raw string) (clientpb.HashType, error) {
-	if raw == "" {
-		return clientpb.HashType_MD5, nil
-	}
-	if numeric, err := strconv.ParseInt(raw, 10, 32); err == nil {
-		return clientpb.HashType(numeric), nil
-	}
-	key := normalizeEnumKey(raw)
-	if value, ok := clientpb.HashType_value[key]; ok {
-		return clientpb.HashType(value), nil
-	}
-	return clientpb.HashType_MD5, fmt.Errorf("unknown hash type: %s", raw)
-}
-
-func parseCrackEncoding(raw string) (clientpb.CrackEncoding, error) {
-	if raw == "" {
-		return clientpb.CrackEncoding_INVALID_ENCODING, nil
-	}
-	if numeric, err := strconv.ParseInt(raw, 10, 32); err == nil {
-		return clientpb.CrackEncoding(numeric), nil
-	}
-	key := normalizeEnumKey(raw)
-	if value, ok := clientpb.CrackEncoding_value[key]; ok {
-		return clientpb.CrackEncoding(value), nil
-	}
-	return clientpb.CrackEncoding_INVALID_ENCODING, fmt.Errorf("unknown encoding: %s", raw)
-}
-
-func parseCrackOutfileFormat(raw string) (clientpb.CrackOutfileFormat, error) {
-	if raw == "" {
-		return clientpb.CrackOutfileFormat_INVALID_FORMAT, nil
-	}
-	if numeric, err := strconv.ParseInt(raw, 10, 32); err == nil {
-		return clientpb.CrackOutfileFormat(numeric), nil
-	}
-	key := normalizeEnumKey(raw)
-	if value, ok := clientpb.CrackOutfileFormat_value[key]; ok {
-		return clientpb.CrackOutfileFormat(value), nil
-	}
-	return clientpb.CrackOutfileFormat_INVALID_FORMAT, fmt.Errorf("unknown outfile format: %s", raw)
-}
-
-func parseCrackWorkloadProfile(raw string) (clientpb.CrackWorkloadProfile, error) {
-	if raw == "" {
-		return clientpb.CrackWorkloadProfile_INVALID_WORKLOAD_PROFILE, nil
-	}
-	if numeric, err := strconv.ParseInt(raw, 10, 32); err == nil {
-		return clientpb.CrackWorkloadProfile(numeric), nil
-	}
-	key := normalizeEnumKey(raw)
-	if value, ok := clientpb.CrackWorkloadProfile_value[key]; ok {
-		return clientpb.CrackWorkloadProfile(value), nil
-	}
-	return clientpb.CrackWorkloadProfile_INVALID_WORKLOAD_PROFILE, fmt.Errorf("unknown workload profile: %s", raw)
-}
-
-func normalizeEnumKey(value string) string {
-	if value == "" {
-		return ""
-	}
-	var builder strings.Builder
-	builder.Grow(len(value))
-	underscore := false
-	for i := 0; i < len(value); i++ {
-		ch := value[i]
-		if (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') {
-			if ch >= 'a' && ch <= 'z' {
-				ch -= 'a' - 'A'
-			}
-			builder.WriteByte(ch)
-			underscore = false
-			continue
-		}
-		if !underscore {
-			builder.WriteByte('_')
-			underscore = true
-		}
-	}
-	return strings.Trim(builder.String(), "_")
-}

client/command/crack/crack-files.go

@@ -106,17 +106,17 @@ func PrintCrackFiles(crackFiles *clientpb.CrackFiles, con *console.SliverClient)
 
 func PrintCrackFilesByType(crackFiles *clientpb.CrackFiles, con *console.SliverClient) {
 	wordlistTable := table.NewWriter()
-	wordlistTable.SetTitle(console.StyleBold.Render("Wordlists"))
+	wordlistTable.SetTitle(console.Bold + "Wordlists" + console.Normal)
 	wordlistTable.SetStyle(settings.GetTableStyle(con))
 	wordlistTable.AppendHeader(table.Row{"Name", "Size"})
 
 	rulesTable := table.NewWriter()
-	rulesTable.SetTitle(console.StyleBold.Render("Rules"))
+	rulesTable.SetTitle(console.Bold + "Rules" + console.Normal)
 	rulesTable.SetStyle(settings.GetTableStyle(con))
 	rulesTable.AppendHeader(table.Row{"Name", "Size"})
 
 	hcTable := table.NewWriter()
-	hcTable.SetTitle(console.StyleBold.Render("Markov Hcstat2"))
+	hcTable.SetTitle(console.Bold + "Markov Hcstat2" + console.Normal)
 	hcTable.SetStyle(settings.GetTableStyle(con))
 	hcTable.AppendHeader(table.Row{"Name", "Size"})
 

client/command/crack/crack-flags.go

@@ -1,108 +0,0 @@
-package crack
-
-import "github.com/spf13/pflag"
-
-func bindCrackFlags(f *pflag.FlagSet) {
-	f.String("attack-mode", "", "crack attack mode (straight, combination, bruteforce, hybrid-wordlist-mask, hybrid-mask-wordlist, association, no-attack, or numeric)")
-	f.String("hash-type", "", "hashcat hash type (number or enum name)")
-	f.StringSlice("hash", nil, "hashes to crack (repeatable)")
-	f.Bool("quiet", false, "quiet mode")
-	f.Bool("hex-charset", false, "treat charset as hex")
-	f.Bool("hex-salt", false, "treat salt as hex")
-	f.Bool("hex-wordlist", false, "treat wordlist as hex")
-	f.Bool("force", false, "ignore warnings")
-	f.Bool("deprecated-check-disable", false, "disable deprecated check")
-	f.Bool("status", false, "enable status")
-	f.Bool("status-json", false, "emit status in JSON")
-	f.Uint32("status-timer", 0, "status timer interval (seconds)")
-	f.Uint32("stdin-timeout-abort", 0, "abort after stdin timeout (seconds)")
-	f.Bool("machine-readable", false, "machine readable output")
-	f.Bool("keep-guessing", false, "keep guessing")
-	f.Bool("self-test-disable", false, "disable self-test")
-	f.Bool("loopback", false, "use loopback mode")
-	f.String("markov-hcstat2", "", "markov hcstat2 filename or identifier")
-	f.Bool("markov-disable", false, "disable markov mode")
-	f.Bool("markov-classic", false, "use classic markov")
-	f.Bool("markov-inverse", false, "use inverse markov")
-	f.Uint32("markov-threshold", 0, "markov threshold")
-	f.Uint32("runtime", 0, "runtime in seconds")
-	f.String("session", "", "session name")
-	f.Bool("restore", false, "restore session")
-	f.Bool("restore-disable", false, "disable restore")
-	f.String("restore-file", "", "restore file path or identifier")
-	f.StringSlice("outfile-format", nil, "outfile formats (hash-salt, plain, hex-plain, crack-pos, timestamp-absolute, timestamp-relative, or numeric)")
-	f.Bool("outfile-autohex-disable", false, "disable outfile autohex")
-	f.Uint32("outfile-check-timer", 0, "outfile check timer interval (seconds)")
-	f.Bool("wordlist-autohex-disable", false, "disable wordlist autohex")
-	f.String("separator", "", "separator character")
-	f.Bool("stdout", false, "stdout output")
-	f.Bool("show", false, "show cracked hashes")
-	f.Bool("left", false, "show uncracked hashes")
-	f.Bool("username", false, "enable username handling")
-	f.Bool("remove", false, "remove cracked hashes")
-	f.Uint32("remove-timer", 0, "remove timer interval (seconds)")
-	f.Bool("potfile-disable", false, "disable potfile")
-	f.String("potfile", "", "potfile path or identifier")
-	f.String("encoding-from", "", "input encoding (iso-8859-15, utf-32le, or numeric)")
-	f.String("encoding-to", "", "output encoding (iso-8859-15, utf-32le, or numeric)")
-	f.Uint32("debug-mode", 0, "debug mode mask")
-	f.Bool("logfile-disable", false, "disable logfile")
-	f.Uint32("hccapx-message-pair", 0, "hccapx message pair")
-	f.Uint32("nonce-error-corrections", 0, "nonce error corrections")
-	f.String("keyboard-layout-mapping", "", "keyboard layout mapping file or identifier")
-	f.Bool("benchmark", false, "run benchmark")
-	f.Bool("benchmark-all", false, "run full benchmark")
-	f.Bool("speed-only", false, "show speed only")
-	f.Bool("progress-only", false, "show progress only")
-	f.Uint32("segment-size", 0, "segment size")
-	f.Uint32("bitmap-min", 0, "bitmap min")
-	f.Uint32("bitmap-max", 0, "bitmap max")
-	f.UintSlice("cpu-affinity", nil, "CPU affinity list")
-	f.Uint32("hook-threads", 0, "hook threads")
-	f.Bool("hash-info", false, "show hash information")
-	f.Bool("backend-ignore-cuda", false, "ignore CUDA backend")
-	f.Bool("backend-ignore-hip", false, "ignore HIP backend")
-	f.Bool("backend-ignore-metal", false, "ignore Metal backend")
-	f.Bool("backend-ignore-opencl", false, "ignore OpenCL backend")
-	f.Bool("backend-info", false, "show backend info")
-	f.UintSlice("backend-devices", nil, "backend device IDs")
-	f.UintSlice("opencl-device-types", nil, "OpenCL device types")
-	f.Bool("optimized-kernel-enable", false, "enable optimized kernels")
-	f.Bool("multiply-accel-disabled", false, "disable multiply accel")
-	f.String("workload-profile", "", "workload profile (low, default, high, nightmare, or numeric)")
-	f.Uint32("kernel-accel", 0, "kernel acceleration")
-	f.Uint32("kernel-loops", 0, "kernel loops")
-	f.Uint32("kernel-threads", 0, "kernel threads")
-	f.Uint32("backend-vector-width", 0, "backend vector width")
-	f.Uint32("spin-damp", 0, "spin damp")
-	f.Bool("hwmon-disable", false, "disable hardware monitoring")
-	f.Uint32("hwmon-temp-abort", 0, "hardware monitor temperature abort")
-	f.Uint32("scrypt-tmto", 0, "scrypt tmto")
-	f.Uint64("skip", 0, "skip count")
-	f.Uint64("limit", 0, "limit count")
-	f.Bool("keyspace", false, "show keyspace")
-	f.String("rules-file", "", "rules file path or identifier")
-	f.Uint32("generate-rules", 0, "generate rules")
-	f.Uint32("generate-rules-fun-min", 0, "generate rules function min")
-	f.Uint32("generate-rules-fun-max", 0, "generate rules function max")
-	f.String("generate-rules-func-sel", "", "generate rules function selection")
-	f.Int32("generate-rules-seed", 0, "generate rules seed")
-	f.String("custom-charset1", "", "custom charset 1")
-	f.String("custom-charset2", "", "custom charset 2")
-	f.String("custom-charset3", "", "custom charset 3")
-	f.String("custom-charset4", "", "custom charset 4")
-	f.String("identify", "", "identify hash")
-	f.Bool("increment", false, "incremental mode")
-	f.Uint32("increment-min", 0, "increment min")
-	f.Uint32("increment-max", 0, "increment max")
-	f.Bool("slow-candidates", false, "slow candidates")
-	f.Bool("brain-server", false, "brain server mode")
-	f.Uint32("brain-server-timer", 0, "brain server timer")
-	f.Bool("brain-client", false, "brain client mode")
-	f.String("brain-client-features", "", "brain client features")
-	f.String("brain-host", "", "brain host")
-	f.Uint32("brain-port", 0, "brain port")
-	f.String("brain-password", "", "brain password")
-	f.String("brain-session", "", "brain session")
-	f.String("brain-session-whitelist", "", "brain session whitelist")
-}

client/command/crack/crack.go

@@ -22,7 +22,6 @@ import (
 	"context"
 	"fmt"
 	"sort"
-	"time"
 
 	"github.com/jedib0t/go-pretty/v6/table"
 	"github.com/spf13/cobra"
@@ -35,37 +34,6 @@ import (
 
 // CrackCmd - GPU password cracking interface
 func CrackCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
-	if shouldRunCrack(cmd, args) {
-		crackCmd, err := buildCrackCommand(cmd, args)
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-
-		timeoutSeconds, _ := cmd.Flags().GetInt64("timeout")
-		ctx := context.Background()
-		if timeoutSeconds > 0 {
-			var cancel context.CancelFunc
-			ctx, cancel = context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)
-			defer cancel()
-		}
-
-		resp, err := con.Rpc.Crack(ctx, crackCmd)
-		if err != nil {
-			con.PrintErrorf("%s\n", err)
-			return
-		}
-		if resp == nil || resp.Job == nil {
-			con.PrintInfof("Crack request submitted\n")
-			return
-		}
-		con.PrintInfof("Crack job %s created (status: %s)\n", resp.Job.ID, resp.Job.Status.String())
-		if resp.Job.Err != "" {
-			con.PrintErrorf("Crack job error: %s\n", resp.Job.Err)
-		}
-		return
-	}
-
 	if !AreCrackersOnline(con) {
 		PrintNoCrackstations(con)
 	} else {
@@ -96,11 +64,10 @@ func CrackStationsCmd(cmd *cobra.Command, con *console.SliverClient, args []stri
 		con.PrintErrorf("%s\n", err)
 		return
 	}
-	showBenchmarks, _ := cmd.Flags().GetBool("show-benchmarks")
 	if len(crackers.Crackstations) == 0 {
 		PrintNoCrackstations(con)
 	} else {
-		PrintCrackers(crackers.Crackstations, con, showBenchmarks)
+		PrintCrackers(crackers.Crackstations, con)
 	}
 }
 
@@ -116,12 +83,12 @@ func AreCrackersOnline(con *console.SliverClient) bool {
 	return len(crackers.Crackstations) > 0
 }
 
-func PrintCrackers(crackers []*clientpb.Crackstation, con *console.SliverClient, showBenchmarks bool) {
+func PrintCrackers(crackers []*clientpb.Crackstation, con *console.SliverClient) {
 	sort.Slice(crackers, func(i, j int) bool {
 		return crackers[i].Name < crackers[j].Name
 	})
 	for index, cracker := range crackers {
-		printCracker(cracker, index, con, showBenchmarks)
+		printCracker(cracker, index, con)
 		if index < len(crackers)-1 {
 			con.Println()
 			con.Println()
@@ -129,63 +96,53 @@ func PrintCrackers(crackers []*clientpb.Crackstation, con *console.SliverClient,
 	}
 }
 
-func printCracker(cracker *clientpb.Crackstation, index int, con *console.SliverClient, showBenchmarks bool) {
+func printCracker(cracker *clientpb.Crackstation, index int, con *console.SliverClient) {
 	tw := table.NewWriter()
 	tw.SetStyle(settings.GetTableStyle(con))
-	tw.SetTitle(console.StyleBoldOrange.Render(fmt.Sprintf(">>> Crackstation %02d - %s (%s)", index+1, cracker.Name, cracker.OperatorName)) + "\n")
+	tw.SetTitle(console.Bold + console.Orange + fmt.Sprintf(">>> Crackstation %02d - %s (%s)", index+1, cracker.Name, cracker.OperatorName) + console.Normal + "\n")
 	tw.AppendSeparator()
-	tw.AppendRow(table.Row{console.StyleBold.Render("Operating System"), fmt.Sprintf("%s/%s", cracker.GOOS, cracker.GOARCH)})
-	tw.AppendRow(table.Row{console.StyleBold.Render("Hashcat Version"), cracker.HashcatVersion})
+	tw.AppendRow(table.Row{console.Bold + "Operating System" + console.Normal, fmt.Sprintf("%s/%s", cracker.GOOS, cracker.GOARCH)})
+	tw.AppendRow(table.Row{console.Bold + "Hashcat Version" + console.Normal, cracker.HashcatVersion})
 	if 0 < len(cracker.CUDA) {
 		for _, cuda := range cracker.CUDA {
 			tw.AppendSeparator()
-			tw.AppendRow(table.Row{console.StyleBold.Render("CUDA Device"), console.StyleBoldGreen.Render(fmt.Sprintf("%s (%s)", cuda.Name, cuda.Version))})
-			tw.AppendRow(table.Row{console.StyleBold.Render("Memory"), fmt.Sprintf("%s free of %s", cuda.MemoryFree, cuda.MemoryTotal)})
-			tw.AppendRow(table.Row{console.StyleBold.Render("Clock"), fmt.Sprintf("%d", cuda.Clock)})
-			tw.AppendRow(table.Row{console.StyleBold.Render("Processors"), fmt.Sprintf("%d", cuda.Processors)})
+			tw.AppendRow(table.Row{console.Bold + "CUDA Device" + console.Normal, fmt.Sprintf(console.Bold+console.Green+"%s (%s)"+console.Normal, cuda.Name, cuda.Version)})
+			tw.AppendRow(table.Row{console.Bold + "Memory" + console.Normal, fmt.Sprintf("%s free of %s", cuda.MemoryFree, cuda.MemoryTotal)})
+			tw.AppendRow(table.Row{console.Bold + "Clock" + console.Normal, fmt.Sprintf("%d", cuda.Clock)})
+			tw.AppendRow(table.Row{console.Bold + "Processors" + console.Normal, fmt.Sprintf("%d", cuda.Processors)})
 		}
 	}
 	if 0 < len(cracker.Metal) {
 		for _, metal := range cracker.Metal {
 			tw.AppendSeparator()
-			tw.AppendRow(table.Row{console.StyleBold.Render("Metal Device"), console.StyleBoldGreen.Render(fmt.Sprintf("%s (%s)", metal.Name, metal.Version))})
-			tw.AppendRow(table.Row{console.StyleBold.Render("Memory"), fmt.Sprintf("%s free of %s", metal.MemoryFree, metal.MemoryTotal)})
-			tw.AppendRow(table.Row{console.StyleBold.Render("Clock"), fmt.Sprintf("%d", metal.Clock)})
-			tw.AppendRow(table.Row{console.StyleBold.Render("Processors"), fmt.Sprintf("%d", metal.Processors)})
+			tw.AppendRow(table.Row{console.Bold + "Metal Device" + console.Normal, fmt.Sprintf(console.Bold+console.Green+"%s (%s)"+console.Normal, metal.Name, metal.Version)})
+			tw.AppendRow(table.Row{console.Bold + "Memory" + console.Normal, fmt.Sprintf("%s free of %s", metal.MemoryFree, metal.MemoryTotal)})
+			tw.AppendRow(table.Row{console.Bold + "Clock" + console.Normal, fmt.Sprintf("%d", metal.Clock)})
+			tw.AppendRow(table.Row{console.Bold + "Processors" + console.Normal, fmt.Sprintf("%d", metal.Processors)})
 		}
 	}
 	if 0 < len(cracker.OpenCL) {
 		for _, openCL := range cracker.OpenCL {
 			tw.AppendSeparator()
-			tw.AppendRow(table.Row{console.StyleBold.Render("OpenCL Device"), console.StyleBoldGreen.Render(fmt.Sprintf("%s (%s)", openCL.Name, openCL.Version))})
-			tw.AppendRow(table.Row{console.StyleBold.Render("Memory"), fmt.Sprintf("%s free of %s", openCL.MemoryFree, openCL.MemoryTotal)})
-			tw.AppendRow(table.Row{console.StyleBold.Render("Clock"), fmt.Sprintf("%d", openCL.Clock)})
-			tw.AppendRow(table.Row{console.StyleBold.Render("Processors"), fmt.Sprintf("%d", openCL.Processors)})
+			tw.AppendRow(table.Row{console.Bold + "OpenCL Device" + console.Normal, fmt.Sprintf(console.Bold+console.Green+console.Bold+"%s (%s)"+console.Normal, openCL.Name, openCL.Version)})
+			tw.AppendRow(table.Row{console.Bold + "Memory" + console.Normal, fmt.Sprintf("%s free of %s", openCL.MemoryFree, openCL.MemoryTotal)})
+			tw.AppendRow(table.Row{console.Bold + "Clock" + console.Normal, fmt.Sprintf("%d", openCL.Clock)})
+			tw.AppendRow(table.Row{console.Bold + "Processors" + console.Normal, fmt.Sprintf("%d", openCL.Processors)})
 		}
 	}
 	con.Printf("%s\n", tw.Render())
-	if showBenchmarks {
-		con.Println()
-		printBenchmarks(cracker, con)
-	}
+	con.Println()
+	printBenchmarks(cracker, con)
 }
 
 func printBenchmarks(cracker *clientpb.Crackstation, con *console.SliverClient) {
 	tw := table.NewWriter()
 	tw.SetStyle(settings.GetTableStyle(con))
-	tw.SetTitle(console.StyleBold.Render("Benchmarks"))
+	tw.SetTitle(console.Bold + "Benchmarks" + console.Normal)
 	tw.SortBy([]table.SortBy{{Name: "Hash Type"}})
-	tw.AppendHeader(table.Row{"Hash Type", "Rate"})
-	if len(cracker.Benchmarks) == 0 {
-		tw.AppendRow(table.Row{"No benchmarks reported", "-"})
-	} else {
-		for hashType, speed := range cracker.Benchmarks {
-			name, ok := hashcatHashTypeName(hashType)
-			if !ok {
-				name = clientpb.HashType(hashType).String()
-			}
-			tw.AppendRow(table.Row{name, humanizeHashRate(speed)})
-		}
+	tw.AppendHeader(table.Row{"Hash Type", "Rate (H/s)"})
+	for hashType, speed := range cracker.Benchmarks {
+		tw.AppendRow(table.Row{clientpb.HashType(hashType), fmt.Sprintf("%d", speed)})
 	}
 	con.Printf("%s\n", tw.Render())
 }

client/command/crack/hashcat_types.go

@@ -1,419 +0,0 @@
-package crack
-
-import "fmt"
-
-// Hashcat mode names sourced from client/credentials/EXAMPLES.md.
-var hashcatHashTypes = map[int32]string{
-	0:     "MD5",
-	10:    "md5($pass.$salt)",
-	11:    "Joomla < 2.5.18",
-	12:    "PostgreSQL",
-	20:    "md5($salt.$pass)",
-	21:    "osCommerce, xt:Commerce",
-	22:    "Juniper NetScreen/SSG (ScreenOS)",
-	23:    "Skype",
-	24:    "SolarWinds Serv-U",
-	30:    "md5(utf16le($pass).$salt)",
-	40:    "md5($salt.utf16le($pass))",
-	50:    "HMAC-MD5 (key = $pass)",
-	60:    "HMAC-MD5 (key = $salt)",
-	70:    "md5(utf16le($pass))",
-	100:   "SHA1",
-	101:   "nsldap, SHA-1(Base64), Netscape LDAP SHA",
-	110:   "sha1($pass.$salt)",
-	111:   "nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
-	112:   "Oracle S: Type (Oracle 11+)",
-	120:   "sha1($salt.$pass)",
-	121:   "SMF (Simple Machines Forum) > v1.1",
-	122:   "macOS v10.4, macOS v10.5, macOS v10.6",
-	123:   "EPi",
-	124:   "Django (SHA-1)",
-	125:   "ArubaOS",
-	130:   "sha1(utf16le($pass).$salt)",
-	131:   "MSSQL (2000)",
-	132:   "MSSQL (2005)",
-	133:   "PeopleSoft",
-	140:   "sha1($salt.utf16le($pass))",
-	141:   "Episerver 6.x < .NET 4",
-	150:   "HMAC-SHA1 (key = $pass)",
-	160:   "HMAC-SHA1 (key = $salt)",
-	170:   "sha1(utf16le($pass))",
-	190:   "sha1(LinkedIn)",
-	200:   "MySQL323",
-	300:   "MySQL4.1/MySQL5",
-	400:   "phpass, phpBB3 (MD5)",
-	500:   "md5crypt, MD5 (Unix), Cisco-IOS $1$ (MD5)",
-	501:   "Juniper IVE",
-	600:   "BLAKE2b-512",
-	900:   "MD4",
-	1000:  "NTLM",
-	1100:  "Domain Cached Credentials (DCC), MS Cache",
-	1300:  "SHA2-224",
-	1400:  "SHA2-256",
-	1410:  "sha256($pass.$salt)",
-	1411:  "SSHA-256(Base64), LDAP {SSHA256}",
-	1420:  "sha256($salt.$pass)",
-	1421:  "hMailServer",
-	1430:  "sha256(utf16le($pass).$salt)",
-	1431:  "base64(sha256(unicode($pass)))",
-	1440:  "sha256($salt.utf16le($pass))",
-	1441:  "Episerver 6.x >= .NET 4",
-	1450:  "HMAC-SHA256 (key = $pass)",
-	1460:  "HMAC-SHA256 (key = $salt)",
-	1470:  "sha256(utf16le($pass))",
-	1500:  "descrypt, DES (Unix), Traditional DES",
-	1600:  "Apache $apr1$ MD5, md5apr1, MD5 (APR)",
-	1700:  "SHA2-512",
-	1710:  "sha512($pass.$salt)",
-	1711:  "SSHA-512(Base64), LDAP {SSHA512}",
-	1720:  "sha512($salt.$pass)",
-	1722:  "macOS v10.7",
-	1730:  "sha512(utf16le($pass).$salt)",
-	1731:  "MSSQL (2012, 2014)",
-	1740:  "sha512($salt.utf16le($pass))",
-	1750:  "HMAC-SHA512 (key = $pass)",
-	1760:  "HMAC-SHA512 (key = $salt)",
-	1770:  "sha512(utf16le($pass))",
-	1800:  "sha512crypt $6$, SHA512 (Unix)",
-	2000:  "STDOUT",
-	2100:  "Domain Cached Credentials 2 (DCC2), MS Cache 2",
-	2400:  "Cisco-PIX MD5",
-	2410:  "Cisco-ASA MD5",
-	2500:  "WPA-EAPOL-PBKDF2",
-	2501:  "WPA-EAPOL-PMK",
-	2600:  "md5(md5($pass))",
-	2611:  "vBulletin < v3.8.5",
-	2612:  "PHPS",
-	2711:  "vBulletin >= v3.8.5",
-	2811:  "MyBB 1.2+, IPB2+ (Invision Power Board)",
-	3000:  "LM",
-	3100:  "Oracle H: Type (Oracle 7+)",
-	3200:  "bcrypt $2\\*$, Blowfish (Unix)",
-	3300:  "MD5(Sun)",
-	3500:  "md5(md5(md5($pass)))",
-	3610:  "md5(md5($salt).$pass )",
-	3710:  "md5($salt.md5($pass))",
-	3711:  "MediaWiki B type",
-	3720:  "md5($pass.md5($salt))",
-	3721:  "WebEdition CMS",
-	3800:  "md5($salt.$pass.$salt)",
-	3910:  "md5(md5($pass).md5($salt))",
-	4010:  "md5($salt.md5($salt.$pass))",
-	4110:  "md5($salt.md5($pass.$salt))",
-	4210:  "md5($username.0.$pass)",
-	4300:  "md5(strtoupper(md5($pass)))",
-	4400:  "md5(sha1($pass))",
-	4500:  "sha1(sha1($pass))",
-	4510:  "sha1(sha1($pass).$salt)",
-	4520:  "sha1($salt.sha1($pass))",
-	4521:  "Redmine",
-	4522:  "PunBB",
-	4600:  "sha1(sha1(sha1($pass)))",
-	4700:  "sha1(md5($pass))",
-	4710:  "sha1(md5($pass).$salt)",
-	4711:  "Huawei sha1(md5($pass).$salt)",
-	4800:  "iSCSI CHAP authentication, MD5(CHAP)",
-	4900:  "sha1($salt.$pass.$salt)",
-	5000:  "sha1(sha1($salt.$pass.$salt))",
-	5100:  "Half MD5",
-	5200:  "Password Safe v3",
-	5300:  "IKE-PSK MD5",
-	5400:  "IKE-PSK SHA1",
-	5500:  "NetNTLMv1 / NetNTLMv1+ESS",
-	5600:  "NetNTLMv2",
-	5700:  "Cisco-IOS type 4 (SHA256)",
-	5800:  "Samsung Android Password/PIN",
-	6000:  "RIPEMD-160",
-	6100:  "Whirlpool",
-	6211:  "TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + AES / TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + Serpent / TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + Twofish",
-	6212:  "TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + AES-Twofish / TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + Serpent-AES / TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + Twofish-Serpent",
-	6213:  "TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + AES-Twofish-Serpent / TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + Serpent-Twofish-AES",
-	6221:  "TrueCrypt 5.0+ SHA512 + AES / TrueCrypt 5.0+ SHA512 + Serpent / TrueCrypt 5.0+ SHA512 + Twofish",
-	6222:  "TrueCrypt 5.0+ SHA512 + AES-Twofish / TrueCrypt 5.0+ SHA512 + Serpent-AES / TrueCrypt 5.0+ SHA512 + Twofish-Serpent",
-	6223:  "TrueCrypt 5.0+ SHA512 + AES-Twofish-Serpent / TrueCrypt 5.0+ SHA512 + Serpent-Twofish-AES",
-	6231:  "TrueCrypt 5.0+ Whirlpool + AES / TrueCrypt 5.0+ Whirlpool + Serpent / TrueCrypt 5.0+ Whirlpool + Twofish",
-	6232:  "TrueCrypt 5.0+ Whirlpool + AES-Twofish / TrueCrypt 5.0+ Whirlpool + Serpent-AES / TrueCrypt 5.0+ Whirlpool + Twofish-Serpent",
-	6233:  "TrueCrypt 5.0+ Whirlpool + AES-Twofish-Serpent / TrueCrypt 5.0+ Whirlpool + Serpent-Twofish-AES",
-	6241:  "TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + AES + boot / TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + Serpent + boot / TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + Twofish + boot",
-	6242:  "TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + AES-Twofish + boot / TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + Serpent-AES + boot / TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + Twofish-Serpent + boot",
-	6243:  "TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + AES-Twofish-Serpent + boot / TrueCrypt 5.0+ PBKDF2-HMAC-RIPEMD160 + Serpent-Twofish-AES + boot",
-	6300:  "AIX {smd5}",
-	6400:  "AIX {ssha256}",
-	6500:  "AIX {ssha512}",
-	6600:  "1Password, agilekeychain",
-	6700:  "AIX {ssha1}",
-	6800:  "LastPass + LastPass sniffed",
-	6900:  "GOST R 34.11-94",
-	7000:  "FortiGate (FortiOS)",
-	7100:  "macOS v10.8+ (PBKDF2-SHA512)",
-	7200:  "GRUB 2",
-	7300:  "IPMI2 RAKP HMAC-SHA1",
-	7400:  "sha256crypt $5$, SHA256 (Unix)",
-	7401:  "MySQL $A$ (sha256crypt)",
-	7500:  "Kerberos 5, etype 23, AS-REQ Pre-Auth",
-	7700:  "SAP CODVN B (BCODE)",
-	7701:  "SAP CODVN B (BCODE) from RFC_READ_TABLE",
-	7800:  "SAP CODVN F/G (PASSCODE)",
-	7801:  "SAP CODVN F/G (PASSCODE) from RFC_READ_TABLE",
-	7900:  "Drupal7",
-	8000:  "Sybase ASE",
-	8100:  "Citrix NetScaler (SHA1)",
-	8200:  "1Password, cloudkeychain",
-	8300:  "DNSSEC (NSEC3)",
-	8400:  "WBB3 (Woltlab Burning Board)",
-	8500:  "RACF",
-	8600:  "Lotus Notes/Domino 5",
-	8700:  "Lotus Notes/Domino 6",
-	8800:  "Android FDE <= 4.3",
-	8900:  "scrypt",
-	9000:  "Password Safe v2",
-	9100:  "Lotus Notes/Domino 8",
-	9200:  "Cisco-IOS $8$ (PBKDF2-SHA256)",
-	9300:  "Cisco-IOS $9$ (scrypt)",
-	9400:  "MS Office 2007",
-	9500:  "MS Office 2010",
-	9600:  "MS Office 2013",
-	9700:  "MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
-	9710:  "MS Office <= 2003 $0/$1, MD5 + RC4, collider #1",
-	9720:  "MS Office <= 2003 $0/$1, MD5 + RC4, collider #2",
-	9800:  "MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
-	9810:  "MS Office <= 2003 $3, SHA1 + RC4, collider #1",
-	9820:  "MS Office <= 2003 $3, SHA1 + RC4, collider #2",
-	9900:  "Radmin2",
-	10000: "Django (PBKDF2-SHA256)",
-	10100: "SipHash",
-	10200: "CRAM-MD5",
-	10300: "SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
-	10400: "PDF 1.1 - 1.3 (Acrobat 2 - 4)",
-	10410: "PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1",
-	10420: "PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2",
-	10500: "PDF 1.4 - 1.6 (Acrobat 5 - 8)",
-	10600: "PDF 1.7 Level 3 (Acrobat 9)",
-	10700: "PDF 1.7 Level 8 (Acrobat 10 - 11)",
-	10800: "SHA2-384",
-	10810: "sha384($pass.$salt)",
-	10820: "sha384($salt.$pass)",
-	10830: "sha384(utf16le($pass).$salt)",
-	10840: "sha384($salt.utf16le($pass))",
-	10870: "sha384(utf16le($pass))",
-	10900: "PBKDF2-HMAC-SHA256",
-	10901: "RedHat 389-DS LDAP (PBKDF2-HMAC-SHA256)",
-	11000: "PrestaShop",
-	11100: "PostgreSQL CRAM (MD5)",
-	11200: "MySQL CRAM (SHA1)",
-	11300: "Bitcoin/Litecoin wallet.dat",
-	11400: "SIP digest authentication (MD5)",
-	11500: "CRC32",
-	11600: "7-Zip",
-	11700: "GOST R 34.11-2012 (Streebog) 256-bit, big-endian",
-	11750: "HMAC-Streebog-256 (key = $pass), big-endian",
-	11760: "HMAC-Streebog-256 (key = $salt), big-endian",
-	11800: "GOST R 34.11-2012 (Streebog) 512-bit, big-endian",
-	11850: "HMAC-Streebog-512 (key = $pass), big-endian",
-	11860: "HMAC-Streebog-512 (key = $salt), big-endian",
-	11900: "PBKDF2-HMAC-MD5",
-	12000: "PBKDF2-HMAC-SHA1",
-	12001: "Atlassian (PBKDF2-HMAC-SHA1)",
-	12100: "PBKDF2-HMAC-SHA512",
-	12200: "eCryptfs",
-	12300: "Oracle T: Type (Oracle 12+)",
-	12400: "BSDi Crypt, Extended DES",
-	12500: "RAR3-hp",
-	12600: "ColdFusion 10+",
-	12700: "Blockchain, My Wallet",
-	12800: "MS-AzureSync PBKDF2-HMAC-SHA256",
-	12900: "Android FDE (Samsung DEK)",
-	13000: "RAR5",
-	13100: "Kerberos 5, etype 23, TGS-REP",
-	13200: "AxCrypt 1",
-	13300: "AxCrypt 1 in-memory SHA1",
-	13400: "KeePass 1 AES / without keyfile / KeePass 2 AES / without keyfile / KeePass 1 Twofish / with keyfile / Keepass 2 AES / with keyfile",
-	13500: "PeopleSoft PS_TOKEN",
-	13600: "WinZip",
-	13711: "VeraCrypt PBKDF2-HMAC-RIPEMD160 + AES / VeraCrypt PBKDF2-HMAC-RIPEMD160 + Serpent / VeraCrypt PBKDF2-HMAC-RIPEMD160 + Twofish",
-	13712: "VeraCrypt PBKDF2-HMAC-RIPEMD160 + AES-Twofish / VeraCrypt PBKDF2-HMAC-RIPEMD160 + Serpent-AES / VeraCrypt PBKDF2-HMAC-RIPEMD160 + Twofish-Serpent",
-	13713: "VeraCrypt PBKDF2-HMAC-RIPEMD160 + Serpent-Twofish-AES",
-	13721: "VeraCrypt PBKDF2-HMAC-SHA512 + AES / VeraCrypt PBKDF2-HMAC-SHA512 + Serpent / VeraCrypt PBKDF2-HMAC-SHA512 + Twofish",
-	13722: "VeraCrypt PBKDF2-HMAC-SHA512 + AES-Twofish / VeraCrypt PBKDF2-HMAC-SHA512 + Serpent-AES / VeraCrypt PBKDF2-HMAC-SHA512 + Twofish-Serpent",
-	13723: "VeraCrypt PBKDF2-HMAC-SHA512 + Serpent-Twofish-AES",
-	13731: "VeraCrypt PBKDF2-HMAC-Whirlpool + AES / VeraCrypt PBKDF2-HMAC-Whirlpool + Serpent / VeraCrypt PBKDF2-HMAC-Whirlpool + Twofish",
-	13732: "VeraCrypt PBKDF2-HMAC-Whirlpool + AES-Twofish / VeraCrypt PBKDF2-HMAC-Whirlpool + Serpent-AES / VeraCrypt PBKDF2-HMAC-Whirlpool + Twofish-Serpent",
-	13733: "VeraCrypt PBKDF2-HMAC-Whirlpool + Serpent-Twofish-AES",
-	13741: "VeraCrypt PBKDF2-HMAC-RIPEMD160 + boot-mode + AES",
-	13742: "VeraCrypt PBKDF2-HMAC-RIPEMD160 + boot-mode + AES-Twofish",
-	13743: "VeraCrypt PBKDF2-HMAC-RIPEMD160 + boot-mode + AES-Twofish-Serpent",
-	13751: "VeraCrypt PBKDF2-HMAC-SHA256 + AES / VeraCrypt PBKDF2-HMAC-SHA256 + Serpent / VeraCrypt PBKDF2-HMAC-SHA256 + Twofish",
-	13752: "VeraCrypt PBKDF2-HMAC-SHA256 + AES-Twofish / VeraCrypt PBKDF2-HMAC-SHA256 + Serpent-AES / VeraCrypt PBKDF2-HMAC-SHA256 + Twofish-Serpent",
-	13753: "VeraCrypt PBKDF2-HMAC-SHA256 + Serpent-Twofish-AES",
-	13761: "VeraCrypt PBKDF2-HMAC-SHA256 + boot-mode + Twofish / VeraCrypt PBKDF2-HMAC-SHA256 + boot-mode + PIM + AES",
-	13762: "VeraCrypt PBKDF2-HMAC-SHA256 + boot-mode + Serpent-AES",
-	13763: "VeraCrypt PBKDF2-HMAC-SHA256 + boot-mode + Serpent-Twofish-AES",
-	13771: "VeraCrypt Streebog-512 + XTS 512 bit",
-	13772: "VeraCrypt Streebog-512 + XTS 1024 bit",
-	13773: "VeraCrypt Streebog-512 + XTS 1536 bit",
-	13800: "Windows Phone 8+ PIN/password",
-	13900: "OpenCart",
-	14000: "DES (PT = $salt, key = $pass)",
-	14100: "3DES (PT = $salt, key = $pass)",
-	14400: "sha1(CX)",
-	14500: "Linux Kernel Crypto API (2.4)",
-	14600: "LUKS",
-	14700: "iTunes backup < 10.0",
-	14800: "iTunes backup >= 10.0",
-	14900: "Skip32 (PT = $salt, key = $pass)",
-	15000: "FileZilla Server >= 0.9.55",
-	15100: "Juniper/NetBSD sha1crypt",
-	15200: "Blockchain, My Wallet, V2",
-	15300: "DPAPI masterkey file v1 + local context",
-	15400: "ChaCha20",
-	15500: "JKS Java Key Store Private Keys (SHA1)",
-	15600: "Ethereum Wallet, PBKDF2-HMAC-SHA256",
-	15700: "Ethereum Wallet, SCRYPT",
-	15900: "DPAPI masterkey file v2 + Active Directory domain context",
-	16000: "Tripcode",
-	16100: "TACACS+",
-	16200: "Apple Secure Notes",
-	16300: "Ethereum Pre-Sale Wallet, PBKDF2-HMAC-SHA256",
-	16400: "CRAM-MD5 Dovecot",
-	16500: "JWT (JSON Web Token)",
-	16600: "Electrum Wallet (Salt-Type 1-3)",
-	16700: "FileVault 2",
-	16800: "WPA-PMKID-PBKDF2",
-	16801: "WPA-PMKID-PMK",
-	16900: "Ansible Vault",
-	17200: "PKZIP (Compressed)",
-	17210: "PKZIP (Uncompressed)",
-	17220: "PKZIP (Compressed Multi-File)",
-	17225: "PKZIP (Mixed Multi-File)",
-	17230: "PKZIP (Mixed Multi-File Checksum-Only)",
-	17300: "SHA3-224",
-	17400: "SHA3-256",
-	17500: "SHA3-384",
-	17600: "SHA3-512",
-	17700: "Keccak-224",
-	17800: "Keccak-256",
-	17900: "Keccak-384",
-	18000: "Keccak-512",
-	18100: "TOTP (HMAC-SHA1)",
-	18200: "Kerberos 5, etype 23, AS-REP",
-	18300: "Apple File System (APFS)",
-	18400: "Open Document Format (ODF) 1.2 (SHA-256, AES)",
-	18500: "sha1(md5(md5($pass)))",
-	18600: "Open Document Format (ODF) 1.1 (SHA-1, Blowfish)",
-	18700: "Java Object hashCode()",
-	18800: "Blockchain, My Wallet, Second Password (SHA256)",
-	18900: "Android Backup",
-	19000: "QNX /etc/shadow (MD5)",
-	19100: "QNX /etc/shadow (SHA256)",
-	19200: "QNX /etc/shadow (SHA512)",
-	19300: "sha1($salt1.$pass.$salt2)",
-	19500: "Ruby on Rails Restful-Authentication",
-	19600: "Kerberos 5, etype 17, TGS-REP (AES128-CTS-HMAC-SHA1-96)",
-	19700: "Kerberos 5, etype 18, TGS-REP (AES256-CTS-HMAC-SHA1-96)",
-	19800: "Kerberos 5, etype 17, Pre-Auth",
-	19900: "Kerberos 5, etype 18, Pre-Auth",
-	20011: "DiskCryptor SHA512 + XTS 512 bit (AES) / DiskCryptor SHA512 + XTS 512 bit (Twofish) / DiskCryptor SHA512 + XTS 512 bit (Serpent)",
-	20012: "DiskCryptor SHA512 + XTS 1024 bit (AES-Twofish) / DiskCryptor SHA512 + XTS 1024 bit (Twofish-Serpent) / DiskCryptor SHA512 + XTS 1024 bit (Serpent-AES)",
-	20013: "DiskCryptor SHA512 + XTS 1536 bit (AES-Twofish-Serpent)",
-	20200: "Python passlib pbkdf2-sha512",
-	20300: "Python passlib pbkdf2-sha256",
-	20400: "Python passlib pbkdf2-sha1",
-	20500: "PKZIP Master Key",
-	20510: "PKZIP Master Key (6 byte optimization)",
-	20600: "Oracle Transportation Management (SHA256)",
-	20710: "sha256(sha256($pass).$salt)",
-	20711: "AuthMe sha256",
-	20720: "sha256($salt.sha256($pass))",
-	20800: "sha256(md5($pass))",
-	20900: "md5(sha1($pass).md5($pass).sha1($pass))",
-	21000: "BitShares v0.x - sha512(sha512_bin(pass))",
-	21100: "sha1(md5($pass.$salt))",
-	21200: "md5(sha1($salt).md5($pass))",
-	21300: "md5($salt.sha1($salt.$pass))",
-	21400: "sha256(sha256_bin($pass))",
-	21500: "SolarWinds Orion",
-	21501: "SolarWinds Orion v2",
-	21600: "Web2py pbkdf2-sha512",
-	21700: "Electrum Wallet (Salt-Type 4)",
-	21800: "Electrum Wallet (Salt-Type 5)",
-	22000: "WPA-PBKDF2-PMKID+EAPOL",
-	22001: "WPA-PMK-PMKID+EAPOL",
-	22100: "BitLocker",
-	22200: "Citrix NetScaler (SHA512)",
-	22300: "sha256($salt.$pass.$salt)",
-	22301: "Telegram Mobile App Passcode (SHA256)",
-	22400: "AES Crypt (SHA256)",
-	22500: "MultiBit Classic .key (MD5)",
-	22600: "Telegram Desktop < v2.1.14 (PBKDF2-HMAC-SHA1)",
-	22700: "MultiBit HD (scrypt)",
-	22911: "RSA/DSA/EC/OpenSSH Private Keys ($0$)",
-	22921: "RSA/DSA/EC/OpenSSH Private Keys ($6$)",
-	22931: "RSA/DSA/EC/OpenSSH Private Keys ($1, $3$)",
-	22941: "RSA/DSA/EC/OpenSSH Private Keys ($4$)",
-	22951: "RSA/DSA/EC/OpenSSH Private Keys ($5$)",
-	23001: "SecureZIP AES-128",
-	23002: "SecureZIP AES-192",
-	23003: "SecureZIP AES-256",
-	23100: "Apple Keychain",
-	23200: "XMPP SCRAM PBKDF2-SHA1",
-	23300: "Apple iWork",
-	23400: "Bitwarden",
-	23500: "AxCrypt 2 AES-128",
-	23600: "AxCrypt 2 AES-256",
-	23700: "RAR3-p (Uncompressed)",
-	23800: "RAR3-p (Compressed)",
-	23900: "BestCrypt v3 Volume Encryption",
-	24100: "MongoDB ServerKey SCRAM-SHA-1",
-	24200: "MongoDB ServerKey SCRAM-SHA-256",
-	24300: "sha1($salt.sha1($pass.$salt))",
-	24410: "PKCS#8 Private Keys (PBKDF2-HMAC-SHA1 + 3DES/AES)",
-	24420: "PKCS#8 Private Keys (PBKDF2-HMAC-SHA256 + 3DES/AES)",
-	24500: "Telegram Desktop >= v2.1.14 (PBKDF2-HMAC-SHA512)",
-	24600: "SQLCipher",
-	24700: "Stuffit5",
-	24800: "Umbraco HMAC-SHA1",
-	24900: "Dahua Authentication MD5",
-	25300: "MS Office 2016 - SheetProtection",
-	25400: "PDF 1.4 - 1.6 (Acrobat 5 - 8) - edit password",
-	25500: "Stargazer Stellar Wallet XLM",
-	25600: "bcrypt(md5($pass)) / bcryptmd5",
-	25700: "MurmurHash",
-	25800: "bcrypt(sha1($pass)) / bcryptsha1",
-	25900: "KNX IP Secure - Device Authentication Code",
-	26000: "Mozilla key3.db",
-	26100: "Mozilla key4.db",
-	26200: "OpenEdge Progress Encode",
-	26300: "FortiGate256 (FortiOS256)",
-	26401: "AES-128-ECB NOKDF (PT = $salt, key = $pass)",
-	26402: "AES-192-ECB NOKDF (PT = $salt, key = $pass)",
-	26403: "AES-256-ECB NOKDF (PT = $salt, key = $pass)",
-	26500: "iPhone passcode (UID key + System Keybag)",
-	26600: "MetaMask Wallet",
-	99999: "Plaintext",
-}
-
-func hashcatHashTypeName(mode int32) (string, bool) {
-	name, ok := hashcatHashTypes[mode]
-	return name, ok
-}
-
-func humanizeHashRate(rate uint64) string {
-	const unit = 1000
-	if rate < unit {
-		return fmt.Sprintf("%d H/s", rate)
-	}
-	value := float64(rate)
-	exp := 0
-	for value >= unit && exp < 5 {
-		value /= unit
-		exp++
-	}
-	suffixes := []string{"kH/s", "MH/s", "GH/s", "TH/s", "PH/s"}
-	if exp == 0 {
-		return fmt.Sprintf("%d H/s", rate)
-	}
-	if exp > len(suffixes) {
-		exp = len(suffixes)
-	}
-	return fmt.Sprintf("%.2f %s", value, suffixes[exp-1])
-}

client/command/crack/helpers.go

@@ -25,7 +25,7 @@ func CrackHcstat2Completer(con *console.SliverClient) carapace.Action {
 			}
 
 			results = append(results, file.Name)
-			desc := fmt.Sprintf("%s (%d chunks, chunk size: %s)", byteCountSI(file.UncompressedSize), len(file.Chunks), byteCountSI(file.ChunkSize))
+			desc := fmt.Sprintf("%s (%s chunks, chunk size: %s)", byteCountSI(file.UncompressedSize), len(file.Chunks), byteCountSI(file.ChunkSize))
 			results = append(results, desc)
 		}
 

client/command/creds/README.md

@@ -1,14 +0,0 @@
-# client/command/creds
-
-## Overview
-
-Implements the 'creds' command group for the Sliver client console. Handlers map Cobra invocations to creds workflows such as ADD, hash types, RM, and select.
-
-## Go Files
-
-- `add.go` – Adds credentials to the client store via interactive or flag-based input.
-- `commands.go` – Registers credential management commands and subcommands.
-- `creds.go` – Lists stored credentials and formats them for display.
-- `hash-types.go` – Enumerates supported hash types and their identifiers.
-- `rm.go` – Removes credentials by ID or filter from the store.
-- `select.go` – Selects credentials for use in other workflows, updating defaults.

client/command/creds/commands.go

@@ -1,7 +1,6 @@
 package creds
 
 import (
-	"github.com/bishopfox/sliver/client/command/completers"
 	"github.com/bishopfox/sliver/client/command/flags"
 	"github.com/bishopfox/sliver/client/command/help"
 	"github.com/bishopfox/sliver/client/console"
@@ -66,7 +65,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		(*comp)["hash-type"] = CredsHashTypeCompleter(con)
 	})
 	carapace.Gen(credsAddFileCmd).PositionalCompletion(carapace.ActionFiles().Tag("credential file"))
-	completers.RegisterLocalFilePathPositionalCompletion(credsAddFileCmd, 0)
 	credsAddCmd.AddCommand(credsAddFileCmd)
 
 	credsRmCmd := &cobra.Command{

client/command/creds/creds.go

@@ -61,9 +61,9 @@ func printCollection(collection string, creds []*clientpb.Credential, con *conso
 	tw := table.NewWriter()
 	tw.SetStyle(settings.GetTableStyle(con))
 	if collection != "" {
-		tw.SetTitle(console.StyleBold.Render(collection))
+		tw.SetTitle(console.Bold + collection + console.Normal)
 	} else {
-		tw.SetTitle(console.StyleBold.Render("Default Collection"))
+		tw.SetTitle(console.Bold + "Default Collection" + console.Normal)
 	}
 	tw.AppendHeader(table.Row{
 		"ID",

client/command/creds/select.go

@@ -8,8 +8,8 @@ import (
 	"strings"
 	"text/tabwriter"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 )
@@ -55,7 +55,11 @@ func SelectCredential(plaintext bool, hashType clientpb.HashType, con *console.S
 	}
 
 	selected := ""
-	err = forms.Select("Select a credential:", options, &selected)
+	prompt := &survey.Select{
+		Message: "Select a credential:",
+		Options: options,
+	}
+	err = survey.AskOne(prompt, &selected)
 	if err != nil {
 		return nil, err
 	}

client/command/cursed/README.md

@@ -1,17 +1,3 @@
-# client/command/cursed
+# Cursed
 
-## Overview
-
-Implements the 'cursed' command group for the Sliver client console. Handlers map Cobra invocations to cursed workflows such as cursed chrome, cursed console, cursed cookies, and cursed edge.
-
-## Go Files
-
-- `commands.go` – Exposes the cursed command suite and binds individual subcommands for supported targets.
-- `cursed-chrome.go` – Launches or hijacks Chrome debugging sessions, locating executables and wiring remote control.
-- `cursed-console.go` – Provides the interactive cursed console experience atop Chrome DevTools sessions.
-- `cursed-cookies.go` – Fetches and displays browser cookies from an active cursed session.
-- `cursed-edge.go` – Mirrors the Chrome workflow for Microsoft Edge, including process discovery logic.
-- `cursed-electron.go` – Drives cursed interactions with arbitrary Electron apps, validating binaries and starting injected sessions.
-- `cursed-rm.go` – Removes cursed sessions from the client cache and tears down associated resources.
-- `cursed-screenshot.go` – Captures screenshots from a cursed browser context via DevTools APIs.
-- `cursed.go` – Manages the cursed process registry, selection helpers, and remote debugger configuration defaults.
+Cursed is a Sliver Chrome/Electron post-exploitation tool kit based on/integrated with [CursedChrome](https://github.com/mandatoryprogrammer/CursedChrome). Code injection is performed via the [DevTools protocol](https://chromedevtools.github.io/devtools-protocol/).

client/command/cursed/commands.go

@@ -1,7 +1,6 @@
 package cursed
 
 import (
-	"github.com/bishopfox/sliver/client/command/completers"
 	"github.com/bishopfox/sliver/client/command/flags"
 	"github.com/bishopfox/sliver/client/command/help"
 	"github.com/bishopfox/sliver/client/console"
@@ -76,7 +75,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 	flags.BindFlagCompletions(cursedChromeCmd, func(comp *carapace.ActionMap) {
 		(*comp)["payload"] = carapace.ActionFiles("js").Tag("javascript files")
 	})
-	completers.RegisterLocalFilePathFlagCompletion(cursedChromeCmd, "payload")
 	cursedChromeCmd.Flags().ParseErrorsWhitelist.UnknownFlags = true
 	carapace.Gen(cursedChromeCmd).PositionalAnyCompletion(carapace.ActionValues().Usage("additional Chrome CLI arguments"))
 
@@ -101,7 +99,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 	flags.BindFlagCompletions(cursedEdgeCmd, func(comp *carapace.ActionMap) {
 		(*comp)["payload"] = carapace.ActionFiles("js").Tag("javascript files")
 	})
-	completers.RegisterLocalFilePathFlagCompletion(cursedEdgeCmd, "payload")
 	cursedEdgeCmd.Flags().ParseErrorsWhitelist.UnknownFlags = true
 	carapace.Gen(cursedEdgeCmd).PositionalAnyCompletion(carapace.ActionValues().Usage("additional Edge CLI arguments"))
 
@@ -133,7 +130,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 	flags.Bind("", false, CursedCookiesCmd, func(f *pflag.FlagSet) {
 		f.StringP("save", "s", "", "save to file")
 	})
-	completers.RegisterLocalFilePathFlagCompletion(CursedCookiesCmd, "save")
 
 	cursedScreenshotCmd := &cobra.Command{
 		Use:   consts.ScreenshotStr,
@@ -148,7 +144,6 @@ func Commands(con *console.SliverClient) []*cobra.Command {
 		f.Int64P("quality", "q", 100, "screenshot quality (1 - 100)")
 		f.StringP("save", "s", "", "save to file")
 	})
-	completers.RegisterLocalFilePathFlagCompletion(cursedScreenshotCmd, "save")
 
 	return []*cobra.Command{cursedCmd}
 }

client/command/cursed/cursed-chrome.go

@@ -23,19 +23,19 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	insecureRand "math/rand"
 	"os"
 	"strings"
 	"time"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/client/overlord"
 	"github.com/bishopfox/sliver/client/tcpproxy"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/bishopfox/sliver/util"
 	"github.com/spf13/cobra"
 )
 
@@ -94,7 +94,7 @@ func CursedChromeCmd(cmd *cobra.Command, con *console.SliverClient, args []strin
 	}
 	if chromeExt != nil {
 		con.Printf("success!\n")
-		con.PrintInfof("Found viable Chrome extension %s (%s)\n", console.StyleBold.Render(chromeExt.Title), chromeExt.ID)
+		con.PrintInfof("Found viable Chrome extension %s%s%s (%s)\n", console.Bold, chromeExt.Title, console.Normal, chromeExt.ID)
 		con.PrintInfof("Injecting payload ... ")
 		cmd, _, _ := overlord.GetChromeContext(chromeExt.WebSocketDebuggerURL, curse)
 		// extCtxTimeout, cancel := context.WithTimeout(cmd, 10*time.Second)
@@ -120,10 +120,10 @@ func avadaKedavraChrome(session *clientpb.Session, cmd *cobra.Command, con *cons
 	if chromeProcess != nil {
 		con.PrintWarnf("Found running Chrome process: %d (ppid: %d)\n", chromeProcess.GetPid(), chromeProcess.GetPpid())
 		con.PrintWarnf("Sliver will need to kill and restart the Chrome process in order to perform code injection.\n")
-		con.PrintWarnf("Sliver will attempt to restore the user's session, however %s\n", console.StyleBold.Render("DATA LOSS MAY OCCUR!"))
+		con.PrintWarnf("Sliver will attempt to restore the user's session, however %sDATA LOSS MAY OCCUR!%s\n", console.Bold, console.Normal)
 		con.Printf("\n")
 		confirm := false
-		err = forms.Confirm("Kill and restore existing Chrome process?", &confirm)
+		err = survey.AskOne(&survey.Confirm{Message: "Kill and restore existing Chrome process?"}, &confirm)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return nil
@@ -213,7 +213,7 @@ func startCursedChromeProcess(isEdge bool, session *clientpb.Session, cmd *cobra
 	con.PrintInfof("Waiting for %s process to initialize ... ", name)
 	time.Sleep(2 * time.Second)
 
-	bindPort := util.Intn(10000) + 40000
+	bindPort := insecureRand.Intn(10000) + 40000
 	bindAddr := fmt.Sprintf("127.0.0.1:%d", bindPort)
 
 	remoteAddr := fmt.Sprintf("127.0.0.1:%d", debugPort)

client/command/cursed/cursed-console.go

@@ -26,9 +26,9 @@ import (
 	"strings"
 	"text/tabwriter"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/client/overlord"
 	"github.com/reeflective/readline"
 	"github.com/spf13/cobra"
@@ -71,8 +71,12 @@ func selectDebugTarget(targets []overlord.ChromeDebugTarget, con *console.Sliver
 	table.Flush()
 	options := strings.Split(outputBuf.String(), "\n")
 	options = options[:len(options)-1] // Remove the last empty option
+	prompt := &survey.Select{
+		Message: "Select a debug target:",
+		Options: options,
+	}
 	selected := ""
-	err := forms.Select("Select a debug target:", options, &selected)
+	err := survey.AskOne(prompt, &selected)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return nil
@@ -93,7 +97,7 @@ func startCursedConsole(curse *core.CursedProcess, helpers bool, target *overlor
 	tmpFile, _ := os.CreateTemp("", "cursed")
 	shell := readline.NewShell()
 	shell.History.AddFromFile("cursed history", tmpFile.Name())
-	shell.Prompt.Primary(func() string { return console.StyleRed.Render("cursed »") + " " })
+	shell.Prompt.Primary(func() string { return "\033[31mcursed »\033[0m " })
 	// 	EOFPrompt:         "exit",
 
 	if con.Settings.VimMode {
@@ -111,7 +115,7 @@ func startCursedConsole(curse *core.CursedProcess, helpers bool, target *overlor
 		}
 	}
 
-	con.Printf("%s\n\n", console.StyleBold.Render(">>> Cursed Console, use ':help' for options"))
+	con.Printf(console.Bold+">>> Cursed Console, use ':help' for options%s\n\n", console.Normal)
 
 	for {
 		line, err := shell.Readline()

client/command/cursed/cursed-cookies.go

@@ -21,10 +21,9 @@ package cursed
 import (
 	"fmt"
 	"os"
+	"strings"
 	"time"
 
-	"encoding/json"
-
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/overlord"
 	"github.com/spf13/cobra"
@@ -47,24 +46,24 @@ func CursedCookiesCmd(cmd *cobra.Command, con *console.SliverClient, args []stri
 	if len(cookies) == 0 {
 		return
 	}
-
 	saveFile, _ := cmd.Flags().GetString("save")
 	if saveFile == "" {
 		saveFile = fmt.Sprintf("cookies-%s.json", time.Now().Format("20060102150405"))
 	}
-
-	jsonBytes, err := json.MarshalIndent(cookies, "", "  ")
-	if err != nil {
-		con.PrintErrorf("Failed to marshal cookies: %s\n", err)
-		return
+	jsonCookies := []string{}
+	for _, cookie := range cookies {
+		jsonCookie, err := cookie.MarshalJSON()
+		if err != nil {
+			con.PrintErrorf("Failed to marshal cookie: %s\n", err)
+			continue
+		}
+		jsonCookies = append(jsonCookies, string(jsonCookie))
 	}
-
-	err = os.WriteFile(saveFile, jsonBytes, 0o600)
+	err = os.WriteFile(saveFile, []byte(strings.Join(jsonCookies, "\n")), 0o600)
 	if err != nil {
 		con.PrintErrorf("Failed to save cookies: %s\n", err)
 		return
 	}
-
 	con.PrintInfof("Saved to %s", saveFile)
 	con.Println()
 }

client/command/cursed/cursed-edge.go

@@ -23,9 +23,9 @@ import (
 	"os"
 	"strings"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/client/overlord"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
@@ -77,7 +77,7 @@ func CursedEdgeCmd(cmd *cobra.Command, con *console.SliverClient, args []string)
 	}
 	if chromeExt != nil {
 		con.Printf("success!\n")
-		con.PrintInfof("Found viable Edge extension %s (%s)\n", console.StyleBold.Render(chromeExt.Title), chromeExt.ID)
+		con.PrintInfof("Found viable Edge extension %s%s%s (%s)\n", console.Bold, chromeExt.Title, console.Normal, chromeExt.ID)
 		con.PrintInfof("Injecting payload ... ")
 		cmd, _, _ := overlord.GetChromeContext(chromeExt.WebSocketDebuggerURL, curse)
 		// extCtxTimeout, cancel := context.WithTimeout(cmd, 10*time.Second)
@@ -103,10 +103,10 @@ func avadaKedavraEdge(session *clientpb.Session, cmd *cobra.Command, con *consol
 	if edgeProcess != nil {
 		con.PrintWarnf("Found running Edge process: %d (ppid: %d)\n", edgeProcess.GetPid(), edgeProcess.GetPpid())
 		con.PrintWarnf("Sliver will need to kill and restart the Edge process in order to perform code injection.\n")
-		con.PrintWarnf("Sliver will attempt to restore the user's session, however %s\n", console.StyleBold.Render("DATA LOSS MAY OCCUR!"))
+		con.PrintWarnf("Sliver will attempt to restore the user's session, however %sDATA LOSS MAY OCCUR!%s\n", console.Bold, console.Normal)
 		con.Printf("\n")
 		confirm := false
-		err = forms.Confirm("Kill and restore existing Edge process?", &confirm)
+		err = survey.AskOne(&survey.Confirm{Message: "Kill and restore existing Edge process?"}, &confirm)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return nil

client/command/cursed/cursed-electron.go

@@ -22,18 +22,18 @@ import (
 	"context"
 	"fmt"
 	"log"
+	insecureRand "math/rand"
 	"path"
 	"time"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/client/overlord"
 	"github.com/bishopfox/sliver/client/tcpproxy"
 	"github.com/bishopfox/sliver/protobuf/clientpb"
 	"github.com/bishopfox/sliver/protobuf/commonpb"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/bishopfox/sliver/util"
 	"github.com/spf13/cobra"
 )
 
@@ -85,10 +85,10 @@ func avadaKedavraElectron(electronExe string, session *clientpb.Session, cmd *co
 	if electronProcess != nil {
 		con.PrintWarnf("Found running '%s' process: %d (ppid: %d)\n", path.Base(electronExe), electronProcess.GetPid(), electronProcess.GetPpid())
 		con.PrintWarnf("Sliver will need to kill and restart the process in order to perform code injection.\n")
-		con.PrintWarnf("%s\n", console.StyleBold.Render("DATA LOSS MAY OCCUR!"))
+		con.PrintWarnf("%sDATA LOSS MAY OCCUR!%s\n", console.Bold, console.Normal)
 		con.Printf("\n")
 		confirm := false
-		err = forms.Confirm("Kill and restart the process?", &confirm)
+		err = survey.AskOne(&survey.Confirm{Message: "Kill and restart the process?"}, &confirm)
 		if err != nil {
 			con.PrintErrorf("%s\n", err)
 			return nil
@@ -118,7 +118,7 @@ func avadaKedavraElectron(electronExe string, session *clientpb.Session, cmd *co
 	return curse
 }
 
-func checkElectronPath(electronExe string, _ *clientpb.Session, cmd *cobra.Command, con *console.SliverClient) (bool, error) {
+func checkElectronPath(electronExe string, session *clientpb.Session, cmd *cobra.Command, con *console.SliverClient) (bool, error) {
 	ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
 		Request: con.ActiveTarget.Request(cmd),
 		Path:    electronExe,
@@ -175,7 +175,7 @@ func startCursedElectronProcess(electronExe string, session *clientpb.Session, c
 	con.PrintInfof("Waiting for process to initialize ... ")
 	time.Sleep(2 * time.Second)
 
-	bindPort := util.Intn(10000) + 40000
+	bindPort := insecureRand.Intn(10000) + 40000
 	bindAddr := fmt.Sprintf("127.0.0.1:%d", bindPort)
 
 	remoteAddr := fmt.Sprintf("127.0.0.1:%d", debugPort)

client/command/cursed/cursed-rm.go

@@ -22,9 +22,9 @@ import (
 	"context"
 	"strconv"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
-	"github.com/bishopfox/sliver/client/forms"
 	"github.com/bishopfox/sliver/protobuf/sliverpb"
 	"github.com/spf13/cobra"
 )
@@ -44,7 +44,7 @@ func CursedRmCmd(cmd *cobra.Command, con *console.SliverClient, args []string) {
 	core.CloseCursedProcessesByBindPort(session.ID, bindPort)
 	if kill {
 		confirm := false
-		err := forms.Confirm("Kill the cursed process?", &confirm)
+		err := survey.AskOne(&survey.Confirm{Message: "Kill the cursed process?"}, &confirm)
 		if err != nil {
 			con.PrintErrorf("%s", err)
 			return

client/command/cursed/cursed.go

@@ -21,15 +21,15 @@ package cursed
 import (
 	"bytes"
 	"fmt"
+	insecureRand "math/rand"
 	"strconv"
 	"strings"
 	"text/tabwriter"
 
+	"github.com/AlecAivazis/survey/v2"
 	"github.com/bishopfox/sliver/client/command/settings"
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/core"
-	"github.com/bishopfox/sliver/client/forms"
-	"github.com/bishopfox/sliver/util"
 	"github.com/jedib0t/go-pretty/v6/table"
 	"github.com/spf13/cobra"
 )
@@ -95,8 +95,12 @@ func selectCursedProcess(con *console.SliverClient) *core.CursedProcess {
 	table.Flush()
 	options := strings.Split(outputBuf.String(), "\n")
 	options = options[:len(options)-1] // Remove the last empty option
+	prompt := &survey.Select{
+		Message: "Select a curse:",
+		Options: options,
+	}
 	selected := ""
-	err := forms.Select("Select a curse:", options, &selected)
+	err := survey.AskOne(prompt, &selected)
 	if err != nil {
 		con.PrintErrorf("%s\n", err)
 		return nil
@@ -111,7 +115,7 @@ func selectCursedProcess(con *console.SliverClient) *core.CursedProcess {
 func getRemoteDebuggerPort(cmd *cobra.Command) int {
 	port, _ := cmd.Flags().GetInt("remote-debugging-port")
 	if port == 0 {
-		port = util.Intn(30000) + 10000
+		port = insecureRand.Intn(30000) + 10000
 	}
 	return port
 }