Merge pull request #594 from je4yfc/integration

Generalized Support for external services across compose generation and port checks

.env

@@ -1,2 +0,0 @@
-COMPOSE_PROJECT_NAME=apfell
-POSTGRES_PASSWORD=super_secret_mythic_user_password

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: [its-a-feature]

.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+  - package-ecosystem: "gomod"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/docker.yml

@@ -0,0 +1,573 @@
+# Pulled from Thanatos (https://github.com/MythicAgents/thanatos/blob/rewrite/.github/workflows/image.yml) - MEhrn00
+
+# Name for the Github actions workflow
+name: Build and push container images
+
+on:
+  # Only run workflow when there is a new release published in Github
+  #release:
+  #  types: [published]
+  push:
+    branches:
+      - 'Mythic3.3'
+      - 'master'
+    tags:
+      - "v*.*.*"
+
+# Variables holding configuration settings
+env:
+  # Container registry the built container image will be pushed to
+  REGISTRY: ghcr.io
+
+  # Set the container image name to the Github repository name. (its-a-feature/Mythic)
+  MYTHIC_SERVER_IMAGE_NAME: ${{ github.repository }}_server
+  MYTHIC_CLI_IMAGE_NAME: ${{ github.repository }}_cli
+  MYTHIC_POSTGRES_IMAGE_NAME: ${{ github.repository }}_postgres
+  MYTHIC_RABBITMQ_IMAGE_NAME: ${{ github.repository }}_rabbitmq
+  MYTHIC_DOCUMENTATION_IMAGE_NAME: ${{ github.repository }}_documentation
+  MYTHIC_JUPYTER_IMAGE_NAME: ${{ github.repository }}_jupyter
+  MYTHIC_GRAPHQL_IMAGE_NAME: ${{ github.repository }}_graphql
+  MYTHIC_NGINX_IMAGE_NAME: ${{ github.repository }}_nginx
+  MYTHIC_REACT_IMAGE_NAME: ${{ github.repository }}_react
+
+  # Description label for the package in Github
+  IMAGE_DESCRIPTION: "test containers for Mythic development. Do not use this version!"
+
+  # Source URL for the package in Github. This links the Github repository packages list
+  # to this container image
+  IMAGE_SOURCE: ${{ github.server_url }}/${{ github.repository }}
+
+  # License for the container image
+  IMAGE_LICENSE: BSD-3-Clause
+
+  # Set the container image version to the Github release tag
+  VERSION: ${{ github.ref_name }}
+
+  # Branch for pushing release changes
+  RELEASE_BRANCH: master
+
+jobs:
+  # Builds the base container image and pushes it to the container registry
+  mythic_server:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@v4 # ref: https://github.com/marketplace/actions/checkout
+      - name: Log in to the container registry
+        uses: docker/login-action@v3 # ref: https://github.com/marketplace/actions/docker-login
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: 'arm64,arm'
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+      # the following are unique to this job
+      - name: Lowercase the server container image name
+        run: echo "MYTHIC_SERVER_IMAGE_NAME=${MYTHIC_SERVER_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Copy version file over
+        run: cp VERSION mythic-docker/src/VERSION
+      - name: Build and push the server container image
+        uses: docker/build-push-action@v5 # ref: https://github.com/marketplace/actions/build-and-push-docker-images
+        with:
+          context: mythic-docker
+          file: mythic-docker/.docker/Dockerfile
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_SERVER_IMAGE_NAME }}:${{ env.VERSION }}
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_SERVER_IMAGE_NAME }}:latest
+          push: ${{ github.ref_type == 'tag' }}
+          # These container metadata labels allow configuring the package in Github
+          # packages. The source will link the package to this Github repository
+          labels: |
+            org.opencontainers.image.source=${{ env.IMAGE_SOURCE }}
+            org.opencontainers.image.description=${{ env.IMAGE_DESCRIPTION }}
+            org.opencontainers.image.licenses=${{ env.IMAGE_LICENSE }}
+          platforms: linux/amd64,linux/arm64
+
+  mythic_postgres:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+    steps:
+      # Pull in the repository code
+      - name: Checkout the repository
+        uses: actions/checkout@v4 # ref: https://github.com/marketplace/actions/checkout
+      - name: Log in to the container registry
+        uses: docker/login-action@v3 # ref: https://github.com/marketplace/actions/docker-login
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: 'arm64,arm'
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+      # the following are unique to this job
+      - name: Lowercase the postgres container image name
+        run: echo "MYTHIC_POSTGRES_IMAGE_NAME=${MYTHIC_POSTGRES_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Build and push the postgres container image
+        uses: docker/build-push-action@v5 # ref: https://github.com/marketplace/actions/build-and-push-docker-images
+        with:
+          context: postgres-docker
+          file: postgres-docker/Dockerfile
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_POSTGRES_IMAGE_NAME }}:${{ env.VERSION }}
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_POSTGRES_IMAGE_NAME }}:latest
+          push: ${{ github.ref_type == 'tag' }}
+          # These container metadata labels allow configuring the package in Github
+          # packages. The source will link the package to this Github repository
+          labels: |
+            org.opencontainers.image.source=${{ env.IMAGE_SOURCE }}
+            org.opencontainers.image.description=${{ env.IMAGE_DESCRIPTION }}
+            org.opencontainers.image.licenses=${{ env.IMAGE_LICENSE }}
+          platforms: linux/amd64,linux/arm64
+
+  mythic_rabbitmq:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+    steps:
+      # Pull in the repository code
+      - name: Checkout the repository
+        uses: actions/checkout@v4 # ref: https://github.com/marketplace/actions/checkout
+      - name: Log in to the container registry
+        uses: docker/login-action@v3 # ref: https://github.com/marketplace/actions/docker-login
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: 'arm64,arm'
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+      # the following are unique to this job
+      - name: Lowercase the rabbitmq container image name
+        run: echo "MYTHIC_RABBITMQ_IMAGE_NAME=${MYTHIC_RABBITMQ_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Build and push the rabbitmq container image
+        uses: docker/build-push-action@v5 # ref: https://github.com/marketplace/actions/build-and-push-docker-images
+        with:
+          context: rabbitmq-docker
+          file: rabbitmq-docker/Dockerfile
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_RABBITMQ_IMAGE_NAME }}:${{ env.VERSION }}
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_RABBITMQ_IMAGE_NAME }}:latest
+          push: ${{ github.ref_type == 'tag' }}
+          # These container metadata labels allow configuring the package in Github
+          # packages. The source will link the package to this Github repository
+          labels: |
+            org.opencontainers.image.source=${{ env.IMAGE_SOURCE }}
+            org.opencontainers.image.description=${{ env.IMAGE_DESCRIPTION }}
+            org.opencontainers.image.licenses=${{ env.IMAGE_LICENSE }}
+          platforms: linux/amd64,linux/arm64
+
+  mythic_documentation:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+    steps:
+      # Pull in the repository code
+      - name: Checkout the repository
+        uses: actions/checkout@v4 # ref: https://github.com/marketplace/actions/checkout
+      - name: Log in to the container registry
+        uses: docker/login-action@v3 # ref: https://github.com/marketplace/actions/docker-login
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: 'arm64,arm'
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+      # the following are unique to this job
+      - name: Lowercase the documentation container image name
+        run: echo "MYTHIC_DOCUMENTATION_IMAGE_NAME=${MYTHIC_DOCUMENTATION_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Build and push the documentation container image
+        uses: docker/build-push-action@v5 # ref: https://github.com/marketplace/actions/build-and-push-docker-images
+        with:
+          context: documentation-docker
+          file: documentation-docker/Dockerfile
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_DOCUMENTATION_IMAGE_NAME }}:${{ env.VERSION }}
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_DOCUMENTATION_IMAGE_NAME }}:latest
+          push: ${{ github.ref_type == 'tag' }}
+          # These container metadata labels allow configuring the package in Github
+          # packages. The source will link the package to this Github repository
+          labels: |
+            org.opencontainers.image.source=${{ env.IMAGE_SOURCE }}
+            org.opencontainers.image.description=${{ env.IMAGE_DESCRIPTION }}
+            org.opencontainers.image.licenses=${{ env.IMAGE_LICENSE }}
+          platforms: linux/amd64,linux/arm64
+
+  mythic_jupyter:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+    steps:
+      # Pull in the repository code
+      - name: Checkout the repository
+        uses: actions/checkout@v4 # ref: https://github.com/marketplace/actions/checkout
+      - name: Log in to the container registry
+        uses: docker/login-action@v3 # ref: https://github.com/marketplace/actions/docker-login
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: 'arm64,arm'
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+
+      # these two are unique
+
+      - name: Lowercase the jupyter container image name
+        run: echo "MYTHIC_JUPYTER_IMAGE_NAME=${MYTHIC_JUPYTER_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Build and push the jupyter container image
+        uses: docker/build-push-action@v5 # ref: https://github.com/marketplace/actions/build-and-push-docker-images
+        with:
+          context: jupyter-docker
+          file: jupyter-docker/Dockerfile
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_JUPYTER_IMAGE_NAME }}:${{ env.VERSION }}
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_JUPYTER_IMAGE_NAME }}:latest
+          push: ${{ github.ref_type == 'tag' }}
+          # These container metadata labels allow configuring the package in Github
+          # packages. The source will link the package to this Github repository
+          labels: |
+            org.opencontainers.image.source=${{ env.IMAGE_SOURCE }}
+            org.opencontainers.image.description=${{ env.IMAGE_DESCRIPTION }}
+            org.opencontainers.image.licenses=${{ env.IMAGE_LICENSE }}
+          platforms: linux/amd64,linux/arm64
+
+  mythic_graphql:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+    steps:
+      # Pull in the repository code
+      - name: Checkout the repository
+        uses: actions/checkout@v4 # ref: https://github.com/marketplace/actions/checkout
+      - name: Log in to the container registry
+        uses: docker/login-action@v3 # ref: https://github.com/marketplace/actions/docker-login
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: 'arm64,arm'
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+
+      # these two are unique
+
+      - name: Lowercase the graphql container image name
+        run: echo "MYTHIC_GRAPHQL_IMAGE_NAME=${MYTHIC_GRAPHQL_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Build and push the graphql container image
+        uses: docker/build-push-action@v5 # ref: https://github.com/marketplace/actions/build-and-push-docker-images
+        with:
+          context: hasura-docker
+          file: hasura-docker/Dockerfile
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_GRAPHQL_IMAGE_NAME }}:${{ env.VERSION }}
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_GRAPHQL_IMAGE_NAME }}:latest
+          push: ${{ github.ref_type == 'tag' }}
+          # These container metadata labels allow configuring the package in Github
+          # packages. The source will link the package to this Github repository
+          labels: |
+            org.opencontainers.image.source=${{ env.IMAGE_SOURCE }}
+            org.opencontainers.image.description=${{ env.IMAGE_DESCRIPTION }}
+            org.opencontainers.image.licenses=${{ env.IMAGE_LICENSE }}
+          platforms: linux/amd64,linux/arm64
+
+  mythic_nginx:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+    steps:
+      # Pull in the repository code
+      - name: Checkout the repository
+        uses: actions/checkout@v4 # ref: https://github.com/marketplace/actions/checkout
+      - name: Log in to the container registry
+        uses: docker/login-action@v3 # ref: https://github.com/marketplace/actions/docker-login
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: 'arm64,arm'
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+
+      # these two are unique
+
+      - name: Lowercase the nginx container image name
+        run: echo "MYTHIC_NGINX_IMAGE_NAME=${MYTHIC_NGINX_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Build and push the nginx container image
+        uses: docker/build-push-action@v5 # ref: https://github.com/marketplace/actions/build-and-push-docker-images
+        with:
+          context: nginx-docker
+          file: nginx-docker/Dockerfile
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_NGINX_IMAGE_NAME }}:${{ env.VERSION }}
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_NGINX_IMAGE_NAME }}:latest
+          push: ${{ github.ref_type == 'tag' }}
+          # These container metadata labels allow configuring the package in Github
+          # packages. The source will link the package to this Github repository
+          labels: |
+            org.opencontainers.image.source=${{ env.IMAGE_SOURCE }}
+            org.opencontainers.image.description=${{ env.IMAGE_DESCRIPTION }}
+            org.opencontainers.image.licenses=${{ env.IMAGE_LICENSE }}
+          platforms: linux/amd64,linux/arm64
+
+  mythic_react:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+    steps:
+      # Pull in the repository code
+      - name: Checkout the repository
+        uses: actions/checkout@v4 # ref: https://github.com/marketplace/actions/checkout
+        with:
+          lfs: true
+      - name: Log in to the container registry
+        uses: docker/login-action@v3 # ref: https://github.com/marketplace/actions/docker-login
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: 'arm64,arm'
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+
+      # these two are unique
+
+      - name: Lowercase the react container image name
+        run: echo "MYTHIC_REACT_IMAGE_NAME=${MYTHIC_REACT_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Build and push the react container image
+        uses: docker/build-push-action@v5 # ref: https://github.com/marketplace/actions/build-and-push-docker-images
+        with:
+          context: mythic-react-docker
+          file: mythic-react-docker/Dockerfile
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_REACT_IMAGE_NAME }}:${{ env.VERSION }}
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_REACT_IMAGE_NAME }}:latest
+          push: ${{ github.ref_type == 'tag' }}
+          # These container metadata labels allow configuring the package in Github
+          # packages. The source will link the package to this Github repository
+          labels: |
+            org.opencontainers.image.source=${{ env.IMAGE_SOURCE }}
+            org.opencontainers.image.description=${{ env.IMAGE_DESCRIPTION }}
+            org.opencontainers.image.licenses=${{ env.IMAGE_LICENSE }}
+          platforms: linux/amd64,linux/arm64
+
+  # update mythic-cli latest after we're sure all the others build properly
+  mythic_cli:
+    runs-on: ubuntu-latest
+    needs:
+      - mythic_server
+      - mythic_postgres
+      - mythic_rabbitmq
+      - mythic_documentation
+      - mythic_jupyter
+      - mythic_graphql
+      - mythic_nginx
+      - mythic_react
+    permissions:
+      contents: write
+      packages: write
+    steps:
+      # Pull in the repository code
+      - name: Checkout the repository
+        uses: actions/checkout@v4 # ref: https://github.com/marketplace/actions/checkout
+      - name: Log in to the container registry
+        uses: docker/login-action@v3 # ref: https://github.com/marketplace/actions/docker-login
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: 'arm64,arm'
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+      # the following are unique to this job
+      - name: Lowercase the cli container image name
+        run: echo "MYTHIC_CLI_IMAGE_NAME=${MYTHIC_CLI_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+
+      - name: Fix the mythic_docker_latest reference to reference the new release tag
+        working-directory: Mythic_CLI/src/cmd/config
+        run: |
+          sed -i "s|^const MythicDockerLatest =.*$|const MythicDockerLatest = \"${VERSION}\"|" constants.go
+
+      - name: Build and push the cli container image
+        uses: docker/build-push-action@v5 # ref: https://github.com/marketplace/actions/build-and-push-docker-images
+        with:
+          context: Mythic_CLI
+          file: Mythic_CLI/Dockerfile
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_CLI_IMAGE_NAME }}:${{ env.VERSION }}
+            ${{ env.REGISTRY }}/${{ env.MYTHIC_CLI_IMAGE_NAME }}:latest
+          push: ${{ github.ref_type == 'tag' }}
+          # These container metadata labels allow configuring the package in Github
+          # packages. The source will link the package to this Github repository
+          labels: |
+            org.opencontainers.image.source=${{ env.IMAGE_SOURCE }}
+            org.opencontainers.image.licenses=${{ env.IMAGE_LICENSE }}
+          platforms: linux/amd64,linux/arm64
+          outputs: type=image,name=target,annotation-index.org.opencontainers.image.description=${{ env.IMAGE_DESCRIPTION }}
+
+  update_files:
+    runs-on: ubuntu-latest
+    needs:
+      - mythic_server
+      - mythic_cli
+      - mythic_postgres
+      - mythic_rabbitmq
+      - mythic_documentation
+      - mythic_jupyter
+      - mythic_graphql
+      - mythic_nginx
+      - mythic_react
+    permissions:
+      contents: write
+      packages: write
+
+    steps:
+      # Pull in the repository code
+      - name: Checkout the repository
+        uses: actions/checkout@v4 # ref: https://github.com/marketplace/actions/checkout
+
+      # update names to lowercase
+      - name: Lowercase the server container image name
+        run: echo "MYTHIC_SERVER_IMAGE_NAME=${MYTHIC_SERVER_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Lowercase the cli container image name
+        run: echo "MYTHIC_CLI_IMAGE_NAME=${MYTHIC_CLI_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Lowercase the postgres container image name
+        run: echo "MYTHIC_POSTGRES_IMAGE_NAME=${MYTHIC_POSTGRES_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Lowercase the rabbitmq container image name
+        run: echo "MYTHIC_RABBITMQ_IMAGE_NAME=${MYTHIC_RABBITMQ_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Lowercase the documentation container image name
+        run: echo "MYTHIC_DOCUMENTATION_IMAGE_NAME=${MYTHIC_DOCUMENTATION_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Lowercase the jupyter container image name
+        run: echo "MYTHIC_JUPYTER_IMAGE_NAME=${MYTHIC_JUPYTER_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Lowercase the graphql container image name
+        run: echo "MYTHIC_GRAPHQL_IMAGE_NAME=${MYTHIC_GRAPHQL_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Lowercase the nginx container image name
+        run: echo "MYTHIC_NGINX_IMAGE_NAME=${MYTHIC_NGINX_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      - name: Lowercase the react container image name
+        run: echo "MYTHIC_REACT_IMAGE_NAME=${MYTHIC_REACT_IMAGE_NAME,,}" >> ${GITHUB_ENV}
+      # The Dockerfile which Mythic uses to pull in the base container image needs to be
+      # updated to reference the newly built container image
+      - name: Fix the server Dockerfile reference to reference the new release tag
+        working-directory: mythic-docker
+        run: |
+          sed -i "s|^FROM ghcr\.io.*$|FROM ${REGISTRY}/${MYTHIC_SERVER_IMAGE_NAME}:${VERSION}|" Dockerfile
+
+      - name: Fix the cli Dockerfile reference to reference the new release tag
+        working-directory: Mythic_CLI
+        run: |
+          sed -i "s|^FROM ghcr\.io.*$|FROM ${REGISTRY}/${MYTHIC_CLI_IMAGE_NAME}:${VERSION}|" Dockerfile
+
+      - name: Fix the cli Makefile reference to reference the new release tag
+        working-directory: Mythic_CLI
+        run: |
+          sed -i "s|^BUILDER_IMAGE=ghcr\.io.*$|BUILDER_IMAGE=${REGISTRY}/${MYTHIC_CLI_IMAGE_NAME}:${VERSION}|" Makefile
+
+      - name: Fix the mythic_docker_latest reference to reference the new release tag
+        working-directory: Mythic_CLI/src/cmd/config
+        run: |
+          sed -i "s|^const MythicDockerLatest =.*$|const MythicDockerLatest = \"${VERSION}\"|" constants.go
+
+      - name: Fix the postgres Dockerfile reference to reference the new release tag
+        working-directory: postgres-docker
+        run: |
+          sed -i "s|^FROM ghcr\.io.*$|FROM ${REGISTRY}/${MYTHIC_POSTGRES_IMAGE_NAME}:${VERSION}|" Dockerfile
+
+      - name: Fix the rabbitmq Dockerfile reference to reference the new release tag
+        working-directory: rabbitmq-docker
+        run: |
+          sed -i "s|^FROM ghcr\.io.*$|FROM ${REGISTRY}/${MYTHIC_RABBITMQ_IMAGE_NAME}:${VERSION}|" Dockerfile
+
+      - name: Fix the documentation Dockerfile reference to reference the new release tag
+        working-directory: documentation-docker
+        run: |
+          sed -i "s|^FROM ghcr\.io.*$|FROM ${REGISTRY}/${MYTHIC_DOCUMENTATION_IMAGE_NAME}:${VERSION}|" Dockerfile
+
+      - name: Fix the jupyter Dockerfile reference to reference the new release tag
+        working-directory: jupyter-docker
+        run: |
+          sed -i "s|^FROM ghcr\.io.*$|FROM ${REGISTRY}/${MYTHIC_JUPYTER_IMAGE_NAME}:${VERSION}|" Dockerfile
+      - name: Fix the graphql Dockerfile reference to reference the new release tag
+        working-directory: hasura-docker
+        run: |
+          sed -i "s|^FROM ghcr\.io.*$|FROM ${REGISTRY}/${MYTHIC_GRAPHQL_IMAGE_NAME}:${VERSION}|" Dockerfile
+      - name: Fix the nginx Dockerfile reference to reference the new release tag
+        working-directory: nginx-docker
+        run: |
+          sed -i "s|^FROM ghcr\.io.*$|FROM ${REGISTRY}/${MYTHIC_NGINX_IMAGE_NAME}:${VERSION}|" Dockerfile
+      - name: Fix the react Dockerfile reference to reference the new release tag
+        working-directory: mythic-react-docker
+        run: |
+          sed -i "s|^FROM ghcr\.io.*$|FROM ${REGISTRY}/${MYTHIC_REACT_IMAGE_NAME}:${VERSION}|" Dockerfile
+      # Push the changes to the Dockerfile
+      - name: Push the updated base Dockerfile image reference changes
+        if: ${{ github.ref_type == 'tag' }}
+        uses: EndBug/add-and-commit@v9 # ref: https://github.com/marketplace/actions/add-commit
+        with:
+          # Only add the Dockerfile changes. Nothing else should have been modified
+          add: "['Mythic_CLI/Makefile', 'Mythic_CLI/src/cmd/config/constants.go']"
+          # Use the Github actions bot for the commit author
+          default_author: github_actions
+          committer_email: github-actions[bot]@users.noreply.github.com
+
+          # Set the commit message
+          message: "Bump Mythic Dockerfile tag to match release '${{ env.VERSION }}'"
+
+          # Overwrite the current git tag with the new changes
+          tag: '${{ env.VERSION }} --force'
+
+          # Push the new changes with the tag overwriting the current one
+          tag_push: '--force'
+
+          # Push the commits to the branch marked as the release branch
+          push: origin HEAD:${{ env.RELEASE_BRANCH }} --set-upstream
+
+          # Have the workflow fail in case there are pathspec issues
+          pathspec_error_handling: exitImmediately

.gitignore

@@ -3,23 +3,43 @@ __pycache__/
 # Sphinx documentation
 docs/_build/
 # Environments
-#.env
+.env
+tmp
+saved_images/
 .venv
+*.swp
+mythic_server
+docker-compose.yml
+.ipynb_checkpoints/
 env/
 venv/
 ENV/
+mythic-cli
+.DS_Store
+[0-9a-zA-Z]*-[0-9a-zA-Z]*-[0-9a-zA-Z]*-[0-9a-zA-Z]*-[0-9a-zA-Z]*
+*.svg
 env.bak/
 venv.bak/
 # pycharm
 .idea/
 # ssl certs
 ssl/
-# downloaded files
-files/
+# Mythic files
+nginx-docker/config/blockips.conf
+mythic-docker/src/Mythic
 mythic_access.*
+mythic_sync/
 postgres-docker/database/
 rabbitmq-docker/storage/
-**/transforms.py
+C2_profiles/
+Payload_Types/
+InstalledServices/
+Docker_Templates/
+documentation-docker/content/
+documentation-docker/public/
+display_output.txt
+full_attack.json
+nginx-docker/config/conf.d/services.conf
 ## Ignore Visual Studio temporary files, build results, and
 ## files generated by popular Visual Studio add-ons.
 ##
@@ -139,4 +159,14 @@ $tf/
 # ReSharper is a .NET coding add-in
 _ReSharper*/
 *.[Rr]e[Ss]harper
-*.DotSettings.user
+*.DotSettings.user
+
+# vscode
+.vscode/
+
+jupyter-docker/jupyter/MythicExamples/.ipynb_checkpoints/
+
+nginx-docker/config/blockips.conf
+/MythicReactUI/build/
+/MythicReactUI/node_modules/
+/.gocache/

C2_Profiles/HTTP/Dockerfile

@@ -1 +0,0 @@
-From itsafeaturemythic/python38_sanic_c2profile:0.0.1

C2_Profiles/HTTP/c2_code/config.json

@@ -1,17 +0,0 @@
-{
-  "instances": [
-  {
-    "ServerHeaders": {
-      "Server": "NetDNA-cache/2.2",
-      "Cache-Control": "max-age=0, no-cache",
-      "Pragma": "no-cache",
-      "Connection": "keep-alive",
-      "Content-Type": "application/javascript; charset=utf-8"
-    },
-    "port": 80,
-    "key_path": "",
-    "cert_path": "",
-    "debug": false
-    }
-  ]
-}

C2_Profiles/HTTP/c2_code/fake.html

@@ -1,10 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <title>Page Not Found!</title>
-</head>
-<body>
-
-</body>
-</html>

C2_Profiles/HTTP/c2_code/server

@@ -1,125 +0,0 @@
-#!/usr/bin/env python3
-
-from sanic import Sanic
-from sanic.response import html, redirect, text, raw
-from sanic.exceptions import NotFound
-import sys
-import asyncio
-import ssl
-from pathlib import Path
-import requests
-import json
-import os
-
-config = {}
-
-async def print_flush(message):
-    print(message)
-    sys.stdout.flush()
-
-
-def server_error_handler(request, exception):
-    if request is None:
-        print("Invalid HTTP Method - Likely HTTPS trying to talk to HTTP")
-        sys.stdout.flush()
-        return html("Error: Failed to process request", status=500, headers={})
-    return html("Error: Requested URL {} not found".format(request.url), status=404, headers=config[request.app.name]['headers'])
-
-
-async def agent_message(request, **kwargs):
-    global config
-    try:
-        if config[request.app.name]['debug']:
-            await print_flush("agent_message request from: {} with {} and {}".format(request.url, request.cookies, request.headers))
-            await print_flush(" and URI: {}".format(request.query_string))
-        if config[request.app.name]['debug']:
-            await print_flush("Forwarding along to: {}".format(config['mythic_address']))
-        if request.method == "POST":
-            # manipulate the request if needed
-            #await MythicCallbackRPC().add_event_message(message="got a POST message")
-            response = requests.post(config['mythic_address'], data=request.body, verify=False, cookies=request.cookies, headers=request.headers)
-        else:
-            # manipulate the request if needed
-            #await MythicCallbackRPC().add_event_message(message="got a GET message")
-            #msg = await MythicCallbackRPC().encrypt_bytes(with_uuid=True, data="my message".encode(), uuid="eaf10700-cb30-402d-b101-8e35d67cdb41")
-            #await MythicCallbackRPC().add_event_message(message=msg.response)
-            response = requests.get(config['mythic_address'] + "?{}".format(request.query_string), verify=False, data=request.body, cookies=request.cookies, headers=request.headers)
-        return raw(response.content, headers=config[request.app.name]['headers'], status=response.status_code)
-    except Exception as e:
-        if request is None:
-            await print_flush("Invalid HTTP Method - Likely HTTPS trying to talk to HTTP")
-            return server_error_handler(request, e)
-        if config[request.app.name]['debug']:
-            await print_flush("error in agent_message: {}".format(str(e)))
-        return server_error_handler(request, e)
-
-
-
-if __name__ == "__main__":
-    sys.path.append("/Mythic/mythic")
-    from C2ProfileBase import *
-    from MythicCallbackRPC import *
-    config_file = open("config.json", 'rb')
-    main_config = json.loads(config_file.read().decode('utf-8'))
-    print("Opening config and starting instances...")
-    sys.stdout.flush()
-    # basic mapping of the general endpoints to the real endpoints
-    try:
-        config['mythic_address'] = os.environ['MYTHIC_ADDRESS']
-    except Exception as e:
-        print("failed to find MYTHIC_ADDRESS environment variable")
-        sys.stdout.flush()
-        sys.exit(1)
-    # now look at the specific instances to start
-    for inst in main_config['instances']:
-        config[str(inst['port'])] = {'debug': inst['debug'],
-                                     'headers': inst['ServerHeaders']}
-        if inst['debug']:
-            print("Debugging statements are enabled. This gives more context, but might be a performance hit")
-        else:
-            print("Debugging statements are disabled")
-        sys.stdout.flush()
-        # now to create an app instance to handle responses
-        app = Sanic(str(inst['port']))
-        app.config['REQUEST_MAX_SIZE'] = 1000000000
-        app.config['REQUEST_TIMEOUT'] = 600
-        app.config['RESPONSE_TIMEOUT'] = 600
-        app.add_route(agent_message, "/<uri:path>", methods=['GET','POST'])
-        app.add_route(agent_message, "/", methods=['GET','POST'])
-        app.error_handler.add(Exception, server_error_handler)
-        keyfile = Path(inst['key_path'])
-        certfile = Path(inst['cert_path'])
-        if keyfile.is_file() and certfile.is_file():
-            context = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)
-            context.load_cert_chain(inst['cert_path'], keyfile=inst['key_path'])
-            if inst['debug']:
-                server = app.create_server(host="0.0.0.0", port=inst['port'], ssl=context, debug=False, return_asyncio_server=True, access_log=True)
-            else:
-                server = app.create_server(host="0.0.0.0", port=inst['port'], ssl=context, debug=False, return_asyncio_server=True, access_log=False)
-            if inst['debug']:
-                print("using SSL for port {}".format(inst['port']))
-                sys.stdout.flush()
-        else:
-            if inst['debug']:
-                print("not using SSL for port {}".format(inst['port']))
-                sys.stdout.flush()
-            if inst['debug']:
-                server = app.create_server(host="0.0.0.0", port=inst['port'], debug=False, return_asyncio_server=True, access_log=True)
-            else:
-                server = app.create_server(host="0.0.0.0", port=inst['port'], debug=False, return_asyncio_server=True, access_log=False)
-        task = asyncio.ensure_future(server)
-
-    try:
-        loop = asyncio.get_event_loop()
-        def callback(fut):
-            try:
-                fetch_count = fut.result()
-            except:
-                print("port already in use")
-                sys.stdout.flush()
-                sys.exit()
-        task.add_done_callback(callback)
-        loop.run_forever()
-    except:
-        sys.exit()
-        loop.stop()

C2_Profiles/HTTP/mythic/C2ProfileBase.py

@@ -1,130 +0,0 @@
-from enum import Enum
-from abc import abstractmethod
-import json
-
-
-class ParameterType(Enum):
-    String = "String"
-    ChooseOne = "ChooseOne"
-    Array = "Array"
-    Date = "Date"
-    Dictionary = "Dictionary"
-
-
-class C2ProfileParameter:
-    def __init__(
-        self,
-        name: str,
-        description: str,
-        default_value: str = "",
-        randomize: bool = False,
-        format_string: str = "",
-        parameter_type: ParameterType = ParameterType.String,
-        required: bool = True,
-        verifier_regex: str = "",
-        choices: [str] = None,
-    ):
-        self.name = name
-        self.description = description
-        self.randomize = randomize
-        self.format_string = format_string
-        self.parameter_type = parameter_type
-        self.required = required
-        self.verifier_regex = verifier_regex
-        self.choices = choices
-        self.default_value = ""
-        if self.parameter_type == ParameterType.ChooseOne and choices is not None:
-            self.default_value = "\n".join(choices)
-        else:
-            self.default_value = default_value
-
-
-    def to_json(self):
-        return {
-            "name": self.name,
-            "description": self.description,
-            "default_value": self.default_value if self.parameter_type not in [ParameterType.Array, ParameterType.Dictionary] else json.dumps(self.default_value),
-            "randomize": self.randomize,
-            "format_string": self.format_string,
-            "required": self.required,
-            "parameter_type": self.parameter_type.value,
-            "verifier_regex": self.verifier_regex,
-        }
-
-
-class C2Profile:
-    @property
-    @abstractmethod
-    def name(self):
-        pass
-
-    @property
-    @abstractmethod
-    def description(self):
-        pass
-
-    @property
-    @abstractmethod
-    def author(self):
-        pass
-
-    @property
-    @abstractmethod
-    def is_p2p(self):
-        pass
-
-    @property
-    @abstractmethod
-    def is_server_routed(self):
-        pass
-
-    @property
-    @abstractmethod
-    def mythic_encrypts(self):
-        pass
-
-    @property
-    @abstractmethod
-    def parameters(self):
-        pass
-
-    def to_json(self):
-        return {
-            "name": self.name,
-            "description": self.description,
-            "author": self.author,
-            "mythic_encrypts": self.mythic_encrypts,
-            "is_p2p": self.is_p2p,
-            "is_server_routed": self.is_server_routed,
-            "params": [x.to_json() for x in self.parameters],
-        }
-
-
-class RPCStatus(Enum):
-    Success = "success"
-    Error = "error"
-
-
-class RPCResponse:
-    def __init__(self, status: RPCStatus = None, response: str = None):
-        self.status = status
-        self.response = response
-
-    @property
-    def status(self):
-        return self._status
-
-    @status.setter
-    def status(self, status):
-        self._status = status
-
-    @property
-    def response(self):
-        return self._response
-
-    @response.setter
-    def response(self, response):
-        self._response = response
-
-    def to_json(self):
-        return {"status": self.status.value, "response": self.response}

C2_Profiles/HTTP/mythic/MythicBaseRPC.py

@@ -1,99 +0,0 @@
-from aio_pika import connect_robust, IncomingMessage, Message
-import asyncio
-import uuid
-import json
-from enum import Enum
-
-
-class MythicStatus(Enum):
-    Success = "success"
-    Error = "error"
-
-
-class RPCResponse:
-    def __init__(self, resp: dict):
-        self._raw_resp = resp
-        if resp["status"] == "success":
-            self.status = MythicStatus.Success
-            self.response = resp["response"] if "response" in resp else ""
-            self.error_message = None
-        else:
-            self.status = MythicStatus.Error
-            self.error_message = resp["error"]
-            self.response = None
-
-    @property
-    def status(self):
-        return self._status
-
-    @status.setter
-    def status(self, status):
-        self._status = status
-
-    @property
-    def error_message(self):
-        return self._error_message
-
-    @error_message.setter
-    def error_message(self, error_message):
-        self._error_message = error_message
-
-    @property
-    def response(self):
-        return self._response
-
-    @response.setter
-    def response(self, response):
-        self._response = response
-
-
-class MythicBaseRPC:
-    def __init__(self):
-        self.connection = None
-        self.channel = None
-        self.callback_queue = None
-        self.futures = {}
-        self.loop = asyncio.get_event_loop()
-
-    async def connect(self):
-        config_file = open("/Mythic/mythic/rabbitmq_config.json", "rb")
-        main_config = json.loads(config_file.read().decode("utf-8"))
-        config_file.close()
-        self.connection = await connect_robust(
-            host=main_config["host"],
-            login=main_config["username"],
-            password=main_config["password"],
-            virtualhost=main_config["virtual_host"],
-        )
-        self.channel = await self.connection.channel()
-        self.callback_queue = await self.channel.declare_queue(exclusive=True)
-        await self.callback_queue.consume(self.on_response)
-
-        return self
-
-    def on_response(self, message: IncomingMessage):
-        future = self.futures.pop(message.correlation_id)
-        future.set_result(message.body)
-
-    async def call(self, n, receiver: str = None) -> RPCResponse:
-        if self.connection is None:
-            await self.connect()
-        correlation_id = str(uuid.uuid4())
-        future = self.loop.create_future()
-
-        self.futures[correlation_id] = future
-        if receiver is None:
-            router = "c2rpc_queue"
-        else:
-            router = "{}_rpc_queue".format(receiver)
-        await self.channel.default_exchange.publish(
-            Message(
-                json.dumps(n).encode(),
-                content_type="application/json",
-                correlation_id=correlation_id,
-                reply_to=self.callback_queue.name,
-            ),
-            routing_key=router,
-        )
-
-        return RPCResponse(json.loads(await future))

C2_Profiles/HTTP/mythic/MythicCallbackRPC.py

@@ -1,124 +0,0 @@
-from MythicBaseRPC import *
-import base64
-
-
-class MythicRPCResponse(RPCResponse):
-    def __init__(self, resp: RPCResponse):
-        super().__init__(resp._raw_resp)
-        if resp.status == MythicStatus.Success:
-            self.data = resp.response
-        else:
-            self.data = None
-
-    @property
-    def data(self):
-        return self._data
-
-    @data.setter
-    def data(self, data):
-        self._data = data
-
-
-class MythicCallbackRPC(MythicBaseRPC):
-    # returns dictionary of `{"raw": raw_tasking, "encrypted": base64(uuid+encrypted_tasking)}`
-    async def get_tasking(
-        self, uuid: str, tasking_size: int = 1
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "get_tasking",
-                "uuid": uuid,
-                "tasking_size": tasking_size,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def add_route(
-        self,
-        source_uuid: str,
-        destination_uuid: str,
-        direction: int = 1,
-        metadata: str = None,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "add_route",
-                "source": source_uuid,
-                "destination": destination_uuid,
-                "direction": direction,
-                "metadata": metadata,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def remove_route(
-        self,
-        source_uuid: str,
-        destination_uuid: str,
-        direction: int = 1,
-        metadata: str = None,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "remove_route",
-                "source": source_uuid,
-                "destination": destination_uuid,
-                "direction": direction,
-                "metadata": metadata,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def get_callback_info(self, uuid: str) -> MythicRPCResponse:
-        resp = await self.call({"action": "get_callback_info", "uuid": uuid})
-        return MythicRPCResponse(resp)
-
-    async def get_encryption_data(self, uuid: str, profile: str) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "get_encryption_data",
-                "uuid": uuid,
-                "c2_profile": profile,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def update_callback_info(self, uuid: str, info: dict) -> MythicRPCResponse:
-        resp = await self.call(
-            {"action": "update_callback_info", "uuid": uuid, "data": info}
-        )
-        return MythicRPCResponse(resp)
-
-    async def add_event_message(
-        self, message: str, level: str = "info"
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {"action": "add_event_message", "level": level, "message": message}
-        )
-        return MythicRPCResponse(resp)
-
-    async def encrypt_bytes(
-        self, data: bytes, uuid: str, with_uuid: bool = False,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "encrypt_bytes",
-                "data": base64.b64encode(data).decode(),
-                "uuid": uuid,
-                "with_uuid": with_uuid,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def decrypt_bytes(
-        self, data: bytes, uuid: str, with_uuid: bool = False,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "decrypt_bytes",
-                "uuid": uuid,
-                "data": base64.b64encode(data).decode(),
-                "with_uuid": with_uuid,
-            }
-        )
-        return MythicRPCResponse(resp)

C2_Profiles/HTTP/mythic/c2_functions/C2_RPC_functions.py

@@ -1,11 +0,0 @@
-from C2ProfileBase import *
-import MythicCallbackRPC
-
-# request is a dictionary: {"action": func_name, "message": "the input",  "task_id": task id num}
-# must return an RPCResponse() object and set .status to an instance of RPCStatus and response to str of message
-async def test(request):
-    response = RPCResponse()
-    response.status = RPCStatus.Success
-    response.response = "hello"
-    #resp = await MythicCallbackRPC.MythicCallbackRPC().add_event_message(message="got a POST message")
-    return response

C2_Profiles/HTTP/mythic/c2_functions/HTTP.py

@@ -1,195 +0,0 @@
-from C2ProfileBase import *
-
-
-class HTTP(C2Profile):
-    name = "HTTP"
-    description = "Uses HTTP(S) connections with a simple query parameter or basic POST messages. For more configuration options use dynamicHTTP."
-    author = "@its_a_feature_"
-    is_p2p = False
-    is_server_routed = False
-    mythic_encrypts = True
-    parameters = [
-        C2ProfileParameter(
-            name="callback_port",
-            description="Callback Port",
-            default_value="80",
-            verifier_regex="^[0-9]+$",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="killdate",
-            description="Kill Date",
-            parameter_type=ParameterType.Date,
-            default_value=365,
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="encrypted_exchange_check",
-            description="Perform Key Exchange",
-            choices=["T", "F"],
-            parameter_type=ParameterType.ChooseOne,
-        ),
-        C2ProfileParameter(
-            name="callback_jitter",
-            description="Callback Jitter in percent",
-            default_value="23",
-            verifier_regex="^[0-9]+$",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="domain_front",
-            description="Host header value for domain fronting",
-            default_value="",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="USER_AGENT",
-            description="User Agent",
-            default_value="Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="AESPSK",
-            description="Base64 of a 32B AES Key",
-            default_value="",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="callback_host",
-            description="Callback Host",
-            default_value="https://domain.com",
-            verifier_regex="^(http|https):\/\/[a-zA-Z0-9]+",
-        ),
-        C2ProfileParameter(
-            name="get_uri",
-            description="GET request URI",
-            default_value="index",
-            required=True,
-        ),
-        C2ProfileParameter(
-            name="post_uri",
-            description="POST request URI",
-            default_value="data",
-            required=True,
-        ),
-        C2ProfileParameter(
-            name="query_path_name",
-            description="Name of the query parameter",
-            default_value="q",
-            required=True,
-        ),
-        C2ProfileParameter(
-            name="proxy_host",
-            description="Proxy Host",
-            default_value="",
-            required=False,
-            verifier_regex="^$|^(http|https):\/\/[a-zA-Z0-9]+",
-        ),
-        C2ProfileParameter(
-            name="proxy_port",
-            description="Proxy Port",
-            default_value="",
-            verifier_regex="^$|^[0-9]+$",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="proxy_user",
-            description="Proxy Username",
-            default_value="",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="proxy_pass",
-            description="Proxy Password",
-            default_value="",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="callback_interval",
-            description="Callback Interval in seconds",
-            default_value="10",
-            verifier_regex="^[0-9]+$",
-            required=False,
-        ),
-    ]
-"""
-C2ProfileParameter(
-            name="callback_port",
-            description="Callback Port",
-            default_value="80",
-            verifier_regex="^[0-9]+$",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="encrypted_exchange_check",
-            description="Perform Key Exchange",
-            choices=["T", "F"],
-            parameter_type=ParameterType.ChooseOne,
-        ),
-        C2ProfileParameter(
-            name="callback_jitter",
-            description="Callback Jitter in percent",
-            default_value="23",
-            verifier_regex="^[0-9]+$",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="domain_front",
-            description="Host header value for domain fronting",
-            default_value="",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="callback_host",
-            description="Callback Host",
-            default_value="https://domain.com",
-            parameter_type=ParameterType.Array,
-            verifier_regex="^(http|https):\/\/[a-zA-Z0-9]+",
-        ),
-
-        C2ProfileParameter(
-            name="killdate",
-            description="Kill Date",
-            parameter_type=ParameterType.Date,
-            default_value=365,
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="USER_AGENT",
-            description="User Agent",
-            required=False,
-            parameter_type=ParameterType.Dictionary,
-            default_value=[
-                {
-                    "name": "USER_AGENT",
-                    "max": 1,
-                    "default_value": "Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko",
-                    "default_show": True,
-                },
-                {
-                    "name": "host",
-                    "max": 2,
-                    "default_value": "",
-                    "default_show": False,
-                },
-                {
-                    "name": "*",
-                    "max": -1,
-                    "default_value": "",
-                    "default_show": False
-                }
-            ]
-        ),
-        C2ProfileParameter(
-            name="AESPSK",
-            description="Base64 of a 32B AES Key",
-            default_value="",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="callback_interval",
-            description="Callback Interval in seconds",
-            default_value="10",
-            verifier_regex="^[0-9]+$",
-            required=False,
-        ),"""

C2_Profiles/HTTP/mythic/c2_service.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-cd /Mythic/mythic
-
-export PYTHONPATH=/Mythic:/Mythic/mythic
-
-python3.8 mythic_service.py

C2_Profiles/HTTP/mythic/mythic_service.py

@@ -1,410 +0,0 @@
-#!/usr/bin/env python3
-import aio_pika
-import os
-import time
-import sys
-import subprocess
-import _thread
-import base64
-import json
-import socket
-import asyncio
-import pathlib
-import traceback
-from C2ProfileBase import *
-from importlib import import_module, invalidate_caches
-from functools import partial
-
-credentials = None
-connection_params = None
-running = False
-process = None
-thread = None
-hostname = ""
-output = ""
-exchange = None
-container_files_path = None
-
-
-def deal_with_stdout():
-    global process
-    global output
-    while True:
-        try:
-            for line in iter(process.stdout.readline, b""):
-                output += line.decode("utf-8")
-        except Exception as e:
-            print("Exiting thread due to: {}\n".format(str(e)))
-            sys.stdout.flush()
-            break
-
-
-def import_all_c2_functions():
-    import glob
-
-    # Get file paths of all modules.
-    modules = glob.glob("c2_functions/*.py")
-    invalidate_caches()
-    for x in modules:
-        if not x.endswith("__init__.py") and x[-3:] == ".py":
-            module = import_module("c2_functions." + pathlib.Path(x).stem, package=None)
-            for el in dir(module):
-                if "__" not in el:
-                    globals()[el] = getattr(module, el)
-
-
-async def send_status(message="", routing_key=""):
-    global exchange
-    try:
-        message_body = aio_pika.Message(message.encode())
-        await exchange.publish(message_body, routing_key=routing_key)
-    except Exception as e:
-        print("Exception in send_status: {}".format(str(e)))
-        sys.stdout.flush()
-
-
-async def callback(message: aio_pika.IncomingMessage):
-    global running
-    global process
-    global output
-    global thread
-    global hostname
-    global container_files_path
-    with message.process():
-        # messages of the form: c2.modify.PROFILE NAME.command
-        try:
-            command = message.routing_key.split(".")[3]
-            username = message.routing_key.split(".")[4]
-            server_path = container_files_path / "server"
-            # command = body.decode('utf-8')
-            if command == "start":
-                if not running:
-                    # make sure to start the /Apfell/server in the background
-                    os.chmod(server_path, mode=0o777)
-                    output = ""
-                    process = subprocess.Popen(
-                        str(server_path),
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.STDOUT,
-                        cwd=str(container_files_path),
-                    )
-                    thread = _thread.start_new_thread(deal_with_stdout, ())
-                    time.sleep(3)
-                    process.poll()
-                    if process.returncode is not None:
-                        # this means something went wrong and the process is dead
-                        running = False
-                        await send_status(
-                            message="Failed to start\nOutput: {}".format(output),
-                            routing_key="c2.status.{}.stopped.start.{}".format(
-                                hostname, username
-                            ),
-                        )
-                        output = ""
-                    else:
-                        running = True
-                        await send_status(
-                            message="Started with pid: {}...\nOutput: {}".format(
-                                str(process.pid), output
-                            ),
-                            routing_key="c2.status.{}.running.start.{}".format(
-                                hostname, username
-                            ),
-                        )
-                        output = ""
-                else:
-                    await send_status(
-                        message="Already running...\nOutput: {}".format(output),
-                        routing_key="c2.status.{}.running.start.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-            elif command == "stop":
-                if running:
-                    try:
-                        process.kill()
-                        process.communicate()
-                    except Exception as e:
-                        pass
-                    try:
-                        thread.exit()
-                    except Exception as e:
-                        pass
-                    running = False
-                    await send_status(
-                        message="Process killed...\nOld Output: {}".format(output),
-                        routing_key="c2.status.{}.stopped.stop.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-                else:
-                    await send_status(
-                        message="Process not running...\nOld Output: {}".format(output),
-                        routing_key="c2.status.{}.stopped.stop.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-                # make sure to stop the /Apfell/server in the background
-            elif command == "status":
-                if running:
-                    await send_status(
-                        message="Output: {}".format(output),
-                        routing_key="c2.status.{}.running.status.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-                else:
-                    await send_status(
-                        message="C2 is not running",
-                        routing_key="c2.status.{}.stopped.status.{}".format(
-                            hostname, username
-                        ),
-                    )
-            elif command == "get_config":
-                try:
-                    path = container_files_path / "config.json"
-                    file_data = open(path, "rb").read()
-                except Exception as e:
-                    file_data = b"File not found"
-                encoded_data = json.dumps(
-                    {
-                        "filename": "config.json",
-                        "data": base64.b64encode(file_data).decode("utf-8"),
-                    }
-                )
-                await send_status(
-                    message=encoded_data,
-                    routing_key="c2.status.{}.{}.get_config.{}".format(
-                        hostname, "running" if running else "stopped", username
-                    ),
-                )
-            elif command == "writefile":
-                try:
-                    message = json.loads(message.body.decode("utf-8"))
-                    file_path = container_files_path / message["file_path"]
-                    file_path = file_path.resolve()
-                    if container_files_path not in file_path.parents:
-                        response = {
-                            "status": "error",
-                            "error": "trying to break out of path",
-                        }
-                    else:
-                        file = open(file_path, "wb")
-                        file.write(base64.b64decode(message["data"]))
-                        file.close()
-                        response = {"status": "success", "file": message["file_path"]}
-                except Exception as e:
-                    response = {"status": "error", "error": str(e)}
-                await send_status(
-                    message=json.dumps(response),
-                    routing_key="c2.status.{}.{}.writefile.{}".format(
-                        hostname, "running" if running else "stopped", username
-                    ),
-                )
-            elif command == "sync_classes":
-                try:
-                    import_all_c2_functions()
-                    # c2profile = {}
-                    for cls in C2Profile.__subclasses__():
-                        c2profile = cls().to_json()
-                        break
-                    await send_status(
-                        message=json.dumps(c2profile),
-                        routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                            hostname, "running" if running else "stopped", username
-                        ),
-                    )
-                except Exception as e:
-                    await send_status(
-                        message='{"message": "Error while syncing info: {}"}'.format(
-                            str(traceback.format_exc())
-                        ),
-                        routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                            hostname, "running" if running else "stopped", username
-                        ),
-                    )
-            else:
-                print("Unknown command: {}".format(command))
-                sys.stdout.flush()
-        except Exception as e:
-            print("Failed overall message processing: " + str(e))
-            sys.stdout.flush()
-
-
-async def sync_classes():
-    try:
-        import_all_c2_functions()
-        c2profile = {}
-        for cls in C2Profile.__subclasses__():
-            c2profile = cls().to_json()
-            break
-        await send_status(
-            message=json.dumps(c2profile),
-            routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                hostname, "stopped", ""
-            ),
-        )
-    except Exception as e:
-        await send_status(
-            message='{"message": "Error while syncing info: {}"}'.format(
-                str(traceback.format_exc())
-            ),
-            routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                hostname, "stopped", ""
-            ),
-        )
-
-
-async def rabbit_c2_rpc_callback(
-    exchange: aio_pika.Exchange, message: aio_pika.IncomingMessage
-):
-    with message.process():
-        request = json.loads(message.body.decode())
-        if "action" in request:
-            response = await globals()[request["action"]](request)
-            response = json.dumps(response.to_json()).encode()
-        else:
-            response = json.dumps(
-                {"status": "error", "error": "Missing action"}
-            ).encode()
-        try:
-            await exchange.publish(
-                aio_pika.Message(body=response, correlation_id=message.correlation_id),
-                routing_key=message.reply_to,
-            )
-        except Exception as e:
-            print(
-                "Exception trying to send message back to container for rpc! " + str(e)
-            )
-            sys.stdout.flush()
-
-
-async def connect_and_consume_rpc():
-    connection = None
-    global hostname
-    while connection is None:
-        try:
-            connection = await aio_pika.connect_robust(
-                host="127.0.0.1",
-                login="mythic_user",
-                password="mythic_password",
-                virtualhost="mythic_vhost",
-            )
-            channel = await connection.channel()
-            # get a random queue that only the apfell server will use to listen on to catch all heartbeats
-            queue = await channel.declare_queue("{}_rpc_queue".format(hostname))
-            await channel.set_qos(prefetch_count=50)
-            try:
-                task = queue.consume(
-                    partial(rabbit_c2_rpc_callback, channel.default_exchange)
-                )
-                result = await asyncio.wait_for(task, None)
-            except Exception as e:
-                print("Exception in connect_and_consume .consume: {}".format(str(e)))
-                sys.stdout.flush()
-        except (ConnectionError, ConnectionRefusedError) as c:
-            print("Connection to rabbitmq failed, trying again...")
-            sys.stdout.flush()
-        except Exception as e:
-            print("Exception in connect_and_consume_rpc connect: {}".format(str(e)))
-            # print("Exception in connect_and_consume connect: {}".format(str(e)))
-            sys.stdout.flush()
-        await asyncio.sleep(2)
-
-
-async def mythic_service():
-    global hostname
-    global exchange
-    global container_files_path
-    connection = None
-    config_file = open("rabbitmq_config.json", "rb")
-    main_config = json.loads(config_file.read().decode("utf-8"))
-    config_file.close()
-    if main_config["name"] == "hostname":
-        hostname = socket.gethostname()
-    else:
-        hostname = main_config["name"]
-    container_files_path = pathlib.Path(
-        os.path.abspath(main_config["container_files_path"])
-    )
-    container_files_path = container_files_path / "c2_code"
-    while connection is None:
-        try:
-            connection = await aio_pika.connect_robust(
-                host=main_config["host"],
-                login=main_config["username"],
-                password=main_config["password"],
-                virtualhost=main_config["virtual_host"],
-            )
-        except Exception as e:
-            await asyncio.sleep(2)
-    try:
-        channel = await connection.channel()
-        exchange = await channel.declare_exchange(
-            "mythic_traffic", aio_pika.ExchangeType.TOPIC
-        )
-        queue = await channel.declare_queue("", exclusive=True)
-        await queue.bind(
-            exchange="mythic_traffic", routing_key="c2.modify.{}.#".format(hostname)
-        )
-        # just want to handle one message at a time so we can clean up and be ready
-        await channel.set_qos(prefetch_count=30)
-        print("Listening for c2.modify.{}.#".format(hostname))
-        sys.stdout.flush()
-        task = queue.consume(callback)
-        await sync_classes()
-        task4 = asyncio.ensure_future(connect_and_consume_rpc())
-        result = await asyncio.gather(task, task4)
-        # send_status(message="", routing_key="c2.status.{}.stopped.stop".format(hostname))
-    except Exception as e:
-        print(str(traceback.format_exc()))
-        sys.stdout.flush()
-
-
-async def heartbeat_loop():
-    config_file = open("rabbitmq_config.json", "rb")
-    main_config = json.loads(config_file.read().decode("utf-8"))
-    config_file.close()
-    if main_config["name"] == "hostname":
-        hostname = socket.gethostname()
-    else:
-        hostname = main_config["name"]
-    while True:
-        try:
-            connection = await aio_pika.connect_robust(
-                host=main_config["host"],
-                login=main_config["username"],
-                password=main_config["password"],
-                virtualhost=main_config["virtual_host"],
-            )
-            channel = await connection.channel()
-            # declare our heartbeat exchange that everybody will publish to, but only the apfell server will are about
-            exchange = await channel.declare_exchange(
-                "mythic_traffic", aio_pika.ExchangeType.TOPIC
-            )
-        except Exception as e:
-            print(str(e))
-            await asyncio.sleep(2)
-            continue
-        while True:
-            try:
-                # routing key is ignored for fanout, it'll go to anybody that's listening, which will only be the server
-                await exchange.publish(
-                    aio_pika.Message("heartbeat".encode()),
-                    routing_key="c2.heartbeat.{}".format(hostname),
-                )
-                await asyncio.sleep(10)
-            except Exception as e:
-                print(str(e))
-                # if we get an exception here, break out to the bigger loop and try to connect again
-                break
-
-# start our service
-loop = asyncio.get_event_loop()
-loop.create_task(mythic_service())
-loop.create_task(heartbeat_loop())
-loop.run_forever()

C2_Profiles/HTTP/mythic/rabbitmq_config.json

@@ -1,8 +0,0 @@
-{
-  "username": "mythic_user",
-  "password": "mythic_password",
-  "virtual_host": "mythic_vhost",
-  "host": "127.0.0.1",
-  "name": "hostname",
-  "container_files_path": "/Mythic/"
-}

C2_Profiles/dynamicHTTP/Dockerfile

@@ -1 +0,0 @@
-From itsafeaturemythic/python38_sanic_c2profile:0.0.1

C2_Profiles/dynamicHTTP/c2_code/agent_config.json

@@ -1,141 +0,0 @@
-{
-  "GET": {
-    "ServerBody": [
-      {
-        "function": "base64",
-        "parameters": []
-      },
-      {
-        "function": "prepend",
-        "parameters": ["!function(e,t){\"use strict\";\"object\"==typeof module&&\"object\"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error(\"jQuery requires a window with a document\");return t(e)}:t(e)}(\"undefined\"!=typeof window?window:this,function(e,t){\"use strict\";var n=[],r=e.document,i=Object.getPrototypeOf,o=n.slice,a=n.concat,s=n.push,u=n.indexOf,l={},c=l.toString,f=l.hasOwnProperty,p=f.toString,d=p.call(Object),h={},g=function e(t){return\"function\"==typeof t&&\"number\"!=typeof t.nodeType},y=function e(t){return null!=t&&t===t.window},v={type:!0,src:!0,noModule:!0};function m(e,t,n){var i,o=(t=t||r).createElement(\"script\");if(o.text=e,n)for(i in v)n[i]&&(o[i]=n[i]);t.head.appendChild(o).parentNode.removeChild(o)}function x(e){return null==e?e+\"\":\"object\"==typeof e||\"function\"==typeof e?l[c.call(e)]||\"object\":typeof e}var b=\"3.3.1\",w=function(e,t){return new w.fn.init(e,t)},T=/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g;w.fn=w.prototype={jquery:\"3.3.1\",constructor:w,length:0,toArray:function(){return o.call(this)},get:function(e){return null==e?o.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=w.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return w.each(this,e)},map:function(e){return this.pushStack(w.map(this,function(t,n){return e.call(t,n,t)}))},slice:function(){return this.pushStack(o.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(n>=0&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:s,sort:n.sort,splice:n.splice},w.extend=w.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for(\"boolean\"==typeof a&&(l=a,a=arguments[s]||{},s++),\"object\"==typeof a||g(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)n=a[t],a!==(r=e[t])&&(l&&r&&(w.isPlainObject(r)||(i=Array.isArray(r)))?(i?(i=!1,o=n&&Array.isArray(n)?n:[]):o=n&&w.isPlainObject(n)?n:{},a[t]=w.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},w.extend({expando:\"jQuery\"+(\"3.3.1\"+Math.random()).replace(/\\D/g,\"\"),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||\"[object Object]\"!==c.call(e))&&(!(t=i(e))||\"function\"==typeof(n=f.call(t,\"constructor\")&&t.constructor)&&p.call(n)===d)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e){m(e)},each:function(e,t){var n,r=0;if(C(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},trim:function(e){return null==e?\"\":(e+\"\").replace(T,\"\")},makeArray:function(e,t){var n=t||[];return null!=e&&(C(Object(e))?w.merge(n,\"string\"==typeof e?[e]:e):s.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:u.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r,i=[],o=0,a=e.length,s=!n;o<a;o++)(r=!t(e[o],o))!==s&&i.push(e[o]);return i},map:function(e,t,n){var r,i,o=0,s=[];if(C(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&s.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&s.push(i);return a.apply([],s)},guid:1,support:h}),\"function\"==typeof Symbol&&(w.fn[Symbol.iterator]=n[Symbol.iterator]),w.each(\"Boolean Number String Function Array Date RegExp Object Error Symbol\".split(\" \"),function(e,t){l[\"[object \"+t+\"]\"]=t.toLowerCase()});function C(e){var t=!!e&&\"length\"in e&&e.length,n=x(e);return!g(e)&&!y(e)&&(\"array\"===n||0===t||\"number\"==typeof t&&t>0&&t-1 in e)}var E=function(e){var t,n,r,i,o,a,s,u,l,c,f,p,d,h,g,y,v,m,x,b=\"sizzle\"+1*new Date,w=e.document,T=0,C=0,E=ae(),k=ae(),S=ae(),D=function(e,t){return e===t&&(f=!0),0},N={}.hasOwnProperty,A=[],j=A.pop,q=A.push,L=A.push,H=A.slice,O=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},P=\"\r"]
-      },
-      {
-        "function": "prepend",
-        "parameters": ["/*! jQuery v3.3.1 | (c) JS Foundation and other contributors | jquery.org/license */"]
-      },
-      {
-        "function": "append",
-        "parameters": ["\".(o=t.documentElement,Math.max(t.body[\"scroll\"+e],o[\"scroll\"+e],t.body[\"offset\"+e],o[\"offset\"+e],o[\"client\"+e])):void 0===i?w.css(t,n,s):w.style(t,n,i,s)},t,a?i:void 0,a)}})}),w.each(\"blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu\".split(\" \"),function(e,t){w.fn[t]=function(e,n){return arguments.length>0?this.on(t,null,e,n):this.trigger(t)}}),w.fn.extend({hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),w.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,\"**\"):this.off(t,e||\"**\",n)}}),w.proxy=function(e,t){var n,r,i;if(\"string\"==typeof t&&(n=e[t],t=e,e=n),g(e))return r=o.call(arguments,2),i=function(){return e.apply(t||this,r.concat(o.call(arguments)))},i.guid=e.guid=e.guid||w.guid++,i},w.holdReady=function(e){e?w.readyWait++:w.ready(!0)},w.isArray=Array.isArray,w.parseJSON=JSON.parse,w.nodeName=N,w.isFunction=g,w.isWindow=y,w.camelCase=G,w.type=x,w.now=Date.now,w.isNumeric=function(e){var t=w.type(e);return(\"number\"===t||\"string\"===t)&&!isNaN(e-parseFloat(e))},\"function\"==typeof define&&define.amd&&define(\"jquery\",[],function(){return w});var Jt=e.jQuery,Kt=e.$;return w.noConflict=function(t){return e.$===w&&(e.$=Kt),t&&e.jQuery===w&&(e.jQuery=Jt),w},t||(e.jQuery=e.$=w),w});"]
-      }
-    ],
-    "ServerHeaders": {
-        "Server": "NetDNA-cache/2.2",
-        "Cache-Control": "max-age=0, no-cache",
-        "Pragma": "no-cache",
-        "Connection": "keep-alive",
-        "Content-Type": "application/javascript; charset=utf-8"
-      },
-    "ServerCookies": {},
-    "AgentMessage": [{
-      "urls": ["http://192.168.205.151:9000"],
-      "uri": "/<test:string>",
-      "urlFunctions": [
-        {
-          "name": "<test:string>",
-          "value": "",
-          "transforms": [
-            {
-              "function": "choose_random",
-              "parameters": ["jquery-3.3.1.min.js","jquery-3.3.1.map"]
-            }
-          ]
-        }
-      ],
-      "AgentHeaders": {
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        "Host": "code.jquery.com",
-        "Referer": "http://code.jquery.com/",
-        "Accept-Encoding": "gzip, deflate",
-        "User-Agent": "Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko"
-      },
-      "QueryParameters": [
-          {
-            "name": "q",
-            "value": "message",
-            "transforms": [
-            ]
-          }
-      ],
-      "Cookies": [
-         {
-          "name": "__cfduid",
-          "value": "",
-          "transforms": [
-            {
-              "function": "random_alpha",
-              "parameters": [30]
-            },
-            {
-              "function": "base64",
-              "parameters": []
-            }
-          ]
-        }
-      ],
-      "Body": []
-    }]
-  },
-  "POST": {
-    "ServerBody": [],
-    "ServerCookies": {},
-    "ServerHeaders": {
-          "Server": "NetDNA-cache/2.2",
-          "Cache-Control": "max-age=0, no-cache",
-          "Pragma": "no-cache",
-          "Connection": "keep-alive",
-          "Content-Type": "application/javascript; charset=utf-8"
-        },
-    "AgentMessage": [{
-      "urls": ["http://192.168.205.151:9000"],
-      "uri": "/download.php",
-      "urlFunctions": [],
-      "QueryParameters": [
-        {
-          "name": "bob2",
-          "value": "justforvalidation",
-          "transforms": []
-        }
-      ],
-      "AgentHeaders": {
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        "Host": "code.jquery.com",
-        "Referer": "http://code.jquery.com/",
-        "Accept-Encoding": "gzip, deflate",
-        "User-Agent": "Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko"
-      },
-      "Cookies": [
-        {
-          "name": "BobCookie",
-          "value": "splat",
-          "transforms": [
-            {
-              "function": "prepend",
-              "parameters": [
-                "splatity_"
-              ]
-            }
-          ]
-        }
-      ],
-      "Body": [
-        {
-          "function": "base64",
-          "parameters": []
-        },
-        {
-          "function": "prepend",
-          "parameters": ["<html>"]
-        },
-          {
-          "function": "append",
-          "parameters": ["</html>"]
-        }
-      ]
-    }]
-  },
-  "jitter": 50,
-  "interval": 10,
-  "chunk_size": 5120000,
-  "key_exchange": true,
-  "kill_date": ""
-}

C2_Profiles/dynamicHTTP/c2_code/config.json

@@ -1,160 +0,0 @@
-{
-  "instances": [
-  {
-    "GET": {
-    "ServerBody": [
-      {
-        "function": "base64",
-        "parameters": []
-      },
-      {
-        "function": "prepend",
-        "parameters": ["!function(e,t){\"use strict\";\"object\"==typeof module&&\"object\"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error(\"jQuery requires a window with a document\");return t(e)}:t(e)}(\"undefined\"!=typeof window?window:this,function(e,t){\"use strict\";var n=[],r=e.document,i=Object.getPrototypeOf,o=n.slice,a=n.concat,s=n.push,u=n.indexOf,l={},c=l.toString,f=l.hasOwnProperty,p=f.toString,d=p.call(Object),h={},g=function e(t){return\"function\"==typeof t&&\"number\"!=typeof t.nodeType},y=function e(t){return null!=t&&t===t.window},v={type:!0,src:!0,noModule:!0};function m(e,t,n){var i,o=(t=t||r).createElement(\"script\");if(o.text=e,n)for(i in v)n[i]&&(o[i]=n[i]);t.head.appendChild(o).parentNode.removeChild(o)}function x(e){return null==e?e+\"\":\"object\"==typeof e||\"function\"==typeof e?l[c.call(e)]||\"object\":typeof e}var b=\"3.3.1\",w=function(e,t){return new w.fn.init(e,t)},T=/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g;w.fn=w.prototype={jquery:\"3.3.1\",constructor:w,length:0,toArray:function(){return o.call(this)},get:function(e){return null==e?o.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=w.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return w.each(this,e)},map:function(e){return this.pushStack(w.map(this,function(t,n){return e.call(t,n,t)}))},slice:function(){return this.pushStack(o.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(n>=0&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:s,sort:n.sort,splice:n.splice},w.extend=w.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for(\"boolean\"==typeof a&&(l=a,a=arguments[s]||{},s++),\"object\"==typeof a||g(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)n=a[t],a!==(r=e[t])&&(l&&r&&(w.isPlainObject(r)||(i=Array.isArray(r)))?(i?(i=!1,o=n&&Array.isArray(n)?n:[]):o=n&&w.isPlainObject(n)?n:{},a[t]=w.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},w.extend({expando:\"jQuery\"+(\"3.3.1\"+Math.random()).replace(/\\D/g,\"\"),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||\"[object Object]\"!==c.call(e))&&(!(t=i(e))||\"function\"==typeof(n=f.call(t,\"constructor\")&&t.constructor)&&p.call(n)===d)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e){m(e)},each:function(e,t){var n,r=0;if(C(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},trim:function(e){return null==e?\"\":(e+\"\").replace(T,\"\")},makeArray:function(e,t){var n=t||[];return null!=e&&(C(Object(e))?w.merge(n,\"string\"==typeof e?[e]:e):s.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:u.call(t,e,n)},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r,i=[],o=0,a=e.length,s=!n;o<a;o++)(r=!t(e[o],o))!==s&&i.push(e[o]);return i},map:function(e,t,n){var r,i,o=0,s=[];if(C(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&s.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&s.push(i);return a.apply([],s)},guid:1,support:h}),\"function\"==typeof Symbol&&(w.fn[Symbol.iterator]=n[Symbol.iterator]),w.each(\"Boolean Number String Function Array Date RegExp Object Error Symbol\".split(\" \"),function(e,t){l[\"[object \"+t+\"]\"]=t.toLowerCase()});function C(e){var t=!!e&&\"length\"in e&&e.length,n=x(e);return!g(e)&&!y(e)&&(\"array\"===n||0===t||\"number\"==typeof t&&t>0&&t-1 in e)}var E=function(e){var t,n,r,i,o,a,s,u,l,c,f,p,d,h,g,y,v,m,x,b=\"sizzle\"+1*new Date,w=e.document,T=0,C=0,E=ae(),k=ae(),S=ae(),D=function(e,t){return e===t&&(f=!0),0},N={}.hasOwnProperty,A=[],j=A.pop,q=A.push,L=A.push,H=A.slice,O=function(e,t){for(var n=0,r=e.length;n<r;n++)if(e[n]===t)return n;return-1},P=\"\r"]
-      },
-      {
-        "function": "prepend",
-        "parameters": ["/*! jQuery v3.3.1 | (c) JS Foundation and other contributors | jquery.org/license */"]
-      },
-      {
-        "function": "append",
-        "parameters": ["\".(o=t.documentElement,Math.max(t.body[\"scroll\"+e],o[\"scroll\"+e],t.body[\"offset\"+e],o[\"offset\"+e],o[\"client\"+e])):void 0===i?w.css(t,n,s):w.style(t,n,i,s)},t,a?i:void 0,a)}})}),w.each(\"blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu\".split(\" \"),function(e,t){w.fn[t]=function(e,n){return arguments.length>0?this.on(t,null,e,n):this.trigger(t)}}),w.fn.extend({hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),w.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,\"**\"):this.off(t,e||\"**\",n)}}),w.proxy=function(e,t){var n,r,i;if(\"string\"==typeof t&&(n=e[t],t=e,e=n),g(e))return r=o.call(arguments,2),i=function(){return e.apply(t||this,r.concat(o.call(arguments)))},i.guid=e.guid=e.guid||w.guid++,i},w.holdReady=function(e){e?w.readyWait++:w.ready(!0)},w.isArray=Array.isArray,w.parseJSON=JSON.parse,w.nodeName=N,w.isFunction=g,w.isWindow=y,w.camelCase=G,w.type=x,w.now=Date.now,w.isNumeric=function(e){var t=w.type(e);return(\"number\"===t||\"string\"===t)&&!isNaN(e-parseFloat(e))},\"function\"==typeof define&&define.amd&&define(\"jquery\",[],function(){return w});var Jt=e.jQuery,Kt=e.$;return w.noConflict=function(t){return e.$===w&&(e.$=Kt),t&&e.jQuery===w&&(e.jQuery=Jt),w},t||(e.jQuery=e.$=w),w});"]
-      }
-    ],
-    "ServerHeaders": {
-        "Server": "NetDNA-cache/2.2",
-        "Cache-Control": "max-age=0, no-cache",
-        "Pragma": "no-cache",
-        "Connection": "keep-alive",
-        "Content-Type": "application/javascript; charset=utf-8"
-      },
-    "ServerCookies": {},
-    "AgentMessage": [{
-      "urls": ["http://192.168.205.151:9000"],
-      "uri": "/<test:string>",
-      "urlFunctions": [
-        {
-          "name": "<test:string>",
-          "value": "",
-          "transforms": [
-            {
-              "function": "choose_random",
-              "parameters": ["jquery-3.3.1.min.js","jquery-3.3.1.map"]
-            }
-          ]
-        }
-      ],
-      "AgentHeaders": {
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        "Host": "code.jquery.com",
-        "Referer": "http://code.jquery.com/",
-        "Accept-Encoding": "gzip, deflate",
-        "User-Agent": "Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko"
-      },
-      "QueryParameters": [
-          {
-            "name": "q",
-            "value": "message",
-            "transforms": [
-            ]
-          }
-      ],
-      "Cookies": [
-         {
-          "name": "__cfduid",
-          "value": "",
-          "transforms": [
-            {
-              "function": "random_alpha",
-              "parameters": [30]
-            },
-            {
-              "function": "base64",
-              "parameters": []
-            }
-          ]
-        }
-      ],
-      "Body": []
-    }]
-  },
-    "POST": {
-    "ServerBody": [],
-    "ServerCookies": {},
-    "ServerHeaders": {
-          "Server": "NetDNA-cache/2.2",
-          "Cache-Control": "max-age=0, no-cache",
-          "Pragma": "no-cache",
-          "Connection": "keep-alive",
-          "Content-Type": "application/javascript; charset=utf-8"
-        },
-    "AgentMessage": [{
-      "urls": ["http://192.168.205.151:9000"],
-      "uri": "/download.php",
-      "urlFunctions": [],
-      "QueryParameters": [
-        {
-          "name": "bob2",
-          "value": "justforvalidation",
-          "transforms": []
-        }
-      ],
-      "AgentHeaders": {
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        "Host": "code.jquery.com",
-        "Referer": "http://code.jquery.com/",
-        "Accept-Encoding": "gzip, deflate",
-        "User-Agent": "Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko"
-      },
-      "Cookies": [
-        {
-          "name": "BobCookie",
-          "value": "splat",
-          "transforms": [
-            {
-              "function": "prepend",
-              "parameters": [
-                "splatity_"
-              ]
-            }
-          ]
-        }
-      ],
-      "Body": [
-        {
-          "function": "base64",
-          "parameters": []
-        },
-        {
-          "function": "prepend",
-          "parameters": ["<html>"]
-        },
-          {
-          "function": "append",
-          "parameters": ["</html>"]
-        }
-      ]
-    }]
-  },
-    "no_match": {
-      "action": "return_file",
-      "redirect": "http://example.com",
-      "proxy_get": {
-        "url": "https://www.google.com",
-        "status": 200
-      },
-      "proxy_post": {
-        "url": "https://www.example.com",
-        "status": 200
-      },
-      "return_file": {
-        "name": "fake.html",
-        "status": 404
-      }
-    },
-    "port": 9000,
-    "key_path": "",
-    "cert_path": "",
-    "debug": false
-    }
-  ]
-}

C2_Profiles/dynamicHTTP/c2_code/config_linter.py

@@ -1,595 +0,0 @@
-#! /usr/bin/env python3
-import json
-import sys
-import os
-
-
-class bcolors:
-    HEADER = "\033[95m"
-    OKBLUE = "\033[94m"
-    OKGREEN = "\033[92m"
-    WARNING = "\033[93m"
-    FAIL = "\033[91m"
-    ENDC = "\033[0m"
-    BOLD = "\033[1m"
-    UNDERLINE = "\033[4m"
-
-
-def check_server_layout(server_config):
-    if "instances" not in server_config:
-        print(
-            f'{bcolors.FAIL}[-]{bcolors.ENDC} config.json must start with "instances"'
-        )
-
-    for inst in server_config["instances"]:
-        # loop through all the instances listed to see if the supplied config matches one of them
-        for method in ["GET", "POST"]:
-            if method not in inst:
-                print(
-                    f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "{method}" element in instance'
-                )
-                sys.exit(1)
-            if "ServerBody" not in inst[method]:
-                print(
-                    f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "ServerBody" array in {method}'
-                )
-                sys.exit(1)
-            for f in inst[method]["ServerBody"]:
-                if "function" not in f:
-                    print(
-                        f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "function" name in {method} ServerBody'
-                    )
-                    sys.exit(1)
-                if "parameters" not in f:
-                    print(
-                        f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "parameters" array in {method} in ServerBody (can be an empty array indicated by []'
-                    )
-                    sys.exit(1)
-            if "ServerHeaders" not in inst[method]:
-                print(
-                    f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "ServerHeaders" dictionary'
-                )
-                sys.exit(1)
-            if "ServerCookies" not in inst[method]:
-                print(
-                    f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "ServerCookies" dictionary'
-                )
-                sys.exit(1)
-            if "AgentMessage" not in inst[method]:
-                print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "AgentMessage" array')
-                sys.exit(1)
-            if len(inst[method]["AgentMessage"]) == 0:
-                print(
-                    f'[*] "AgentMessage" array is empty, so you won\'t be able to do {method} messages'
-                )
-            for m in inst[method]["AgentMessage"]:
-                if "urls" not in m:
-                    print(
-                        '[-] Missing "urls" array indicating urls where the agent will reach out to'
-                    )
-                    sys.exit(1)
-                if "uri" not in m:
-                    print(
-                        '[-] Missing "uri" indicator of what the URI will be. If not in use, set to empty string'
-                    )
-                    sys.exit(1)
-                if "urlFunctions" not in m:
-                    print(
-                        '[-] Missing "urlFunctions" array, if you don\'t intent to do any manipulations here, set to empty array []'
-                    )
-                    sys.exit(1)
-                for f in m["urlFunctions"]:
-                    if "name" not in f:
-                        print('[-] Missing "name" parameter in urlFunction')
-                        sys.exit(1)
-                    if "value" not in f:
-                        print(
-                            '[-] Missing "value" parameter in urlFunction. This is the starting value before transforms are applied'
-                        )
-                        sys.exit(1)
-                    if "transforms" not in f:
-                        print(
-                            '[-] Missing "transforms" array. If no transforms needed, set to empty array []'
-                        )
-                        sys.exit(1)
-                    for t in f["transforms"]:
-                        if "function" not in t:
-                            print(
-                                '[-] Missing "function" name in transforms in urlFunctions'
-                            )
-                            sys.exit(1)
-                        if "parameters" not in t:
-                            print(
-                                '[-] Missing "parameters" array in transforms in urlFunctions (can be an empty array indicated by []'
-                            )
-                            sys.exit(1)
-                if "AgentHeaders" not in m:
-                    print(
-                        '[-] Missing "AgentHeaders" dictionary, this can be blank if the agent won\'t set any headers (i.e. {}'
-                    )
-                    sys.exit(1)
-                if "QueryParameters" not in m:
-                    print(
-                        '[-] Missing "QueryParameters" array in GET. If no query parameters will be set, leave as empty array []'
-                    )
-                    sys.exit(1)
-                for f in m["QueryParameters"]:
-                    if "name" not in f:
-                        print('[-] Missing "name" parameter in QueryParameters')
-                        sys.exit(1)
-                    if "value" not in f:
-                        print(
-                            '[-] Missing "value" parameter in QueryParameters. This is the starting value before transforms are applied'
-                        )
-                        sys.exit(1)
-                    if "transforms" not in f:
-                        print(
-                            '[-] Missing "transforms" array. If no transforms needed, set to empty array []'
-                        )
-                        sys.exit(1)
-                    for t in f["transforms"]:
-                        if "function" not in t:
-                            print(
-                                '[-] Missing "function" name in transforms in QueryParameters'
-                            )
-                            sys.exit(1)
-                        if "parameters" not in t:
-                            print(
-                                '[-] Missing "parameters" array in transforms in QueryParameters (can be an empty array indicated by []'
-                            )
-                            sys.exit(1)
-                if "Cookies" not in m:
-                    print(
-                        '[-] Missing "Cookies" array in GET. If none will be set, leave as empty array []'
-                    )
-                    sys.exit(1)
-                for f in m["Cookies"]:
-                    if "name" not in f:
-                        print('[-] Missing "name" parameter in Cookies')
-                        sys.exit(1)
-                    if "value" not in f:
-                        print(
-                            '[-] Missing "value" parameter in Cookies. This is the starting value before transforms are applied'
-                        )
-                        sys.exit(1)
-                    if "transforms" not in f:
-                        print(
-                            '[-] Missing "transforms" array. If no transforms needed, set to empty array []'
-                        )
-                        sys.exit(1)
-                    for t in f["transforms"]:
-                        if "function" not in t:
-                            print(
-                                '[-] Missing "function" name in transforms in Cookies'
-                            )
-                            sys.exit(1)
-                        if "parameters" not in t:
-                            print(
-                                '[-] Missing "parameters" array in transforms in Cookies (can be an empty array indicated by []'
-                            )
-                            sys.exit(1)
-                if "Body" not in m:
-                    print(
-                        '[-] Missing "Body" array in GET message. If none will be supplied, set as empty array []'
-                    )
-                    sys.exit(1)
-        if "no_match" not in inst:
-            print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "no_match" dictionary')
-            sys.exit(1)
-        if "action" not in inst["no_match"]:
-            print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "action" key in "no_match"')
-            sys.exit(1)
-        if inst["no_match"]["action"] not in [
-            "redirect",
-            "proxy_get",
-            "proxy_post",
-            "return_file",
-        ]:
-            print(
-                f"{bcolors.FAIL}[-]{bcolors.ENDC} no_match action isn't in the approved list"
-            )
-            sys.exit(1)
-        if "redirect" not in inst["no_match"]:
-            print(
-                f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "redirect" option in no_match'
-            )
-            sys.exit(1)
-        if "proxy_get" not in inst["no_match"]:
-            print(
-                f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "proxy_get" option in no_match'
-            )
-            sys.exit(1)
-        if "url" not in inst["no_match"]["proxy_get"]:
-            print(
-                f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "url" in no_match\'s proxy_get dictionary'
-            )
-            sys.exit(1)
-        if "status" not in inst["no_match"]["proxy_get"]:
-            print(
-                f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "status" code for no_match\'s proxy_get dictionary'
-            )
-            sys.exit(1)
-        if "proxy_post" not in inst["no_match"]:
-            print(
-                f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "proxy_post" option in no_match'
-            )
-            sys.exit(1)
-        if "url" not in inst["no_match"]["proxy_post"]:
-            print(
-                f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "url" in no_match\'s proxy_post dictionary'
-            )
-            sys.exit(1)
-        if "status" not in inst["no_match"]["proxy_post"]:
-            print(
-                f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "status" code in no_match\'s proxy_post dictionary'
-            )
-            sys.exit(1)
-        if "return_file" not in inst["no_match"]:
-            print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "return_file" in no_match')
-            sys.exit(1)
-        if "name" not in inst["no_match"]["return_file"]:
-            print(
-                f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "name" for the file to be returned in no_match case'
-            )
-            sys.exit(1)
-        if not os.path.exists(inst["no_match"]["return_file"]["name"]):
-            print(
-                f'{bcolors.FAIL}[-]{bcolors.ENDC} File specified in "no_match" case for "return_file" can\'t be found'
-            )
-            sys.exit(1)
-        if "status" not in inst["no_match"]["return_file"]:
-            print(
-                f'{bcolors.FAIL}[-]{bcolors.ENDC} Misisng "status" return code for no_match\'s return_file'
-            )
-            sys.exit(1)
-        if "port" not in inst:
-            print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "port" in instance')
-            sys.exit(1)
-        if "key_path" not in inst:
-            print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "key_path" in instance')
-            sys.exit(1)
-        if inst["key_path"] != "" and not os.path.exists(inst["key_path"]):
-            print(f"{bcolors.FAIL}[-]{bcolors.ENDC} Key_path file can't be found")
-            sys.exit(1)
-        if "cert_path" not in inst:
-            print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "cert_path" in instance')
-            sys.exit(1)
-        if inst["cert_path"] != "" and not os.path.exists(inst["cert_path"]):
-            print(f"{bcolors.FAIL}[-]{bcolors.ENDC} cert_path file can't be found")
-            sys.exit(1)
-        if "debug" not in inst:
-            print(
-                f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "debug" boolean in instance'
-            )
-            sys.exit(1)
-
-
-def check_agent_config_layout(inst):
-    for method in ["GET", "POST"]:
-        if method not in inst:
-            print(
-                f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "{method}" element in instance'
-            )
-            sys.exit(1)
-        if "ServerBody" not in inst[method]:
-            print(
-                f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "ServerBody" array in {method}'
-            )
-            sys.exit(1)
-        for f in inst[method]["ServerBody"]:
-            if "function" not in f:
-                print(
-                    f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "function" name in {method} ServerBody'
-                )
-                sys.exit(1)
-            if "parameters" not in f:
-                print(
-                    f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "parameters" array in {method} in ServerBody (can be an empty array indicated by []'
-                )
-                sys.exit(1)
-        if "ServerHeaders" not in inst[method]:
-            print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "ServerHeaders" dictionary')
-            sys.exit(1)
-        if "ServerCookies" not in inst[method]:
-            print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "ServerCookies" dictionary')
-            sys.exit(1)
-        if "AgentMessage" not in inst[method]:
-            print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "AgentMessage" array')
-            sys.exit(1)
-        if len(inst[method]["AgentMessage"]) == 0:
-            print(
-                f'[*] "AgentMessage" array is empty, so you won\'t be able to do {method} messages'
-            )
-        for m in inst[method]["AgentMessage"]:
-            if "urls" not in m:
-                print(
-                    f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "urls" array indicating urls where the agent will reach out to'
-                )
-                sys.exit(1)
-            if "uri" not in m:
-                print(
-                    f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "uri" indicator of what the URI will be. If not in use, set to empty string'
-                )
-                sys.exit(1)
-            if "urlFunctions" not in m:
-                print(
-                    f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "urlFunctions" array, if you don\'t intent to do any manipulations here, set to empty array []'
-                )
-                sys.exit(1)
-            for f in m["urlFunctions"]:
-                if "name" not in f:
-                    print(
-                        f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "name" parameter in urlFunction'
-                    )
-                    sys.exit(1)
-                if "value" not in f:
-                    print(
-                        f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "value" parameter in urlFunction. This is the starting value before transforms are applied'
-                    )
-                    sys.exit(1)
-                if "transforms" not in f:
-                    print(
-                        f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "transforms" array. If no transforms needed, set to empty array []'
-                    )
-                    sys.exit(1)
-                for t in f["transforms"]:
-                    if "function" not in t:
-                        print(
-                            f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "function" name in transforms in urlFunctions'
-                        )
-                        sys.exit(1)
-                    if "parameters" not in t:
-                        print(
-                            f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "parameters" array in transforms in urlFunctions (can be an empty array indicated by []'
-                        )
-                        sys.exit(1)
-            if "AgentHeaders" not in m:
-                print(
-                    f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "AgentHeaders" dictionary, this can be blank if the agent won\'t set any headers'
-                )
-                sys.exit(1)
-            if "QueryParameters" not in m:
-                print(
-                    f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "QueryParameters" array in GET. If no query parameters will be set, leave as empty array []'
-                )
-                sys.exit(1)
-            for f in m["QueryParameters"]:
-                if "name" not in f:
-                    print(
-                        f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "name" parameter in QueryParameters'
-                    )
-                    sys.exit(1)
-                if "value" not in f:
-                    print(
-                        '[-] Missing "value" parameter in QueryParameters. This is the starting value before transforms are applied'
-                    )
-                    sys.exit(1)
-                if "transforms" not in f:
-                    print(
-                        f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "transforms" array. If no transforms needed, set to empty array []'
-                    )
-                    sys.exit(1)
-                for t in f["transforms"]:
-                    if "function" not in t:
-                        print(
-                            f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "function" name in transforms in QueryParameters'
-                        )
-                        sys.exit(1)
-                    if "parameters" not in t:
-                        print(
-                            f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "parameters" array in transforms in QueryParameters (can be an empty array indicated by []'
-                        )
-                        sys.exit(1)
-            if "Cookies" not in m:
-                print(
-                    f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "Cookies" array in GET. If none will be set, leave as empty array []'
-                )
-                sys.exit(1)
-            for f in m["Cookies"]:
-                if "name" not in f:
-                    print(
-                        f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "name" parameter in Cookies'
-                    )
-                    sys.exit(1)
-                if "value" not in f:
-                    print(
-                        f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "value" parameter in Cookies. This is the starting value before transforms are applied'
-                    )
-                    sys.exit(1)
-                if "transforms" not in f:
-                    print(
-                        f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "transforms" array. If no transforms needed, set to empty array []'
-                    )
-                    sys.exit(1)
-                for t in f["transforms"]:
-                    if "function" not in t:
-                        print(
-                            f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "function" name in transforms in Cookies'
-                        )
-                        sys.exit(1)
-                    if "parameters" not in t:
-                        print(
-                            f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "parameters" array in transforms in Cookies (can be an empty array indicated by []'
-                        )
-                        sys.exit(1)
-            if "Body" not in m:
-                print(
-                    f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "Body" array in GET message. If none will be supplied, set as empty array []'
-                )
-                sys.exit(1)
-    if "jitter" not in inst:
-        print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "jitter"')
-        sys.exit(1)
-    if "interval" not in inst:
-        print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "interval"')
-        sys.exit(1)
-    if "chunk_size" not in inst:
-        print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "chunk_size"')
-        sys.exit(1)
-    if "key_exchange" not in inst:
-        print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "key_exchange" boolean')
-        sys.exit(1)
-    if "kill_date" not in inst:
-        print(f'{bcolors.FAIL}[-]{bcolors.ENDC} Missing "kill_date"')
-        sys.exit(1)
-
-
-def check_config(server_config, agent_config, method):
-    # get info for agent config
-    agent_message = {"location": "", "value": "", "method": method}
-    print(f"{bcolors.OKBLUE}[*]{bcolors.ENDC} Looking into {method} AgentMessages")
-    for g in agent_config[method]["AgentMessage"]:
-        # we need to find where the "message" parameter exists so we know where the data will be
-        agent_message["urls"] = g["urls"]
-        agent_message["uri"] = g["uri"]
-        print(
-            f"{bcolors.OKBLUE}[*]{bcolors.ENDC} Current URLs: {g['urls']}\n\tCurrent URI: {g['uri']}"
-        )
-        for p in g["QueryParameters"]:
-            if p["value"] == "message":
-                print(
-                    f"{bcolors.OKBLUE}[*]{bcolors.ENDC} Found 'message' keyword in QueryParameter {p['name']}"
-                )
-                agent_message["location"] = "QueryParameters"
-                agent_message["value"] = p
-        for p in g["Cookies"]:
-            if p["value"] == "message":
-                print(
-                    f"{bcolors.OKBLUE}[*]{bcolors.ENDC} Found 'message' keyword in Cookies {p['name']}"
-                )
-                agent_message["location"] = "Cookies"
-                agent_message["value"] = p
-        for p in g["urlFunctions"]:
-            if p["name"] == "<message:string>":
-                print(
-                    f"{bcolors.OKBLUE}[*]{bcolors.ENDC} Found '<message:string>' keyword in urlFunctions"
-                )
-                agent_message["location"] = "URI"
-                agent_message["value"] = p
-        if agent_message["location"] == "":
-            # if we haven't set it yet, data must be in the body
-            print(
-                f"{bcolors.OKBLUE}[*]{bcolors.ENDC} Didn't find message keyword anywhere, assuming it to be the Body of the message"
-            )
-            agent_message["location"] = "Body"
-            agent_message["value"] = g["Body"]
-        print(
-            f"{bcolors.OKBLUE}[*]{bcolors.ENDC} Now checking server config for matching section"
-        )
-        check_match_to_server(server_config, agent_message)
-
-
-def check_match_to_server(server_config, agent_message):
-    for inst in server_config["instances"]:
-        # only look into AgentMessage details if the urls and uri match
-        for g in inst[agent_message["method"]]["AgentMessage"]:
-            match = False
-            if agent_message["uri"] != g["uri"]:
-                continue
-            if not urls_match(agent_message["urls"], g["urls"]):
-                continue
-            else:
-                print(
-                    f"{bcolors.OKBLUE}[*]{bcolors.ENDC} Found matching URLs and URI, checking rest of AgentMessage"
-                )
-            if agent_message["location"] == "Body":
-                print(
-                    f"{bcolors.OKBLUE}[*]{bcolors.ENDC} Checking for matching Body messages"
-                )
-                match = body_match(g["Body"], agent_message["value"])
-            else:
-                match = contains_element(
-                    agent_message["value"], g[agent_message["location"]]
-                )
-            if match:
-                print(f"{bcolors.OKGREEN}[+]{bcolors.ENDC} FOUND MATCH")
-                return True
-            else:
-                print(
-                    f"{bcolors.FAIL}[-]{bcolors.ENDC} Matched URLs/URI failed to match AgentMessages"
-                )
-                return False
-    print(f"{bcolors.FAIL}[-]{bcolors.ENDC} Failed to find any matching URLs/URIs")
-    return False
-
-
-def transforms_match(arr1, arr2):
-    if len(arr1) != len(arr2):
-        return False
-    for i in range(len(arr1)):
-        if arr1[i]["function"] != arr2[i]["function"]:
-            return False
-        if len(arr1[i]["parameters"]) != len(arr2[i]["parameters"]):
-            return False
-        for j in range(len(arr1[i]["parameters"])):
-            if arr1[i]["parameters"][j] != arr2[i]["parameters"][j]:
-                return False
-    return True
-
-
-def body_match(arr1, arr2):
-    if len(arr1) != len(arr2):
-        return False
-    for e in range(len(arr1)):
-        if arr1[e]["function"] != arr2[e]["function"]:
-            return False
-        if len(arr1[e]["parameters"]) != len(arr2[e]["parameters"]):
-            return False
-        for p in range(len(arr1[e]["parameters"])):
-            if arr1[e]["parameters"][p] != arr2[e]["parameters"][p]:
-                return False
-    return True
-
-
-def contains_element(ele, arr):
-    # check  if arr  contains ele
-    for i in arr:
-        if i["name"] == ele["name"]:
-            if i["value"] == ele["value"]:
-                if transforms_match(ele["transforms"], i["transforms"]):
-                    return True
-    return False
-
-
-def urls_match(arr1, arr2):
-    if len(arr1) != len(arr2):
-        return False
-    for i in range(len(arr1)):
-        if arr1[i] not in arr2:
-            return False
-    return True
-
-
-if __name__ == "__main__":
-    if os.path.exists("config.json"):
-        server_config = json.load(open("config.json"))
-    else:
-        print(f"{bcolors.FAIL}[-]{bcolors.ENDC} Can't find config.json")
-        sys.exit(1)
-
-    if len(sys.argv) < 2:
-        print(
-            f"{bcolors.FAIL}[-]{bcolors.ENDC} Please specify an agent config file on the command line"
-        )
-        sys.exit(1)
-
-    if os.path.exists(sys.argv[1]):
-        agent_config = json.load(open(sys.argv[1]))
-    else:
-        print(f"{bcolors.FAIL}[-]{bcolors.ENDC} Can't find the supplied file")
-        sys.exit(1)
-    # first, check that the two configs have all the right pieces
-    print(
-        f"{bcolors.OKBLUE}[*]{bcolors.ENDC} Checking server config for layout structure"
-    )
-    check_server_layout(server_config)
-    print(f"{bcolors.OKGREEN}[+]{bcolors.ENDC} Server config layout structure is good")
-    print(
-        f"{bcolors.OKBLUE}[*]{bcolors.ENDC} Checking agent config for layout structure"
-    )
-    check_agent_config_layout(agent_config)
-    print(f"{bcolors.OKGREEN}[+]{bcolors.ENDC} Agent config layout structure is good")
-    # now check that server_config can understand an agent_config message
-    # first check a GET request
-    check_config(server_config, agent_config, "GET")
-    check_config(server_config, agent_config, "POST")

C2_Profiles/dynamicHTTP/c2_code/fake.html

@@ -1,10 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <title>Page Not Found!</title>
-</head>
-<body>
-
-</body>
-</html>

C2_Profiles/dynamicHTTP/c2_code/server

@@ -1,353 +0,0 @@
-#!/usr/bin/env python3
-
-from sanic import Sanic
-from sanic.response import html, redirect, raw
-from sanic.exceptions import NotFound
-import sys
-import asyncio
-import ssl
-from pathlib import Path
-import json
-import requests
-import base64 as b64
-import random
-import os
-
-config = {}
-
-
-async def r_base64(*args):
-    # called with base64(value)
-    if isinstance(args[0], str):
-        return b64.b64decode(args[0].encode())
-    else:
-        return b64.b64decode(args[0])
-
-
-async def base64(*args):
-    # called with base64(value)
-    return b64.b64encode(args[0]).decode('utf-8')
-
-
-async def r_prepend(*args):
-    # called with prepend(value, "string")
-    return args[0][len(args[1]):]
-
-
-async def prepend(*args):
-    # called with prepend(value, "string")
-    return str(args[1]) + str(args[0])
-
-
-async def r_append(*args):
-    # called with append(value, "string")
-    return args[0][:len(args[0]) - len(args[1])]
-
-
-async def append(*args):
-    # called with append(value, "string")
-    return args[0] + args[1]
-
-
-async def random_mixed(*args):
-    # called with random_mixed(value, 10), always appends
-    letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
-    rnd = ''.join(random.choice(letters) for i in range(args[1]))
-    return args[0] + rnd
-
-
-async def r_random_mixed(*args):
-    # called with random_mixed(value, 10), always appends
-    # return the string going from 0 to -10 (or ten from the end)
-    return args[0][: -1 * args[1]]
-
-
-async def random_number(*args):
-    # called with random_number(value, 10)
-    letters = "0987654321"
-    rnd = ''.join(random.choice(letters) for i in range(args[1]))
-    return args[0] + rnd
-
-
-async def r_random_number(*args):
-    # called with random_mixed(value, 10), always appends
-    # return the string going from 0 to -10 (or ten from the end)
-    return args[0][: -1 * args[1]]
-
-
-async def random_alpha(*args):
-    # called with random_alpha(value, 10), always appends
-    letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-    rnd = ''.join(random.choice(letters) for i in range(args[1]))
-    return args[0] + rnd
-
-
-async def r_random_alpha(*args):
-    # called with random_mixed(value, 10), always appends
-    # return the string going from 0 to -10 (or ten from the end)
-    return args[0][: -1 * args[1]]
-
-
-async def choose_random(*args):
-    # called with choose_random(value, opt1, opt2, opt3...)
-    choice = random.choice(args[1:])
-    return args[0] + choice
-
-
-async def r_choose_random(*args):
-    # called with choose_random(value, opt1, opt2, opt3...)
-    for e in args[1:]:
-        if e in args[0]:
-            return args[0].replace(e, "", 1)
-
-
-async def get_value(value, transforms):
-    # given an obfuscated value, apply transforms to get back the value we need
-    # await print_flush(transforms)
-    for step in transforms[::-1]:
-        value = await globals()["r_" + step['function']](value, *step['parameters'])
-    return value
-
-
-async def create_value(value, transforms):
-    for step in transforms:
-        # await print_flush("in create_value: value: {}\n".format(value))
-        value = await globals()[step['function']](value, *step['parameters'])
-    return value
-
-
-async def create_response(request, data, status=200, method="POST"):
-    try:
-        if config[request.app.name]['debug']:
-            await print_flush("calling create_value for data: {}\nwith transforms: {}\n".format(data, config[request.app.name][method]['ServerBody']))
-        data = await create_value(data, config[request.app.name][method]['ServerBody'])
-
-        headers = config[request.app.name][method]['ServerHeaders']
-
-        cookies = config[request.app.name][method]['ServerCookies']
-        if config[request.app.name]['debug']:
-            await print_flush("response of: {}".format(data))
-            await print_flush("response data: {}\n".format(data))
-            await print_flush("response headers: {}\n".format(headers))
-            await print_flush("response_cookies: {}\n".format(cookies))
-        if isinstance(data, str):
-            data = data.encode()
-        response = raw(data, status=status, headers=headers)
-        for key in cookies.items():
-            response.cookies[key] = cookies[key]
-        return response
-    except Exception as e:
-        if config[request.app.name]['debug']:
-            await print_flush("error in create_response: {}".format(str(e)))
-        return html("Error: Requested URL {} not found\n".format(request.url), status=404)
-
-
-async def no_match(request, exception):
-    global config
-    if config[request.app.name]['debug']:
-        await print_flush("hit a 'no_match' case")
-    if config[request.app.name]['no_match']['action'] == "":
-        return await create_response(request, data="Error: Requested URL {} not found".format(request.url), status=404)
-    elif config[request.app.name]['no_match']['action'] == 'redirect':
-        return redirect(config[request.app.name]['no_match']['redirect'])
-    elif config[request.app.name]['no_match']['action'] == 'proxy_get':
-        resp = requests.get(config[request.app.name]['no_match']['proxy_get']['url'], verify=False)
-        return await create_response(request, data=resp.content, status=config[request.app.name]['no_match']['proxy_get']['status'])
-    elif config[request.app.name]['no_match']['action'] == 'proxy_post':
-        resp = requests.post(config[request.app.name]['no_match']['proxy_post']['url'], data=request.body, verify=False)
-        return await create_response(request, data=resp.content, status=config[request.app.name]['no_match']['proxy_post']['status'])
-    elif config[request.app.name]['no_match']['action'] == 'return_file':
-        content = open(config[request.app.name]['no_match']['return_file']['name'], 'r').read()
-        return await create_response(request, data=content, status=config[request.app.name]['no_match']['return_file']['status'])
-
-
-async def print_flush(message):
-    print(message)
-    sys.stdout.flush()
-
-
-async def get_base_values(request, method: str, mythic_endpoint: str, **kwargs):
-    value = None
-    transforms = None
-    try:
-        if config[request.app.name][method][mythic_endpoint]['location'] == 'URI':
-            value = kwargs["message"]
-            transforms = {}
-        elif config[request.app.name][method][mythic_endpoint]['location'] == 'QueryParameters':
-            value = request.args[config[request.app.name][method][mythic_endpoint]['value']['name']][0]
-            transforms = config[request.app.name][method][mythic_endpoint]['value']['transforms']
-        elif config[request.app.name][method][mythic_endpoint]['location'] == 'Cookies':
-            value = request.cookies.get(config[request.app.name][method][mythic_endpoint]['value']['name'])
-            transforms = config[request.app.name][method][mythic_endpoint]['value']['transforms']
-        elif config[request.app.name][method][mythic_endpoint]['location'] == 'Body':
-            value = request.body
-            transforms = config[request.app.name][method][mythic_endpoint]['value']
-        else:
-            if config[request.app.name]['debug']:
-                await print_flush("{} failed to find required parameter".format(mythic_endpoint))
-                return None, None
-        if config[request.app.name]['debug']:
-            await print_flush("Got value: {}\nGot transforms: {}\n".format(value, transforms))
-    except Exception as e:
-        if config[request.app.name]['debug']:
-            await print_flush("Failed to get a value: {}, {}".format(mythic_endpoint, str(e)))
-    return value, transforms
-
-
-async def get_agent_message(request, **kwargs):
-    global config
-    try:
-        if config[request.app.name]['debug']:
-            await print_flush("get_agent_message request from: {} with {} and {}".format(request.url, request.cookies, request.headers))
-        # find the agent value and the transforms needed to get the real value out
-        message, transforms = await get_base_values(request, 'GET', request.uri_template, **kwargs)
-        if message is None:
-            # this means we failed to find our message
-            return await no_match(request, NotFound)
-        # given the message location and transforms, extract the actual value
-        message = await get_value(message, transforms)
-        if config[request.app.name]['debug']:
-            await print_flush("Forwarding along to: {}".format(config['mythic_address']))
-        response = requests.post(config['mythic_address'], verify=False, data=message)
-        return await create_response(request, data=response.content, status=response.status_code, method="GET")
-    except Exception as e:
-        if config[request.app.name]['debug']:
-            await print_flush("error in get_agent_message: {}".format(str(e)))
-        return await no_match(request, NotFound)
-
-
-async def post_agent_message(request, **kwargs):
-    global config
-    try:
-        if config[request.app.name]['debug']:
-            await print_flush("post_agent_message request from: {} with {} and {}".format(request.url, request.cookies, request.headers))
-        message, agent_transforms = await get_base_values(request, 'POST', request.uri_template, **kwargs)
-        if message is None:
-            return await no_match(request, NotFound)
-        message = await get_value(message, agent_transforms)
-        if config[request.app.name]['debug']:
-            await print_flush("Forwarding along to: {}".format(config['mythic_address']))
-        response = requests.post(config['mythic_address'], data=message, verify=False)
-        return await create_response(request, data=response.content, status=response.status_code, method="POST")
-    except Exception as e:
-        if config[request.app.name]['debug']:
-            await print_flush("error in post_agent_message: {}".format(str(e)))
-        return await no_match(request, NotFound)
-
-
-if __name__ == "__main__":
-    config_file = open("config.json", 'rb')
-    main_config = json.loads(config_file.read().decode('utf-8'))
-    print("Opening config and starting instances...")
-    sys.stdout.flush()
-    # basic mapping of the general endpoints to the real endpoints
-    config['mythic_address'] = os.environ['MYTHIC_ADDRESS']
-    # now look at the specific instances to start
-    for inst in main_config['instances']:
-        config[str(inst['port'])] = {'debug': inst['debug'],
-                                     'no_match': inst['no_match'],
-                                     'POST': {  # these are server response configurations
-                                         'ServerHeaders': inst['POST']['ServerHeaders'],
-                                         'ServerCookies': inst['POST']['ServerCookies'],
-                                         'ServerBody': inst['POST']['ServerBody']
-                                     },
-                                     "GET": {  # these are server response configurations
-                                         'ServerHeaders': inst['GET']['ServerHeaders'],
-                                         'ServerCookies': inst['GET']['ServerCookies'],
-                                         'ServerBody': inst['GET']['ServerBody']
-                                     }}
-        if inst['debug']:
-            print("Debugging output is enabled. This might be a performance it, but gives more context")
-        else:
-            print("Debugging output is disabled")
-        sys.stdout.flush()
-        # now to create an app instance too handle responses
-        app = Sanic(str(inst['port']))
-        app.config['REQUEST_MAX_SIZE'] = 1000000000
-        app.config['REQUEST_TIMEOUT'] = 600
-        app.config['RESPONSE_TIMEOUT'] = 600
-        app.error_handler.add(Exception, no_match)
-
-        # do a little extra processing here once so we don't have to do extra processing for each request
-        # for each endpoint need to track:
-        #   1. where the data is located (URI, query, cookie, body, header)
-        #   2. what needs to be done to access the value
-        #       (access specific field, certain offset into data, decode first, etc)
-        #   3. what needs to be done to get the final value out (decode, remove extra data, etc)
-
-        # an instance can have multiple URLs and schemes for each GET/POST, so loop through all of that
-        for g in inst['GET']['AgentMessage']:
-            app.add_route(get_agent_message, g['uri'], methods=['GET'])
-            config[str(inst['port'])]['GET'][g['uri']] = {}
-            # we need to find where the "message" parameter exists so we know where the data will be
-            for p in g['QueryParameters']:
-                if p['value'] == "message":
-                    config[str(inst['port'])]['GET'][g['uri']]['location'] = "QueryParameters"
-                    config[str(inst['port'])]['GET'][g['uri']]['value'] = p
-            for p in g['Cookies']:
-                if p['value'] == 'message':
-                    config[str(inst['port'])]['GET'][g['uri']]['location'] = "Cookies"
-                    config[str(inst['port'])]['GET'][g['uri']]['value'] = p
-            for p in g['urlFunctions']:
-                if p['name'] == '<message:string>':
-                    config[str(inst['port'])]['GET'][g['uri']]['location'] = "URI"
-                    config[str(inst['port'])]['GET'][g['uri']]['value'] = p
-            if 'location' not in config[str(inst['port'])]['GET'][g['uri']]:
-                # if we haven't set it yet, data must be in the body
-                config[str(inst['port'])]['GET'][g['uri']]['location'] = "Body"
-                config[str(inst['port'])]['GET'][g['uri']]['value'] = g['Body']
-        for g in inst['POST']['AgentMessage']:
-            app.add_route(post_agent_message, g['uri'], methods=['POST'])
-            config[str(inst['port'])]['POST'][g['uri']] = {}
-            # we need to find where the "message" parameter exists so we know where the data will be
-            for p in g['QueryParameters']:
-                if p['value'] == "message":
-                    config[str(inst['port'])]['POST'][g['uri']]['location'] = "QueryParameters"
-                    config[str(inst['port'])]['POST'][g['uri']]['value'] = p
-            for p in g['Cookies']:
-                if p['value'] == 'message':
-                    config[str(inst['port'])]['POST'][g['uri']]['location'] = "Cookies"
-                    config[str(inst['port'])]['POST'][g['uri']]['value'] = p
-            for p in g['urlFunctions']:
-                if p['name'] == '<message:string>':
-                    config[str(inst['port'])]['POST'][g['uri']]['location'] = "URI"
-                    config[str(inst['port'])]['POST'][g['uri']]['value'] = p
-            if 'location' not in config[str(inst['port'])]['POST'][g['uri']]:
-                # if we haven't set it yet, data must be in the body
-                config[str(inst['port'])]['POST'][g['uri']]['location'] = "Body"
-                config[str(inst['port'])]['POST'][g['uri']]['value'] = g['Body']
-
-        keyfile = Path(inst['key_path'])
-        certfile = Path(inst['cert_path'])
-        if keyfile.is_file() and certfile.is_file():
-            context = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)
-            context.load_cert_chain(inst['cert_path'], keyfile=inst['key_path'])
-            if inst['debug']:
-                server = app.create_server(host="0.0.0.0", port=inst['port'], ssl=context, debug=False, return_asyncio_server=True, access_log=True)
-            else:
-                server = app.create_server(host="0.0.0.0", port=inst['port'], ssl=context, debug=False, return_asyncio_server=True, access_log=False)
-            if inst['debug']:
-                print("using SSL for port {}".format(inst['port']))
-                sys.stdout.flush()
-        else:
-            if inst['debug']:
-                print("not using SSL for port {}".format(inst['port']))
-                sys.stdout.flush()
-            if inst['debug']:
-                server = app.create_server(host="0.0.0.0", port=inst['port'], debug=False, return_asyncio_server=True, access_log=True)
-            else:
-                server = app.create_server(host="0.0.0.0", port=inst['port'], debug=False, return_asyncio_server=True, access_log=False)
-        task = asyncio.ensure_future(server)
-
-    try:
-        loop = asyncio.get_event_loop()
-        def callback(fut):
-            try:
-                fetch_count = fut.result()
-            except OSError as e:
-                print("probably the port set is being used")
-                fut.get_loop().stop()
-        task.add_done_callback(callback)
-        loop.run_forever()
-    except:
-        loop.stop()

C2_Profiles/dynamicHTTP/mythic/C2ProfileBase.py

@@ -1,130 +0,0 @@
-from enum import Enum
-from abc import abstractmethod
-import json
-
-
-class ParameterType(Enum):
-    String = "String"
-    ChooseOne = "ChooseOne"
-    Array = "Array"
-    Date = "Date"
-    Dictionary = "Dictionary"
-
-
-class C2ProfileParameter:
-    def __init__(
-        self,
-        name: str,
-        description: str,
-        default_value: str = "",
-        randomize: bool = False,
-        format_string: str = "",
-        parameter_type: ParameterType = ParameterType.String,
-        required: bool = True,
-        verifier_regex: str = "",
-        choices: [str] = None,
-    ):
-        self.name = name
-        self.description = description
-        self.randomize = randomize
-        self.format_string = format_string
-        self.parameter_type = parameter_type
-        self.required = required
-        self.verifier_regex = verifier_regex
-        self.choices = choices
-        self.default_value = ""
-        if self.parameter_type == ParameterType.ChooseOne and choices is not None:
-            self.default_value = "\n".join(choices)
-        else:
-            self.default_value = default_value
-
-
-    def to_json(self):
-        return {
-            "name": self.name,
-            "description": self.description,
-            "default_value": self.default_value if self.parameter_type not in [ParameterType.Array, ParameterType.Dictionary] else json.dumps(self.default_value),
-            "randomize": self.randomize,
-            "format_string": self.format_string,
-            "required": self.required,
-            "parameter_type": self.parameter_type.value,
-            "verifier_regex": self.verifier_regex,
-        }
-
-
-class C2Profile:
-    @property
-    @abstractmethod
-    def name(self):
-        pass
-
-    @property
-    @abstractmethod
-    def description(self):
-        pass
-
-    @property
-    @abstractmethod
-    def author(self):
-        pass
-
-    @property
-    @abstractmethod
-    def is_p2p(self):
-        pass
-
-    @property
-    @abstractmethod
-    def is_server_routed(self):
-        pass
-
-    @property
-    @abstractmethod
-    def mythic_encrypts(self):
-        pass
-
-    @property
-    @abstractmethod
-    def parameters(self):
-        pass
-
-    def to_json(self):
-        return {
-            "name": self.name,
-            "description": self.description,
-            "author": self.author,
-            "mythic_encrypts": self.mythic_encrypts,
-            "is_p2p": self.is_p2p,
-            "is_server_routed": self.is_server_routed,
-            "params": [x.to_json() for x in self.parameters],
-        }
-
-
-class RPCStatus(Enum):
-    Success = "success"
-    Error = "error"
-
-
-class RPCResponse:
-    def __init__(self, status: RPCStatus = None, response: str = None):
-        self.status = status
-        self.response = response
-
-    @property
-    def status(self):
-        return self._status
-
-    @status.setter
-    def status(self, status):
-        self._status = status
-
-    @property
-    def response(self):
-        return self._response
-
-    @response.setter
-    def response(self, response):
-        self._response = response
-
-    def to_json(self):
-        return {"status": self.status.value, "response": self.response}

C2_Profiles/dynamicHTTP/mythic/MythicBaseRPC.py

@@ -1,99 +0,0 @@
-from aio_pika import connect_robust, IncomingMessage, Message
-import asyncio
-import uuid
-import json
-from enum import Enum
-
-
-class MythicStatus(Enum):
-    Success = "success"
-    Error = "error"
-
-
-class RPCResponse:
-    def __init__(self, resp: dict):
-        self._raw_resp = resp
-        if resp["status"] == "success":
-            self.status = MythicStatus.Success
-            self.response = resp["response"] if "response" in resp else ""
-            self.error_message = None
-        else:
-            self.status = MythicStatus.Error
-            self.error_message = resp["error"]
-            self.response = None
-
-    @property
-    def status(self):
-        return self._status
-
-    @status.setter
-    def status(self, status):
-        self._status = status
-
-    @property
-    def error_message(self):
-        return self._error_message
-
-    @error_message.setter
-    def error_message(self, error_message):
-        self._error_message = error_message
-
-    @property
-    def response(self):
-        return self._response
-
-    @response.setter
-    def response(self, response):
-        self._response = response
-
-
-class MythicBaseRPC:
-    def __init__(self):
-        self.connection = None
-        self.channel = None
-        self.callback_queue = None
-        self.futures = {}
-        self.loop = asyncio.get_event_loop()
-
-    async def connect(self):
-        config_file = open("/Mythic/mythic/rabbitmq_config.json", "rb")
-        main_config = json.loads(config_file.read().decode("utf-8"))
-        config_file.close()
-        self.connection = await connect_robust(
-            host=main_config["host"],
-            login=main_config["username"],
-            password=main_config["password"],
-            virtualhost=main_config["virtual_host"],
-        )
-        self.channel = await self.connection.channel()
-        self.callback_queue = await self.channel.declare_queue(exclusive=True)
-        await self.callback_queue.consume(self.on_response)
-
-        return self
-
-    def on_response(self, message: IncomingMessage):
-        future = self.futures.pop(message.correlation_id)
-        future.set_result(message.body)
-
-    async def call(self, n, receiver: str = None) -> RPCResponse:
-        if self.connection is None:
-            await self.connect()
-        correlation_id = str(uuid.uuid4())
-        future = self.loop.create_future()
-
-        self.futures[correlation_id] = future
-        if receiver is None:
-            router = "c2rpc_queue"
-        else:
-            router = "{}_rpc_queue".format(receiver)
-        await self.channel.default_exchange.publish(
-            Message(
-                json.dumps(n).encode(),
-                content_type="application/json",
-                correlation_id=correlation_id,
-                reply_to=self.callback_queue.name,
-            ),
-            routing_key=router,
-        )
-
-        return RPCResponse(json.loads(await future))

C2_Profiles/dynamicHTTP/mythic/MythicCallbackRPC.py

@@ -1,124 +0,0 @@
-from MythicBaseRPC import *
-import base64
-
-
-class MythicRPCResponse(RPCResponse):
-    def __init__(self, resp: RPCResponse):
-        super().__init__(resp._raw_resp)
-        if resp.status == MythicStatus.Success:
-            self.data = resp.response
-        else:
-            self.data = None
-
-    @property
-    def data(self):
-        return self._data
-
-    @data.setter
-    def data(self, data):
-        self._data = data
-
-
-class MythicCallbackRPC(MythicBaseRPC):
-    # returns dictionary of `{"raw": raw_tasking, "encrypted": base64(uuid+encrypted_tasking)}`
-    async def get_tasking(
-        self, uuid: str, tasking_size: int = 1
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "get_tasking",
-                "uuid": uuid,
-                "tasking_size": tasking_size,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def add_route(
-        self,
-        source_uuid: str,
-        destination_uuid: str,
-        direction: int = 1,
-        metadata: str = None,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "add_route",
-                "source": source_uuid,
-                "destination": destination_uuid,
-                "direction": direction,
-                "metadata": metadata,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def remove_route(
-        self,
-        source_uuid: str,
-        destination_uuid: str,
-        direction: int = 1,
-        metadata: str = None,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "remove_route",
-                "source": source_uuid,
-                "destination": destination_uuid,
-                "direction": direction,
-                "metadata": metadata,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def get_callback_info(self, uuid: str) -> MythicRPCResponse:
-        resp = await self.call({"action": "get_callback_info", "uuid": uuid})
-        return MythicRPCResponse(resp)
-
-    async def get_encryption_data(self, uuid: str, profile: str) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "get_encryption_data",
-                "uuid": uuid,
-                "c2_profile": profile,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def update_callback_info(self, uuid: str, info: dict) -> MythicRPCResponse:
-        resp = await self.call(
-            {"action": "update_callback_info", "uuid": uuid, "data": info}
-        )
-        return MythicRPCResponse(resp)
-
-    async def add_event_message(
-        self, message: str, level: str = "info"
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {"action": "add_event_message", "level": level, "message": message}
-        )
-        return MythicRPCResponse(resp)
-
-    async def encrypt_bytes(
-        self, data: bytes, uuid: str, with_uuid: bool = False,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "encrypt_bytes",
-                "data": base64.b64encode(data).decode(),
-                "uuid": uuid,
-                "with_uuid": with_uuid,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def decrypt_bytes(
-        self, data: bytes, uuid: str, with_uuid: bool = False,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "decrypt_bytes",
-                "uuid": uuid,
-                "data": base64.b64encode(data).decode(),
-                "with_uuid": with_uuid,
-            }
-        )
-        return MythicRPCResponse(resp)

C2_Profiles/dynamicHTTP/mythic/c2_functions/C2_RPC_functions.py

@@ -1,11 +0,0 @@
-from C2ProfileBase import *
-import MythicCallbackRPC
-
-# request is a dictionary: {"action": func_name, "message": "the input",  "task_id": task id num}
-# must return an RPCResponse() object and set .status to an instance of RPCStatus and response to str of message
-async def test(request):
-    response = RPCResponse()
-    response.status = RPCStatus.Success
-    response.response = "hello"
-    #resp = await MythicCallbackRPC.MythicCallbackRPC().add_event_message(message="got a POST message")
-    return response

C2_Profiles/dynamicHTTP/mythic/c2_functions/dynamicHTTP.py

@@ -1,18 +0,0 @@
-from C2ProfileBase import *
-
-
-class DynamicHTTP(C2Profile):
-    name = "dynamicHTTP"
-    description = "Manipulate HTTP(S) requests and responses"
-    author = "@its_a_feature_"
-    is_p2p = False
-    is_server_routed = False
-    mythic_encrypts = True
-    parameters = [
-        C2ProfileParameter(
-            name="AESPSK", description="Base64 of a 32B AES Key", default_value=""
-        ),
-        C2ProfileParameter(
-            name="raw_c2_config", description="Agent JSON Config", default_value=""
-        ),
-    ]

C2_Profiles/dynamicHTTP/mythic/c2_service.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-cd /Mythic/mythic
-
-export PYTHONPATH=/Mythic:/Mythic/mythic
-
-python3.8 mythic_service.py

C2_Profiles/dynamicHTTP/mythic/mythic_service.py

@@ -1,410 +0,0 @@
-#!/usr/bin/env python3
-import aio_pika
-import os
-import time
-import sys
-import subprocess
-import _thread
-import base64
-import json
-import socket
-import asyncio
-import pathlib
-import traceback
-from C2ProfileBase import *
-from importlib import import_module, invalidate_caches
-from functools import partial
-
-credentials = None
-connection_params = None
-running = False
-process = None
-thread = None
-hostname = ""
-output = ""
-exchange = None
-container_files_path = None
-
-
-def deal_with_stdout():
-    global process
-    global output
-    while True:
-        try:
-            for line in iter(process.stdout.readline, b""):
-                output += line.decode("utf-8")
-        except Exception as e:
-            print("Exiting thread due to: {}\n".format(str(e)))
-            sys.stdout.flush()
-            break
-
-
-def import_all_c2_functions():
-    import glob
-
-    # Get file paths of all modules.
-    modules = glob.glob("c2_functions/*.py")
-    invalidate_caches()
-    for x in modules:
-        if not x.endswith("__init__.py") and x[-3:] == ".py":
-            module = import_module("c2_functions." + pathlib.Path(x).stem, package=None)
-            for el in dir(module):
-                if "__" not in el:
-                    globals()[el] = getattr(module, el)
-
-
-async def send_status(message="", routing_key=""):
-    global exchange
-    try:
-        message_body = aio_pika.Message(message.encode())
-        await exchange.publish(message_body, routing_key=routing_key)
-    except Exception as e:
-        print("Exception in send_status: {}".format(str(e)))
-        sys.stdout.flush()
-
-
-async def callback(message: aio_pika.IncomingMessage):
-    global running
-    global process
-    global output
-    global thread
-    global hostname
-    global container_files_path
-    with message.process():
-        # messages of the form: c2.modify.PROFILE NAME.command
-        try:
-            command = message.routing_key.split(".")[3]
-            username = message.routing_key.split(".")[4]
-            server_path = container_files_path / "server"
-            # command = body.decode('utf-8')
-            if command == "start":
-                if not running:
-                    # make sure to start the /Apfell/server in the background
-                    os.chmod(server_path, mode=0o777)
-                    output = ""
-                    process = subprocess.Popen(
-                        str(server_path),
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.STDOUT,
-                        cwd=str(container_files_path),
-                    )
-                    thread = _thread.start_new_thread(deal_with_stdout, ())
-                    time.sleep(3)
-                    process.poll()
-                    if process.returncode is not None:
-                        # this means something went wrong and the process is dead
-                        running = False
-                        await send_status(
-                            message="Failed to start\nOutput: {}".format(output),
-                            routing_key="c2.status.{}.stopped.start.{}".format(
-                                hostname, username
-                            ),
-                        )
-                        output = ""
-                    else:
-                        running = True
-                        await send_status(
-                            message="Started with pid: {}...\nOutput: {}".format(
-                                str(process.pid), output
-                            ),
-                            routing_key="c2.status.{}.running.start.{}".format(
-                                hostname, username
-                            ),
-                        )
-                        output = ""
-                else:
-                    await send_status(
-                        message="Already running...\nOutput: {}".format(output),
-                        routing_key="c2.status.{}.running.start.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-            elif command == "stop":
-                if running:
-                    try:
-                        process.kill()
-                        process.communicate()
-                    except Exception as e:
-                        pass
-                    try:
-                        thread.exit()
-                    except Exception as e:
-                        pass
-                    running = False
-                    await send_status(
-                        message="Process killed...\nOld Output: {}".format(output),
-                        routing_key="c2.status.{}.stopped.stop.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-                else:
-                    await send_status(
-                        message="Process not running...\nOld Output: {}".format(output),
-                        routing_key="c2.status.{}.stopped.stop.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-                # make sure to stop the /Apfell/server in the background
-            elif command == "status":
-                if running:
-                    await send_status(
-                        message="Output: {}".format(output),
-                        routing_key="c2.status.{}.running.status.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-                else:
-                    await send_status(
-                        message="C2 is not running",
-                        routing_key="c2.status.{}.stopped.status.{}".format(
-                            hostname, username
-                        ),
-                    )
-            elif command == "get_config":
-                try:
-                    path = container_files_path / "config.json"
-                    file_data = open(path, "rb").read()
-                except Exception as e:
-                    file_data = b"File not found"
-                encoded_data = json.dumps(
-                    {
-                        "filename": "config.json",
-                        "data": base64.b64encode(file_data).decode("utf-8"),
-                    }
-                )
-                await send_status(
-                    message=encoded_data,
-                    routing_key="c2.status.{}.{}.get_config.{}".format(
-                        hostname, "running" if running else "stopped", username
-                    ),
-                )
-            elif command == "writefile":
-                try:
-                    message = json.loads(message.body.decode("utf-8"))
-                    file_path = container_files_path / message["file_path"]
-                    file_path = file_path.resolve()
-                    if container_files_path not in file_path.parents:
-                        response = {
-                            "status": "error",
-                            "error": "trying to break out of path",
-                        }
-                    else:
-                        file = open(file_path, "wb")
-                        file.write(base64.b64decode(message["data"]))
-                        file.close()
-                        response = {"status": "success", "file": message["file_path"]}
-                except Exception as e:
-                    response = {"status": "error", "error": str(e)}
-                await send_status(
-                    message=json.dumps(response),
-                    routing_key="c2.status.{}.{}.writefile.{}".format(
-                        hostname, "running" if running else "stopped", username
-                    ),
-                )
-            elif command == "sync_classes":
-                try:
-                    import_all_c2_functions()
-                    # c2profile = {}
-                    for cls in C2Profile.__subclasses__():
-                        c2profile = cls().to_json()
-                        break
-                    await send_status(
-                        message=json.dumps(c2profile),
-                        routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                            hostname, "running" if running else "stopped", username
-                        ),
-                    )
-                except Exception as e:
-                    await send_status(
-                        message='{"message": "Error while syncing info: {}"}'.format(
-                            str(traceback.format_exc())
-                        ),
-                        routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                            hostname, "running" if running else "stopped", username
-                        ),
-                    )
-            else:
-                print("Unknown command: {}".format(command))
-                sys.stdout.flush()
-        except Exception as e:
-            print("Failed overall message processing: " + str(e))
-            sys.stdout.flush()
-
-
-async def sync_classes():
-    try:
-        import_all_c2_functions()
-        c2profile = {}
-        for cls in C2Profile.__subclasses__():
-            c2profile = cls().to_json()
-            break
-        await send_status(
-            message=json.dumps(c2profile),
-            routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                hostname, "stopped", ""
-            ),
-        )
-    except Exception as e:
-        await send_status(
-            message='{"message": "Error while syncing info: {}"}'.format(
-                str(traceback.format_exc())
-            ),
-            routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                hostname, "stopped", ""
-            ),
-        )
-
-
-async def rabbit_c2_rpc_callback(
-    exchange: aio_pika.Exchange, message: aio_pika.IncomingMessage
-):
-    with message.process():
-        request = json.loads(message.body.decode())
-        if "action" in request:
-            response = await globals()[request["action"]](request)
-            response = json.dumps(response.to_json()).encode()
-        else:
-            response = json.dumps(
-                {"status": "error", "error": "Missing action"}
-            ).encode()
-        try:
-            await exchange.publish(
-                aio_pika.Message(body=response, correlation_id=message.correlation_id),
-                routing_key=message.reply_to,
-            )
-        except Exception as e:
-            print(
-                "Exception trying to send message back to container for rpc! " + str(e)
-            )
-            sys.stdout.flush()
-
-
-async def connect_and_consume_rpc():
-    connection = None
-    global hostname
-    while connection is None:
-        try:
-            connection = await aio_pika.connect_robust(
-                host="127.0.0.1",
-                login="mythic_user",
-                password="mythic_password",
-                virtualhost="mythic_vhost",
-            )
-            channel = await connection.channel()
-            # get a random queue that only the apfell server will use to listen on to catch all heartbeats
-            queue = await channel.declare_queue("{}_rpc_queue".format(hostname))
-            await channel.set_qos(prefetch_count=50)
-            try:
-                task = queue.consume(
-                    partial(rabbit_c2_rpc_callback, channel.default_exchange)
-                )
-                result = await asyncio.wait_for(task, None)
-            except Exception as e:
-                print("Exception in connect_and_consume .consume: {}".format(str(e)))
-                sys.stdout.flush()
-        except (ConnectionError, ConnectionRefusedError) as c:
-            print("Connection to rabbitmq failed, trying again...")
-            sys.stdout.flush()
-        except Exception as e:
-            print("Exception in connect_and_consume_rpc connect: {}".format(str(e)))
-            # print("Exception in connect_and_consume connect: {}".format(str(e)))
-            sys.stdout.flush()
-        await asyncio.sleep(2)
-
-
-async def mythic_service():
-    global hostname
-    global exchange
-    global container_files_path
-    connection = None
-    config_file = open("rabbitmq_config.json", "rb")
-    main_config = json.loads(config_file.read().decode("utf-8"))
-    config_file.close()
-    if main_config["name"] == "hostname":
-        hostname = socket.gethostname()
-    else:
-        hostname = main_config["name"]
-    container_files_path = pathlib.Path(
-        os.path.abspath(main_config["container_files_path"])
-    )
-    container_files_path = container_files_path / "c2_code"
-    while connection is None:
-        try:
-            connection = await aio_pika.connect_robust(
-                host=main_config["host"],
-                login=main_config["username"],
-                password=main_config["password"],
-                virtualhost=main_config["virtual_host"],
-            )
-        except Exception as e:
-            await asyncio.sleep(2)
-    try:
-        channel = await connection.channel()
-        exchange = await channel.declare_exchange(
-            "mythic_traffic", aio_pika.ExchangeType.TOPIC
-        )
-        queue = await channel.declare_queue("", exclusive=True)
-        await queue.bind(
-            exchange="mythic_traffic", routing_key="c2.modify.{}.#".format(hostname)
-        )
-        # just want to handle one message at a time so we can clean up and be ready
-        await channel.set_qos(prefetch_count=30)
-        print("Listening for c2.modify.{}.#".format(hostname))
-        sys.stdout.flush()
-        task = queue.consume(callback)
-        await sync_classes()
-        task4 = asyncio.ensure_future(connect_and_consume_rpc())
-        result = await asyncio.gather(task, task4)
-        # send_status(message="", routing_key="c2.status.{}.stopped.stop".format(hostname))
-    except Exception as e:
-        print(str(traceback.format_exc()))
-        sys.stdout.flush()
-
-
-async def heartbeat_loop():
-    config_file = open("rabbitmq_config.json", "rb")
-    main_config = json.loads(config_file.read().decode("utf-8"))
-    config_file.close()
-    if main_config["name"] == "hostname":
-        hostname = socket.gethostname()
-    else:
-        hostname = main_config["name"]
-    while True:
-        try:
-            connection = await aio_pika.connect_robust(
-                host=main_config["host"],
-                login=main_config["username"],
-                password=main_config["password"],
-                virtualhost=main_config["virtual_host"],
-            )
-            channel = await connection.channel()
-            # declare our heartbeat exchange that everybody will publish to, but only the apfell server will are about
-            exchange = await channel.declare_exchange(
-                "mythic_traffic", aio_pika.ExchangeType.TOPIC
-            )
-        except Exception as e:
-            print(str(e))
-            await asyncio.sleep(2)
-            continue
-        while True:
-            try:
-                # routing key is ignored for fanout, it'll go to anybody that's listening, which will only be the server
-                await exchange.publish(
-                    aio_pika.Message("heartbeat".encode()),
-                    routing_key="c2.heartbeat.{}".format(hostname),
-                )
-                await asyncio.sleep(10)
-            except Exception as e:
-                print(str(e))
-                # if we get an exception here, break out to the bigger loop and try to connect again
-                break
-
-# start our service
-loop = asyncio.get_event_loop()
-loop.create_task(mythic_service())
-loop.create_task(heartbeat_loop())
-loop.run_forever()

C2_Profiles/dynamicHTTP/mythic/rabbitmq_config.json

@@ -1,8 +0,0 @@
-{
-  "username": "mythic_user",
-  "password": "mythic_password",
-  "virtual_host": "mythic_vhost",
-  "host": "127.0.0.1",
-  "name": "hostname",
-  "container_files_path": "/Mythic/"
-}

C2_Profiles/leviathan-websocket/Dockerfile

@@ -1 +0,0 @@
-From itsafeaturemythic/python38_sanic_c2profile:0.0.1

C2_Profiles/leviathan-websocket/c2_code/config.json

@@ -1,10 +0,0 @@
-{
-    "bindaddress": "0.0.0.0:8081",
-    "usessl": false,
-    "sslkey":"",
-    "sslcert":"",
-    "websocketuri": "socket",
-    "defaultpage": "index.html",
-    "logfile": "server.log",
-    "debug": false
-}

C2_Profiles/leviathan-websocket/c2_code/index.html

@@ -1,9 +0,0 @@
-<!DOCTYPE>
-<html>
-<head>
-<title>Under Construction</title>
-</head>
-<body>
-<p>This page is under construction. Please come back soon!</p>
-</body>
-</html>

C2_Profiles/leviathan-websocket/c2_code/src/build_help

@@ -1,8 +0,0 @@
-To build the sever:
-
-go get github.com/gorilla/websocket
-go get github.com/kabukky/httpscerts
-go build -tags=websocket main.go
-
-this outputs a binary called "main"
-move this to ../server

C2_Profiles/leviathan-websocket/c2_code/src/main.go

@@ -1,35 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"log"
-	"os"
-
-	"./pkg/servers"
-)
-
-var cf *os.File
-func main() {
-	cf, err := os.Open("config.json")
-
-	if err != nil {
-		log.Println("Error opening config file ", err.Error())
-		os.Exit(-1)
-	}
-
-	config, _ := ioutil.ReadAll(cf)
-
-	c2config := servers.C2Config{}
-	err = json.Unmarshal(config, &c2config)
-	if err != nil {
-		log.Println("Error in unmarshal call for config ", err.Error())
-		os.Exit(-1)
-	}
-
-	// start the server instance with the config
-	c2server := servers.NewInstance().(servers.Server)
-
-	c2server.Run(c2config)
-
-}

C2_Profiles/leviathan-websocket/c2_code/src/pkg/servers/server.go

@@ -1,34 +0,0 @@
-package servers
-
-// C2Config - struct for server configuration
-type C2Config struct {
-	BindAddress   string `json:"bindaddress"`
-	SocketURI     string `json:"websocketuri"`
-	SSLKey        string `json:"sslkey"`
-	SSLCert       string `json:"sslcert"`
-	UseSSL        bool   `json:"usessl"`
-	Defaultpage   string `json:"defaultpage"`
-	Logfile       string `json:"logfile"`
-	Debug         bool   `json:"debug"`
-}
-
-//Server - interface used for all c2 profiles
-type Server interface {
-	ApfellBaseURL() string
-	SetApfellBaseURL(url string)
-	PostResponse(taskid string, output []byte) []byte
-	PostMessage(msg []byte) []byte
-	GetNextTask(apfellID string) []byte
-	Run(cf interface{})
-}
-
-//Message - struct definition for messages between clients and the server
-type Message struct {
-	Tag    string `json:"tag"`
-	Client bool   `json:"client"`
-	Data   string `json:"data"`
-}
-
-func NewInstance() interface{} {
-	return newServer()
-}

C2_Profiles/leviathan-websocket/c2_code/src/pkg/servers/websocket.go

@@ -1,298 +0,0 @@
-// +build websocket
-
-package servers
-
-import (
-	"bytes"
-	"crypto/tls"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"os"
-	"strings"
-
-	"github.com/gorilla/websocket"
-	"github.com/kabukky/httpscerts"
-)
-
-type WebsocketC2 struct {
-	BaseURL     string
-	BindAddress string
-	SSL         bool
-	SocketURI   string
-	Defaultpage string
-	Logfile     string
-	Debug       bool
-}
-
-var upgrader = websocket.Upgrader{}
-
-func newServer() Server {
-	return &WebsocketC2{}
-}
-
-func (s *WebsocketC2) SetBindAddress(addr string) {
-	s.BindAddress = addr
-}
-
-//ApfellBaseURL - Returns the base url for apfell
-func (s WebsocketC2) ApfellBaseURL() string {
-	return s.BaseURL
-}
-
-//SetApfellBaseURL - Sets the base url for apfell
-func (s *WebsocketC2) SetApfellBaseURL(url string) {
-	s.BaseURL = url
-}
-
-//SetSocketURI - Set socket uri
-func (s *WebsocketC2) SetSocketURI(uri string) {
-	s.SocketURI = uri
-}
-
-func (s *WebsocketC2) PostMessage(msg []byte) []byte {
-	return s.htmlPostData("", msg)
-}
-
-func (s WebsocketC2) GetNextTask(apfellID string) []byte {
-	//place holder
-	//url := fmt.Sprintf("%sapi/v%s/agent_message", s.ApfellBaseURL(), ApiVersion)
-	return make([]byte, 0)
-}
-
-func (s WebsocketC2) PostResponse(taskid string, output []byte) []byte {
-	//urlEnding := fmt.Sprintf("api/v%s/agent_message", ApiVersion)
-	return output
-}
-
-//postRESTResponse - Wrapper to post task responses through the Apfell rest API
-func (s *WebsocketC2) postRESTResponse(urlEnding string, data []byte) []byte {
-	return make([]byte, 0)
-}
-
-//htmlPostData HTTP POST function
-func (s *WebsocketC2) htmlPostData(urlEnding string, sendData []byte) []byte {
-	url :=  s.ApfellBaseURL()
-	//log.Println("Sending POST request to url: ", url)
-	s.Websocketlog(fmt.Sprintln("Sending POST request to: ", url))
-
-	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(sendData))
-	contentLength := len(sendData)
-	req.ContentLength = int64(contentLength)
-	tr := &http.Transport{
-		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-	}
-	client := &http.Client{Transport: tr}
-	resp, err := client.Do(req)
-
-	if err != nil {
-		s.Websocketlog(fmt.Sprintf("Error sending POST request: %s", err.Error()))
-		return make([]byte, 0)
-	}
-
-	if resp.StatusCode != 200 {
-		s.Websocketlog(fmt.Sprintf("Did not receive 200 response code: %d", resp.StatusCode))
-		return make([]byte, 0)
-	}
-
-	defer resp.Body.Close()
-
-	body, err := ioutil.ReadAll(resp.Body)
-
-	if err != nil {
-		s.Websocketlog(fmt.Sprintf("Error reading response body: %s", err.Error()))
-		return make([]byte, 0)
-	}
-
-	return body
-}
-
-//htmlGetData - HTTP GET request for data
-func (s *WebsocketC2) htmlGetData(url string) []byte {
-	//log.Println("Sending HTML GET request to url: ", url)
-	tr := &http.Transport{
-		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-	}
-	client := &http.Client{Transport: tr}
-	var respBody []byte
-
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		s.Websocketlog(fmt.Sprintf("Error creating http request: %s", err.Error()))
-		return make([]byte, 0)
-	}
-
-	resp, err := client.Do(req)
-
-	if err != nil {
-		s.Websocketlog(fmt.Sprintf("Error completing GET request: %s", err.Error()))
-		return make([]byte, 0)
-	}
-
-	if resp.StatusCode != 200 {
-		s.Websocketlog(fmt.Sprintf("Did not receive 200 response code: %d", resp.StatusCode))
-		return make([]byte, 0)
-	}
-
-	defer resp.Body.Close()
-
-	respBody, _ = ioutil.ReadAll(resp.Body)
-
-	return respBody
-
-}
-
-func (s *WebsocketC2) SetDebug(debug bool) {
-	s.Debug = debug
-}
-
-//GetDefaultPage - Get the default html page
-func (s WebsocketC2) GetDefaultPage() string {
-	return s.Defaultpage
-}
-
-//SetDefaultPage - Set the default html page
-func (s *WebsocketC2) SetDefaultPage(newpage string) {
-	s.Defaultpage = newpage
-}
-
-//SocketHandler - Websockets handler
-func (s WebsocketC2) SocketHandler(w http.ResponseWriter, r *http.Request) {
-	//Upgrade the websocket connection
-	upgrader.CheckOrigin = func(r *http.Request) bool { return true }
-	conn, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		s.Websocketlog(fmt.Sprintf("Websocket upgrade failed: %s\n", err.Error()))
-		http.Error(w, "websocket connection failed", http.StatusBadRequest)
-		return
-	}
-
-	s.Websocketlog("Received new websocket client")
-
-	go s.manageClient(conn)
-
-}
-
-func (s *WebsocketC2) manageClient(c *websocket.Conn) {
-
-LOOP:
-	for {
-		// Wait for the client to send the initial checkin message
-		m := Message{}
-		err := c.ReadJSON(&m)
-
-		if err != nil {
-			s.Websocketlog(fmt.Sprintf("Read error %s. Exiting session", err.Error()))
-			return
-		}
-
-		var resp []byte
-		if m.Client {
-			s.Websocketlog(fmt.Sprintf("Received agent message %+v\n", m))
-			resp = s.PostMessage([]byte(m.Data))
-		}
-
-		reply := Message{Client: false}
-
-		if len(resp) == 0 {
-			reply.Data = string(make([]byte, 1))
-		} else {
-			reply.Data = string(resp)
-		}
-
-		reply.Tag = m.Tag
-
-		if err = c.WriteJSON(reply); err != nil {
-			s.Websocketlog(fmt.Sprintf("Error writing json to client %s", err.Error()))
-			break LOOP
-		}
-
-	}
-
-	c.Close()
-
-}
-
-//ServeDefaultPage - HTTP handler
-func (s WebsocketC2) ServeDefaultPage(w http.ResponseWriter, r *http.Request) {
-	log.Println("Received request: ", r.URL)
-	log.Println("URI Path ", r.URL.Path)
-	if (r.URL.Path == "/" || r.URL.Path == "/index.html") && r.Method == "GET" {
-		// Serve the default page if we receive a GET request at the base URI
-		http.ServeFile(w, r, s.GetDefaultPage())
-	}
-
-	http.Error(w, "Not Found", http.StatusNotFound)
-	return
-}
-//Run - main function for the websocket profile
-func (s WebsocketC2) Run(config interface{}) {
-	cf := config.(C2Config)
-    s.Debug = cf.Debug
-	s.SetDefaultPage(cf.Defaultpage)
-	s.SetApfellBaseURL(os.Getenv("MYTHIC_ADDRESS"))
-	s.SetBindAddress(cf.BindAddress)
-	s.SetSocketURI(cf.SocketURI)
-
-	// Handle requests to the base uri
-	http.HandleFunc("/", s.ServeDefaultPage)
-	// Handle requests to the websockets uri
-	http.HandleFunc(fmt.Sprintf("/%s", s.SocketURI), s.SocketHandler)
-
-	// Setup all of the options according to the configuration
-	if !strings.Contains(cf.SSLKey, "") && !strings.Contains(cf.SSLCert, "") {
-
-		// copy the key and cert to the local directory
-		keyfile, err := ioutil.ReadFile(cf.SSLKey)
-		if err != nil {
-			log.Println("Unable to read key file ", err.Error())
-		}
-
-		err = ioutil.WriteFile("key.pem", keyfile, 0644)
-		if err != nil {
-			log.Println("Unable to write key file ", err.Error())
-		}
-
-		certfile, err := ioutil.ReadFile(cf.SSLCert)
-		if err != nil {
-			log.Println("Unable to read cert file ", err.Error())
-		}
-
-		err = ioutil.WriteFile("cert.pem", certfile, 0644)
-		if err != nil {
-			log.Println("Unable to write cert file ", err.Error())
-		}
-	}
-
-	if cf.UseSSL {
-		err := httpscerts.Check("cert.pem", "key.pem")
-		if err != nil {
-			s.Websocketlog(fmt.Sprintf("Error for cert.pem or key.pem %s", err.Error()))
-			err = httpscerts.Generate("cert.pem", "key.pem", cf.BindAddress)
-			if err != nil {
-				log.Fatal("Error generating https cert")
-				os.Exit(1)
-			}
-		}
-
-		s.Websocketlog(fmt.Sprintf("Starting SSL server at https://%s and wss://%s", cf.BindAddress, cf.BindAddress))
-		err = http.ListenAndServeTLS(cf.BindAddress, "cert.pem", "key.pem", nil)
-		if err != nil {
-			log.Fatal("Failed to start raven server: ", err)
-		}
-	} else {
-		s.Websocketlog(fmt.Sprintf("Starting server at http://%s and ws://%s", cf.BindAddress, cf.BindAddress))
-		err := http.ListenAndServe(cf.BindAddress, nil)
-		if err != nil {
-			log.Fatal("Failed to start raven server: ", err)
-		}
-	}
-}
-
-//Websocketlog - logging function
-func (s WebsocketC2) Websocketlog(msg string) {
-	if s.Debug {
-		log.Println(msg)
-	}
-}

C2_Profiles/leviathan-websocket/mythic/C2ProfileBase.py

@@ -1,130 +0,0 @@
-from enum import Enum
-from abc import abstractmethod
-import json
-
-
-class ParameterType(Enum):
-    String = "String"
-    ChooseOne = "ChooseOne"
-    Array = "Array"
-    Date = "Date"
-    Dictionary = "Dictionary"
-
-
-class C2ProfileParameter:
-    def __init__(
-        self,
-        name: str,
-        description: str,
-        default_value: str = "",
-        randomize: bool = False,
-        format_string: str = "",
-        parameter_type: ParameterType = ParameterType.String,
-        required: bool = True,
-        verifier_regex: str = "",
-        choices: [str] = None,
-    ):
-        self.name = name
-        self.description = description
-        self.randomize = randomize
-        self.format_string = format_string
-        self.parameter_type = parameter_type
-        self.required = required
-        self.verifier_regex = verifier_regex
-        self.choices = choices
-        self.default_value = ""
-        if self.parameter_type == ParameterType.ChooseOne and choices is not None:
-            self.default_value = "\n".join(choices)
-        else:
-            self.default_value = default_value
-
-
-    def to_json(self):
-        return {
-            "name": self.name,
-            "description": self.description,
-            "default_value": self.default_value if self.parameter_type not in [ParameterType.Array, ParameterType.Dictionary] else json.dumps(self.default_value),
-            "randomize": self.randomize,
-            "format_string": self.format_string,
-            "required": self.required,
-            "parameter_type": self.parameter_type.value,
-            "verifier_regex": self.verifier_regex,
-        }
-
-
-class C2Profile:
-    @property
-    @abstractmethod
-    def name(self):
-        pass
-
-    @property
-    @abstractmethod
-    def description(self):
-        pass
-
-    @property
-    @abstractmethod
-    def author(self):
-        pass
-
-    @property
-    @abstractmethod
-    def is_p2p(self):
-        pass
-
-    @property
-    @abstractmethod
-    def is_server_routed(self):
-        pass
-
-    @property
-    @abstractmethod
-    def mythic_encrypts(self):
-        pass
-
-    @property
-    @abstractmethod
-    def parameters(self):
-        pass
-
-    def to_json(self):
-        return {
-            "name": self.name,
-            "description": self.description,
-            "author": self.author,
-            "mythic_encrypts": self.mythic_encrypts,
-            "is_p2p": self.is_p2p,
-            "is_server_routed": self.is_server_routed,
-            "params": [x.to_json() for x in self.parameters],
-        }
-
-
-class RPCStatus(Enum):
-    Success = "success"
-    Error = "error"
-
-
-class RPCResponse:
-    def __init__(self, status: RPCStatus = None, response: str = None):
-        self.status = status
-        self.response = response
-
-    @property
-    def status(self):
-        return self._status
-
-    @status.setter
-    def status(self, status):
-        self._status = status
-
-    @property
-    def response(self):
-        return self._response
-
-    @response.setter
-    def response(self, response):
-        self._response = response
-
-    def to_json(self):
-        return {"status": self.status.value, "response": self.response}

C2_Profiles/leviathan-websocket/mythic/MythicBaseRPC.py

@@ -1,99 +0,0 @@
-from aio_pika import connect_robust, IncomingMessage, Message
-import asyncio
-import uuid
-import json
-from enum import Enum
-
-
-class MythicStatus(Enum):
-    Success = "success"
-    Error = "error"
-
-
-class RPCResponse:
-    def __init__(self, resp: dict):
-        self._raw_resp = resp
-        if resp["status"] == "success":
-            self.status = MythicStatus.Success
-            self.response = resp["response"] if "response" in resp else ""
-            self.error_message = None
-        else:
-            self.status = MythicStatus.Error
-            self.error_message = resp["error"]
-            self.response = None
-
-    @property
-    def status(self):
-        return self._status
-
-    @status.setter
-    def status(self, status):
-        self._status = status
-
-    @property
-    def error_message(self):
-        return self._error_message
-
-    @error_message.setter
-    def error_message(self, error_message):
-        self._error_message = error_message
-
-    @property
-    def response(self):
-        return self._response
-
-    @response.setter
-    def response(self, response):
-        self._response = response
-
-
-class MythicBaseRPC:
-    def __init__(self):
-        self.connection = None
-        self.channel = None
-        self.callback_queue = None
-        self.futures = {}
-        self.loop = asyncio.get_event_loop()
-
-    async def connect(self):
-        config_file = open("/Mythic/mythic/rabbitmq_config.json", "rb")
-        main_config = json.loads(config_file.read().decode("utf-8"))
-        config_file.close()
-        self.connection = await connect_robust(
-            host=main_config["host"],
-            login=main_config["username"],
-            password=main_config["password"],
-            virtualhost=main_config["virtual_host"],
-        )
-        self.channel = await self.connection.channel()
-        self.callback_queue = await self.channel.declare_queue(exclusive=True)
-        await self.callback_queue.consume(self.on_response)
-
-        return self
-
-    def on_response(self, message: IncomingMessage):
-        future = self.futures.pop(message.correlation_id)
-        future.set_result(message.body)
-
-    async def call(self, n, receiver: str = None) -> RPCResponse:
-        if self.connection is None:
-            await self.connect()
-        correlation_id = str(uuid.uuid4())
-        future = self.loop.create_future()
-
-        self.futures[correlation_id] = future
-        if receiver is None:
-            router = "c2rpc_queue"
-        else:
-            router = "{}_rpc_queue".format(receiver)
-        await self.channel.default_exchange.publish(
-            Message(
-                json.dumps(n).encode(),
-                content_type="application/json",
-                correlation_id=correlation_id,
-                reply_to=self.callback_queue.name,
-            ),
-            routing_key=router,
-        )
-
-        return RPCResponse(json.loads(await future))

C2_Profiles/leviathan-websocket/mythic/MythicCallbackRPC.py

@@ -1,124 +0,0 @@
-from MythicBaseRPC import *
-import base64
-
-
-class MythicRPCResponse(RPCResponse):
-    def __init__(self, resp: RPCResponse):
-        super().__init__(resp._raw_resp)
-        if resp.status == MythicStatus.Success:
-            self.data = resp.response
-        else:
-            self.data = None
-
-    @property
-    def data(self):
-        return self._data
-
-    @data.setter
-    def data(self, data):
-        self._data = data
-
-
-class MythicCallbackRPC(MythicBaseRPC):
-    # returns dictionary of `{"raw": raw_tasking, "encrypted": base64(uuid+encrypted_tasking)}`
-    async def get_tasking(
-        self, uuid: str, tasking_size: int = 1
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "get_tasking",
-                "uuid": uuid,
-                "tasking_size": tasking_size,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def add_route(
-        self,
-        source_uuid: str,
-        destination_uuid: str,
-        direction: int = 1,
-        metadata: str = None,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "add_route",
-                "source": source_uuid,
-                "destination": destination_uuid,
-                "direction": direction,
-                "metadata": metadata,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def remove_route(
-        self,
-        source_uuid: str,
-        destination_uuid: str,
-        direction: int = 1,
-        metadata: str = None,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "remove_route",
-                "source": source_uuid,
-                "destination": destination_uuid,
-                "direction": direction,
-                "metadata": metadata,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def get_callback_info(self, uuid: str) -> MythicRPCResponse:
-        resp = await self.call({"action": "get_callback_info", "uuid": uuid})
-        return MythicRPCResponse(resp)
-
-    async def get_encryption_data(self, uuid: str, profile: str) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "get_encryption_data",
-                "uuid": uuid,
-                "c2_profile": profile,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def update_callback_info(self, uuid: str, info: dict) -> MythicRPCResponse:
-        resp = await self.call(
-            {"action": "update_callback_info", "uuid": uuid, "data": info}
-        )
-        return MythicRPCResponse(resp)
-
-    async def add_event_message(
-        self, message: str, level: str = "info"
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {"action": "add_event_message", "level": level, "message": message}
-        )
-        return MythicRPCResponse(resp)
-
-    async def encrypt_bytes(
-        self, data: bytes, uuid: str, with_uuid: bool = False,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "encrypt_bytes",
-                "data": base64.b64encode(data).decode(),
-                "uuid": uuid,
-                "with_uuid": with_uuid,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def decrypt_bytes(
-        self, data: bytes, uuid: str, with_uuid: bool = False,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "decrypt_bytes",
-                "uuid": uuid,
-                "data": base64.b64encode(data).decode(),
-                "with_uuid": with_uuid,
-            }
-        )
-        return MythicRPCResponse(resp)

C2_Profiles/leviathan-websocket/mythic/c2_functions/C2_RPC_functions.py

@@ -1,11 +0,0 @@
-from C2ProfileBase import *
-import MythicCallbackRPC
-
-# request is a dictionary: {"action": func_name, "message": "the input",  "task_id": task id num}
-# must return an RPCResponse() object and set .status to an instance of RPCStatus and response to str of message
-async def test(request):
-    response = RPCResponse()
-    response.status = RPCStatus.Success
-    response.response = "hello"
-    #resp = await MythicCallbackRPC.MythicCallbackRPC().add_event_message(message="got a POST message")
-    return response

C2_Profiles/leviathan-websocket/mythic/c2_functions/websocket.py

@@ -1,38 +0,0 @@
-from C2ProfileBase import *
-
-
-class Websocket(C2Profile):
-    name = "leviathan-websocket"
-    description = "Websocket C2 Server for Leviathan"
-    author = "@xorrior"
-    is_p2p = False
-    is_server_routed = False
-    mythic_encrypts = True
-    parameters = [
-        C2ProfileParameter(
-            name="callback_host",
-            description="Callback Host",
-            default_value="ws://127.0.0.1",
-            verifier_regex="^(ws|wss)://[a-zA-Z0-9]+",
-        ),
-        C2ProfileParameter(
-            name="callback_interval",
-            description="Callback Interval in seconds",
-            default_value="10",
-            verifier_regex="^[0-9]+$",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="ENDPOINT_REPLACE",
-            description="Websockets Endpoint",
-            default_value="socket",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="callback_port",
-            description="Callback Port",
-            default_value="8081",
-            verifier_regex="^[0-9]+$",
-            required=False,
-        ),
-    ]

C2_Profiles/leviathan-websocket/mythic/c2_service.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-cd /Mythic/mythic
-
-export PYTHONPATH=/Mythic:/Mythic/mythic
-
-python3.8 mythic_service.py

C2_Profiles/leviathan-websocket/mythic/mythic_service.py

@@ -1,410 +0,0 @@
-#!/usr/bin/env python3
-import aio_pika
-import os
-import time
-import sys
-import subprocess
-import _thread
-import base64
-import json
-import socket
-import asyncio
-import pathlib
-import traceback
-from C2ProfileBase import *
-from importlib import import_module, invalidate_caches
-from functools import partial
-
-credentials = None
-connection_params = None
-running = False
-process = None
-thread = None
-hostname = ""
-output = ""
-exchange = None
-container_files_path = None
-
-
-def deal_with_stdout():
-    global process
-    global output
-    while True:
-        try:
-            for line in iter(process.stdout.readline, b""):
-                output += line.decode("utf-8")
-        except Exception as e:
-            print("Exiting thread due to: {}\n".format(str(e)))
-            sys.stdout.flush()
-            break
-
-
-def import_all_c2_functions():
-    import glob
-
-    # Get file paths of all modules.
-    modules = glob.glob("c2_functions/*.py")
-    invalidate_caches()
-    for x in modules:
-        if not x.endswith("__init__.py") and x[-3:] == ".py":
-            module = import_module("c2_functions." + pathlib.Path(x).stem, package=None)
-            for el in dir(module):
-                if "__" not in el:
-                    globals()[el] = getattr(module, el)
-
-
-async def send_status(message="", routing_key=""):
-    global exchange
-    try:
-        message_body = aio_pika.Message(message.encode())
-        await exchange.publish(message_body, routing_key=routing_key)
-    except Exception as e:
-        print("Exception in send_status: {}".format(str(e)))
-        sys.stdout.flush()
-
-
-async def callback(message: aio_pika.IncomingMessage):
-    global running
-    global process
-    global output
-    global thread
-    global hostname
-    global container_files_path
-    with message.process():
-        # messages of the form: c2.modify.PROFILE NAME.command
-        try:
-            command = message.routing_key.split(".")[3]
-            username = message.routing_key.split(".")[4]
-            server_path = container_files_path / "server"
-            # command = body.decode('utf-8')
-            if command == "start":
-                if not running:
-                    # make sure to start the /Apfell/server in the background
-                    os.chmod(server_path, mode=0o777)
-                    output = ""
-                    process = subprocess.Popen(
-                        str(server_path),
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.STDOUT,
-                        cwd=str(container_files_path),
-                    )
-                    thread = _thread.start_new_thread(deal_with_stdout, ())
-                    time.sleep(3)
-                    process.poll()
-                    if process.returncode is not None:
-                        # this means something went wrong and the process is dead
-                        running = False
-                        await send_status(
-                            message="Failed to start\nOutput: {}".format(output),
-                            routing_key="c2.status.{}.stopped.start.{}".format(
-                                hostname, username
-                            ),
-                        )
-                        output = ""
-                    else:
-                        running = True
-                        await send_status(
-                            message="Started with pid: {}...\nOutput: {}".format(
-                                str(process.pid), output
-                            ),
-                            routing_key="c2.status.{}.running.start.{}".format(
-                                hostname, username
-                            ),
-                        )
-                        output = ""
-                else:
-                    await send_status(
-                        message="Already running...\nOutput: {}".format(output),
-                        routing_key="c2.status.{}.running.start.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-            elif command == "stop":
-                if running:
-                    try:
-                        process.kill()
-                        process.communicate()
-                    except Exception as e:
-                        pass
-                    try:
-                        thread.exit()
-                    except Exception as e:
-                        pass
-                    running = False
-                    await send_status(
-                        message="Process killed...\nOld Output: {}".format(output),
-                        routing_key="c2.status.{}.stopped.stop.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-                else:
-                    await send_status(
-                        message="Process not running...\nOld Output: {}".format(output),
-                        routing_key="c2.status.{}.stopped.stop.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-                # make sure to stop the /Apfell/server in the background
-            elif command == "status":
-                if running:
-                    await send_status(
-                        message="Output: {}".format(output),
-                        routing_key="c2.status.{}.running.status.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-                else:
-                    await send_status(
-                        message="C2 is not running",
-                        routing_key="c2.status.{}.stopped.status.{}".format(
-                            hostname, username
-                        ),
-                    )
-            elif command == "get_config":
-                try:
-                    path = container_files_path / "config.json"
-                    file_data = open(path, "rb").read()
-                except Exception as e:
-                    file_data = b"File not found"
-                encoded_data = json.dumps(
-                    {
-                        "filename": "config.json",
-                        "data": base64.b64encode(file_data).decode("utf-8"),
-                    }
-                )
-                await send_status(
-                    message=encoded_data,
-                    routing_key="c2.status.{}.{}.get_config.{}".format(
-                        hostname, "running" if running else "stopped", username
-                    ),
-                )
-            elif command == "writefile":
-                try:
-                    message = json.loads(message.body.decode("utf-8"))
-                    file_path = container_files_path / message["file_path"]
-                    file_path = file_path.resolve()
-                    if container_files_path not in file_path.parents:
-                        response = {
-                            "status": "error",
-                            "error": "trying to break out of path",
-                        }
-                    else:
-                        file = open(file_path, "wb")
-                        file.write(base64.b64decode(message["data"]))
-                        file.close()
-                        response = {"status": "success", "file": message["file_path"]}
-                except Exception as e:
-                    response = {"status": "error", "error": str(e)}
-                await send_status(
-                    message=json.dumps(response),
-                    routing_key="c2.status.{}.{}.writefile.{}".format(
-                        hostname, "running" if running else "stopped", username
-                    ),
-                )
-            elif command == "sync_classes":
-                try:
-                    import_all_c2_functions()
-                    # c2profile = {}
-                    for cls in C2Profile.__subclasses__():
-                        c2profile = cls().to_json()
-                        break
-                    await send_status(
-                        message=json.dumps(c2profile),
-                        routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                            hostname, "running" if running else "stopped", username
-                        ),
-                    )
-                except Exception as e:
-                    await send_status(
-                        message='{"message": "Error while syncing info: {}"}'.format(
-                            str(traceback.format_exc())
-                        ),
-                        routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                            hostname, "running" if running else "stopped", username
-                        ),
-                    )
-            else:
-                print("Unknown command: {}".format(command))
-                sys.stdout.flush()
-        except Exception as e:
-            print("Failed overall message processing: " + str(e))
-            sys.stdout.flush()
-
-
-async def sync_classes():
-    try:
-        import_all_c2_functions()
-        c2profile = {}
-        for cls in C2Profile.__subclasses__():
-            c2profile = cls().to_json()
-            break
-        await send_status(
-            message=json.dumps(c2profile),
-            routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                hostname, "stopped", ""
-            ),
-        )
-    except Exception as e:
-        await send_status(
-            message='{"message": "Error while syncing info: {}"}'.format(
-                str(traceback.format_exc())
-            ),
-            routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                hostname, "stopped", ""
-            ),
-        )
-
-
-async def rabbit_c2_rpc_callback(
-    exchange: aio_pika.Exchange, message: aio_pika.IncomingMessage
-):
-    with message.process():
-        request = json.loads(message.body.decode())
-        if "action" in request:
-            response = await globals()[request["action"]](request)
-            response = json.dumps(response.to_json()).encode()
-        else:
-            response = json.dumps(
-                {"status": "error", "error": "Missing action"}
-            ).encode()
-        try:
-            await exchange.publish(
-                aio_pika.Message(body=response, correlation_id=message.correlation_id),
-                routing_key=message.reply_to,
-            )
-        except Exception as e:
-            print(
-                "Exception trying to send message back to container for rpc! " + str(e)
-            )
-            sys.stdout.flush()
-
-
-async def connect_and_consume_rpc():
-    connection = None
-    global hostname
-    while connection is None:
-        try:
-            connection = await aio_pika.connect_robust(
-                host="127.0.0.1",
-                login="mythic_user",
-                password="mythic_password",
-                virtualhost="mythic_vhost",
-            )
-            channel = await connection.channel()
-            # get a random queue that only the apfell server will use to listen on to catch all heartbeats
-            queue = await channel.declare_queue("{}_rpc_queue".format(hostname))
-            await channel.set_qos(prefetch_count=50)
-            try:
-                task = queue.consume(
-                    partial(rabbit_c2_rpc_callback, channel.default_exchange)
-                )
-                result = await asyncio.wait_for(task, None)
-            except Exception as e:
-                print("Exception in connect_and_consume .consume: {}".format(str(e)))
-                sys.stdout.flush()
-        except (ConnectionError, ConnectionRefusedError) as c:
-            print("Connection to rabbitmq failed, trying again...")
-            sys.stdout.flush()
-        except Exception as e:
-            print("Exception in connect_and_consume_rpc connect: {}".format(str(e)))
-            # print("Exception in connect_and_consume connect: {}".format(str(e)))
-            sys.stdout.flush()
-        await asyncio.sleep(2)
-
-
-async def mythic_service():
-    global hostname
-    global exchange
-    global container_files_path
-    connection = None
-    config_file = open("rabbitmq_config.json", "rb")
-    main_config = json.loads(config_file.read().decode("utf-8"))
-    config_file.close()
-    if main_config["name"] == "hostname":
-        hostname = socket.gethostname()
-    else:
-        hostname = main_config["name"]
-    container_files_path = pathlib.Path(
-        os.path.abspath(main_config["container_files_path"])
-    )
-    container_files_path = container_files_path / "c2_code"
-    while connection is None:
-        try:
-            connection = await aio_pika.connect_robust(
-                host=main_config["host"],
-                login=main_config["username"],
-                password=main_config["password"],
-                virtualhost=main_config["virtual_host"],
-            )
-        except Exception as e:
-            await asyncio.sleep(2)
-    try:
-        channel = await connection.channel()
-        exchange = await channel.declare_exchange(
-            "mythic_traffic", aio_pika.ExchangeType.TOPIC
-        )
-        queue = await channel.declare_queue("", exclusive=True)
-        await queue.bind(
-            exchange="mythic_traffic", routing_key="c2.modify.{}.#".format(hostname)
-        )
-        # just want to handle one message at a time so we can clean up and be ready
-        await channel.set_qos(prefetch_count=30)
-        print("Listening for c2.modify.{}.#".format(hostname))
-        sys.stdout.flush()
-        task = queue.consume(callback)
-        await sync_classes()
-        task4 = asyncio.ensure_future(connect_and_consume_rpc())
-        result = await asyncio.gather(task, task4)
-        # send_status(message="", routing_key="c2.status.{}.stopped.stop".format(hostname))
-    except Exception as e:
-        print(str(traceback.format_exc()))
-        sys.stdout.flush()
-
-
-async def heartbeat_loop():
-    config_file = open("rabbitmq_config.json", "rb")
-    main_config = json.loads(config_file.read().decode("utf-8"))
-    config_file.close()
-    if main_config["name"] == "hostname":
-        hostname = socket.gethostname()
-    else:
-        hostname = main_config["name"]
-    while True:
-        try:
-            connection = await aio_pika.connect_robust(
-                host=main_config["host"],
-                login=main_config["username"],
-                password=main_config["password"],
-                virtualhost=main_config["virtual_host"],
-            )
-            channel = await connection.channel()
-            # declare our heartbeat exchange that everybody will publish to, but only the apfell server will are about
-            exchange = await channel.declare_exchange(
-                "mythic_traffic", aio_pika.ExchangeType.TOPIC
-            )
-        except Exception as e:
-            print(str(e))
-            await asyncio.sleep(2)
-            continue
-        while True:
-            try:
-                # routing key is ignored for fanout, it'll go to anybody that's listening, which will only be the server
-                await exchange.publish(
-                    aio_pika.Message("heartbeat".encode()),
-                    routing_key="c2.heartbeat.{}".format(hostname),
-                )
-                await asyncio.sleep(10)
-            except Exception as e:
-                print(str(e))
-                # if we get an exception here, break out to the bigger loop and try to connect again
-                break
-
-# start our service
-loop = asyncio.get_event_loop()
-loop.create_task(mythic_service())
-loop.create_task(heartbeat_loop())
-loop.run_forever()

C2_Profiles/leviathan-websocket/mythic/rabbitmq_config.json

@@ -1,8 +0,0 @@
-{
-  "username": "mythic_user",
-  "password": "mythic_password",
-  "virtual_host": "mythic_vhost",
-  "host": "127.0.0.1",
-  "name": "hostname",
-  "container_files_path": "/Mythic/"
-}

C2_Profiles/websocket/Dockerfile

@@ -1 +0,0 @@
-From itsafeaturemythic/python38_sanic_c2profile:0.0.1

C2_Profiles/websocket/c2_code/config.json

@@ -1,10 +0,0 @@
-{
-    "bindaddress": "0.0.0.0:8081",
-    "usessl": false,
-    "sslkey":"",
-    "sslcert":"",
-    "websocketuri": "socket",
-    "defaultpage": "index.html",
-    "logfile": "server.log",
-    "debug": false
-}

C2_Profiles/websocket/c2_code/index.html

@@ -1,9 +0,0 @@
-<!DOCTYPE>
-<html>
-<head>
-<title>Under Construction</title>
-</head>
-<body>
-<p>This page is under construction. Please come back soon!</p>
-</body>
-</html>

C2_Profiles/websocket/c2_code/src/build_help

@@ -1,8 +0,0 @@
-To build the sever:
-
-go get github.com/gorilla/websocket
-go get github.com/kabukky/httpscerts
-go build -tags=websocket main.go
-
-this outputs a binary called "main"
-move this to ../server

C2_Profiles/websocket/c2_code/src/main.go

@@ -1,35 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"log"
-	"os"
-
-	"./pkg/servers"
-)
-
-var cf *os.File
-func main() {
-	cf, err := os.Open("config.json")
-
-	if err != nil {
-		log.Println("Error opening config file ", err.Error())
-		os.Exit(-1)
-	}
-
-	config, _ := ioutil.ReadAll(cf)
-
-	c2config := servers.C2Config{}
-	err = json.Unmarshal(config, &c2config)
-	if err != nil {
-		log.Println("Error in unmarshal call for config ", err.Error())
-		os.Exit(-1)
-	}
-
-	// start the server instance with the config
-	c2server := servers.NewInstance().(servers.Server)
-
-	c2server.Run(c2config)
-
-}

C2_Profiles/websocket/c2_code/src/pkg/servers/server.go

@@ -1,34 +0,0 @@
-package servers
-
-// C2Config - struct for server configuration
-type C2Config struct {
-	BindAddress   string `json:"bindaddress"`
-	SocketURI     string `json:"websocketuri"`
-	SSLKey        string `json:"sslkey"`
-	SSLCert       string `json:"sslcert"`
-	UseSSL        bool   `json:"usessl"`
-	Defaultpage   string `json:"defaultpage"`
-	Logfile       string `json:"logfile"`
-	Debug         bool   `json:"debug"`
-}
-
-//Server - interface used for all c2 profiles
-type Server interface {
-	ApfellBaseURL() string
-	SetApfellBaseURL(url string)
-	PostResponse(taskid string, output []byte) []byte
-	PostMessage(msg []byte) []byte
-	GetNextTask(apfellID string) []byte
-	Run(cf interface{})
-}
-
-//Message - struct definition for messages between clients and the server
-type Message struct {
-	Tag    string `json:"tag"`
-	Client bool   `json:"client"`
-	Data   string `json:"data"`
-}
-
-func NewInstance() interface{} {
-	return newServer()
-}

C2_Profiles/websocket/c2_code/src/pkg/servers/websocket.go

@@ -1,298 +0,0 @@
-// +build websocket
-
-package servers
-
-import (
-	"bytes"
-	"crypto/tls"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"os"
-	"strings"
-
-	"github.com/gorilla/websocket"
-	"github.com/kabukky/httpscerts"
-)
-
-type WebsocketC2 struct {
-	BaseURL     string
-	BindAddress string
-	SSL         bool
-	SocketURI   string
-	Defaultpage string
-	Logfile     string
-	Debug       bool
-}
-
-var upgrader = websocket.Upgrader{}
-
-func newServer() Server {
-	return &WebsocketC2{}
-}
-
-func (s *WebsocketC2) SetBindAddress(addr string) {
-	s.BindAddress = addr
-}
-
-//ApfellBaseURL - Returns the base url for apfell
-func (s WebsocketC2) ApfellBaseURL() string {
-	return s.BaseURL
-}
-
-//SetApfellBaseURL - Sets the base url for apfell
-func (s *WebsocketC2) SetApfellBaseURL(url string) {
-	s.BaseURL = url
-}
-
-//SetSocketURI - Set socket uri
-func (s *WebsocketC2) SetSocketURI(uri string) {
-	s.SocketURI = uri
-}
-
-func (s *WebsocketC2) PostMessage(msg []byte) []byte {
-	return s.htmlPostData("", msg)
-}
-
-func (s WebsocketC2) GetNextTask(apfellID string) []byte {
-	//place holder
-	//url := fmt.Sprintf("%sapi/v%s/agent_message", s.ApfellBaseURL(), ApiVersion)
-	return make([]byte, 0)
-}
-
-func (s WebsocketC2) PostResponse(taskid string, output []byte) []byte {
-	//urlEnding := fmt.Sprintf("api/v%s/agent_message", ApiVersion)
-	return output
-}
-
-//postRESTResponse - Wrapper to post task responses through the Apfell rest API
-func (s *WebsocketC2) postRESTResponse(urlEnding string, data []byte) []byte {
-	return make([]byte, 0)
-}
-
-//htmlPostData HTTP POST function
-func (s *WebsocketC2) htmlPostData(urlEnding string, sendData []byte) []byte {
-	url :=  s.ApfellBaseURL()
-	//log.Println("Sending POST request to url: ", url)
-	s.Websocketlog(fmt.Sprintln("Sending POST request to: ", url))
-
-	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(sendData))
-	contentLength := len(sendData)
-	req.ContentLength = int64(contentLength)
-	tr := &http.Transport{
-		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-	}
-	client := &http.Client{Transport: tr}
-	resp, err := client.Do(req)
-
-	if err != nil {
-		s.Websocketlog(fmt.Sprintf("Error sending POST request: %s", err.Error()))
-		return make([]byte, 0)
-	}
-
-	if resp.StatusCode != 200 {
-		s.Websocketlog(fmt.Sprintf("Did not receive 200 response code: %d", resp.StatusCode))
-		return make([]byte, 0)
-	}
-
-	defer resp.Body.Close()
-
-	body, err := ioutil.ReadAll(resp.Body)
-
-	if err != nil {
-		s.Websocketlog(fmt.Sprintf("Error reading response body: %s", err.Error()))
-		return make([]byte, 0)
-	}
-
-	return body
-}
-
-//htmlGetData - HTTP GET request for data
-func (s *WebsocketC2) htmlGetData(url string) []byte {
-	//log.Println("Sending HTML GET request to url: ", url)
-	tr := &http.Transport{
-		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-	}
-	client := &http.Client{Transport: tr}
-	var respBody []byte
-
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		s.Websocketlog(fmt.Sprintf("Error creating http request: %s", err.Error()))
-		return make([]byte, 0)
-	}
-
-	resp, err := client.Do(req)
-
-	if err != nil {
-		s.Websocketlog(fmt.Sprintf("Error completing GET request: %s", err.Error()))
-		return make([]byte, 0)
-	}
-
-	if resp.StatusCode != 200 {
-		s.Websocketlog(fmt.Sprintf("Did not receive 200 response code: %d", resp.StatusCode))
-		return make([]byte, 0)
-	}
-
-	defer resp.Body.Close()
-
-	respBody, _ = ioutil.ReadAll(resp.Body)
-
-	return respBody
-
-}
-
-func (s *WebsocketC2) SetDebug(debug bool) {
-	s.Debug = debug
-}
-
-//GetDefaultPage - Get the default html page
-func (s WebsocketC2) GetDefaultPage() string {
-	return s.Defaultpage
-}
-
-//SetDefaultPage - Set the default html page
-func (s *WebsocketC2) SetDefaultPage(newpage string) {
-	s.Defaultpage = newpage
-}
-
-//SocketHandler - Websockets handler
-func (s WebsocketC2) SocketHandler(w http.ResponseWriter, r *http.Request) {
-	//Upgrade the websocket connection
-	upgrader.CheckOrigin = func(r *http.Request) bool { return true }
-	conn, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		s.Websocketlog(fmt.Sprintf("Websocket upgrade failed: %s\n", err.Error()))
-		http.Error(w, "websocket connection failed", http.StatusBadRequest)
-		return
-	}
-
-	s.Websocketlog("Received new websocket client")
-
-	go s.manageClient(conn)
-
-}
-
-func (s *WebsocketC2) manageClient(c *websocket.Conn) {
-
-LOOP:
-	for {
-		// Wait for the client to send the initial checkin message
-		m := Message{}
-		err := c.ReadJSON(&m)
-
-		if err != nil {
-			s.Websocketlog(fmt.Sprintf("Read error %s. Exiting session", err.Error()))
-			return
-		}
-
-		var resp []byte
-		if m.Client {
-			s.Websocketlog(fmt.Sprintf("Received agent message %+v\n", m))
-			resp = s.PostMessage([]byte(m.Data))
-		}
-
-		reply := Message{Client: false}
-
-		if len(resp) == 0 {
-			reply.Data = string(make([]byte, 1))
-		} else {
-			reply.Data = string(resp)
-		}
-
-		reply.Tag = m.Tag
-
-		if err = c.WriteJSON(reply); err != nil {
-			s.Websocketlog(fmt.Sprintf("Error writing json to client %s", err.Error()))
-			break LOOP
-		}
-
-	}
-
-	c.Close()
-
-}
-
-//ServeDefaultPage - HTTP handler
-func (s WebsocketC2) ServeDefaultPage(w http.ResponseWriter, r *http.Request) {
-	log.Println("Received request: ", r.URL)
-	log.Println("URI Path ", r.URL.Path)
-	if (r.URL.Path == "/" || r.URL.Path == "/index.html") && r.Method == "GET" {
-		// Serve the default page if we receive a GET request at the base URI
-		http.ServeFile(w, r, s.GetDefaultPage())
-	}
-
-	http.Error(w, "Not Found", http.StatusNotFound)
-	return
-}
-//Run - main function for the websocket profile
-func (s WebsocketC2) Run(config interface{}) {
-	cf := config.(C2Config)
-    s.Debug = cf.Debug
-	s.SetDefaultPage(cf.Defaultpage)
-	s.SetApfellBaseURL(os.Getenv("MYTHIC_ADDRESS"))
-	s.SetBindAddress(cf.BindAddress)
-	s.SetSocketURI(cf.SocketURI)
-
-	// Handle requests to the base uri
-	http.HandleFunc("/", s.ServeDefaultPage)
-	// Handle requests to the websockets uri
-	http.HandleFunc(fmt.Sprintf("/%s", s.SocketURI), s.SocketHandler)
-
-	// Setup all of the options according to the configuration
-	if !strings.Contains(cf.SSLKey, "") && !strings.Contains(cf.SSLCert, "") {
-
-		// copy the key and cert to the local directory
-		keyfile, err := ioutil.ReadFile(cf.SSLKey)
-		if err != nil {
-			log.Println("Unable to read key file ", err.Error())
-		}
-
-		err = ioutil.WriteFile("key.pem", keyfile, 0644)
-		if err != nil {
-			log.Println("Unable to write key file ", err.Error())
-		}
-
-		certfile, err := ioutil.ReadFile(cf.SSLCert)
-		if err != nil {
-			log.Println("Unable to read cert file ", err.Error())
-		}
-
-		err = ioutil.WriteFile("cert.pem", certfile, 0644)
-		if err != nil {
-			log.Println("Unable to write cert file ", err.Error())
-		}
-	}
-
-	if cf.UseSSL {
-		err := httpscerts.Check("cert.pem", "key.pem")
-		if err != nil {
-			s.Websocketlog(fmt.Sprintf("Error for cert.pem or key.pem %s", err.Error()))
-			err = httpscerts.Generate("cert.pem", "key.pem", cf.BindAddress)
-			if err != nil {
-				log.Fatal("Error generating https cert")
-				os.Exit(1)
-			}
-		}
-
-		s.Websocketlog(fmt.Sprintf("Starting SSL server at https://%s and wss://%s", cf.BindAddress, cf.BindAddress))
-		err = http.ListenAndServeTLS(cf.BindAddress, "cert.pem", "key.pem", nil)
-		if err != nil {
-			log.Fatal("Failed to start raven server: ", err)
-		}
-	} else {
-		s.Websocketlog(fmt.Sprintf("Starting server at http://%s and ws://%s", cf.BindAddress, cf.BindAddress))
-		err := http.ListenAndServe(cf.BindAddress, nil)
-		if err != nil {
-			log.Fatal("Failed to start raven server: ", err)
-		}
-	}
-}
-
-//Websocketlog - logging function
-func (s WebsocketC2) Websocketlog(msg string) {
-	if s.Debug {
-		log.Println(msg)
-	}
-}

C2_Profiles/websocket/mythic/C2ProfileBase.py

@@ -1,130 +0,0 @@
-from enum import Enum
-from abc import abstractmethod
-import json
-
-
-class ParameterType(Enum):
-    String = "String"
-    ChooseOne = "ChooseOne"
-    Array = "Array"
-    Date = "Date"
-    Dictionary = "Dictionary"
-
-
-class C2ProfileParameter:
-    def __init__(
-        self,
-        name: str,
-        description: str,
-        default_value: str = "",
-        randomize: bool = False,
-        format_string: str = "",
-        parameter_type: ParameterType = ParameterType.String,
-        required: bool = True,
-        verifier_regex: str = "",
-        choices: [str] = None,
-    ):
-        self.name = name
-        self.description = description
-        self.randomize = randomize
-        self.format_string = format_string
-        self.parameter_type = parameter_type
-        self.required = required
-        self.verifier_regex = verifier_regex
-        self.choices = choices
-        self.default_value = ""
-        if self.parameter_type == ParameterType.ChooseOne and choices is not None:
-            self.default_value = "\n".join(choices)
-        else:
-            self.default_value = default_value
-
-
-    def to_json(self):
-        return {
-            "name": self.name,
-            "description": self.description,
-            "default_value": self.default_value if self.parameter_type not in [ParameterType.Array, ParameterType.Dictionary] else json.dumps(self.default_value),
-            "randomize": self.randomize,
-            "format_string": self.format_string,
-            "required": self.required,
-            "parameter_type": self.parameter_type.value,
-            "verifier_regex": self.verifier_regex,
-        }
-
-
-class C2Profile:
-    @property
-    @abstractmethod
-    def name(self):
-        pass
-
-    @property
-    @abstractmethod
-    def description(self):
-        pass
-
-    @property
-    @abstractmethod
-    def author(self):
-        pass
-
-    @property
-    @abstractmethod
-    def is_p2p(self):
-        pass
-
-    @property
-    @abstractmethod
-    def is_server_routed(self):
-        pass
-
-    @property
-    @abstractmethod
-    def mythic_encrypts(self):
-        pass
-
-    @property
-    @abstractmethod
-    def parameters(self):
-        pass
-
-    def to_json(self):
-        return {
-            "name": self.name,
-            "description": self.description,
-            "author": self.author,
-            "mythic_encrypts": self.mythic_encrypts,
-            "is_p2p": self.is_p2p,
-            "is_server_routed": self.is_server_routed,
-            "params": [x.to_json() for x in self.parameters],
-        }
-
-
-class RPCStatus(Enum):
-    Success = "success"
-    Error = "error"
-
-
-class RPCResponse:
-    def __init__(self, status: RPCStatus = None, response: str = None):
-        self.status = status
-        self.response = response
-
-    @property
-    def status(self):
-        return self._status
-
-    @status.setter
-    def status(self, status):
-        self._status = status
-
-    @property
-    def response(self):
-        return self._response
-
-    @response.setter
-    def response(self, response):
-        self._response = response
-
-    def to_json(self):
-        return {"status": self.status.value, "response": self.response}

C2_Profiles/websocket/mythic/MythicBaseRPC.py

@@ -1,99 +0,0 @@
-from aio_pika import connect_robust, IncomingMessage, Message
-import asyncio
-import uuid
-import json
-from enum import Enum
-
-
-class MythicStatus(Enum):
-    Success = "success"
-    Error = "error"
-
-
-class RPCResponse:
-    def __init__(self, resp: dict):
-        self._raw_resp = resp
-        if resp["status"] == "success":
-            self.status = MythicStatus.Success
-            self.response = resp["response"] if "response" in resp else ""
-            self.error_message = None
-        else:
-            self.status = MythicStatus.Error
-            self.error_message = resp["error"]
-            self.response = None
-
-    @property
-    def status(self):
-        return self._status
-
-    @status.setter
-    def status(self, status):
-        self._status = status
-
-    @property
-    def error_message(self):
-        return self._error_message
-
-    @error_message.setter
-    def error_message(self, error_message):
-        self._error_message = error_message
-
-    @property
-    def response(self):
-        return self._response
-
-    @response.setter
-    def response(self, response):
-        self._response = response
-
-
-class MythicBaseRPC:
-    def __init__(self):
-        self.connection = None
-        self.channel = None
-        self.callback_queue = None
-        self.futures = {}
-        self.loop = asyncio.get_event_loop()
-
-    async def connect(self):
-        config_file = open("/Mythic/mythic/rabbitmq_config.json", "rb")
-        main_config = json.loads(config_file.read().decode("utf-8"))
-        config_file.close()
-        self.connection = await connect_robust(
-            host=main_config["host"],
-            login=main_config["username"],
-            password=main_config["password"],
-            virtualhost=main_config["virtual_host"],
-        )
-        self.channel = await self.connection.channel()
-        self.callback_queue = await self.channel.declare_queue(exclusive=True)
-        await self.callback_queue.consume(self.on_response)
-
-        return self
-
-    def on_response(self, message: IncomingMessage):
-        future = self.futures.pop(message.correlation_id)
-        future.set_result(message.body)
-
-    async def call(self, n, receiver: str = None) -> RPCResponse:
-        if self.connection is None:
-            await self.connect()
-        correlation_id = str(uuid.uuid4())
-        future = self.loop.create_future()
-
-        self.futures[correlation_id] = future
-        if receiver is None:
-            router = "c2rpc_queue"
-        else:
-            router = "{}_rpc_queue".format(receiver)
-        await self.channel.default_exchange.publish(
-            Message(
-                json.dumps(n).encode(),
-                content_type="application/json",
-                correlation_id=correlation_id,
-                reply_to=self.callback_queue.name,
-            ),
-            routing_key=router,
-        )
-
-        return RPCResponse(json.loads(await future))

C2_Profiles/websocket/mythic/MythicCallbackRPC.py

@@ -1,124 +0,0 @@
-from MythicBaseRPC import *
-import base64
-
-
-class MythicRPCResponse(RPCResponse):
-    def __init__(self, resp: RPCResponse):
-        super().__init__(resp._raw_resp)
-        if resp.status == MythicStatus.Success:
-            self.data = resp.response
-        else:
-            self.data = None
-
-    @property
-    def data(self):
-        return self._data
-
-    @data.setter
-    def data(self, data):
-        self._data = data
-
-
-class MythicCallbackRPC(MythicBaseRPC):
-    # returns dictionary of `{"raw": raw_tasking, "encrypted": base64(uuid+encrypted_tasking)}`
-    async def get_tasking(
-        self, uuid: str, tasking_size: int = 1
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "get_tasking",
-                "uuid": uuid,
-                "tasking_size": tasking_size,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def add_route(
-        self,
-        source_uuid: str,
-        destination_uuid: str,
-        direction: int = 1,
-        metadata: str = None,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "add_route",
-                "source": source_uuid,
-                "destination": destination_uuid,
-                "direction": direction,
-                "metadata": metadata,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def remove_route(
-        self,
-        source_uuid: str,
-        destination_uuid: str,
-        direction: int = 1,
-        metadata: str = None,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "remove_route",
-                "source": source_uuid,
-                "destination": destination_uuid,
-                "direction": direction,
-                "metadata": metadata,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def get_callback_info(self, uuid: str) -> MythicRPCResponse:
-        resp = await self.call({"action": "get_callback_info", "uuid": uuid})
-        return MythicRPCResponse(resp)
-
-    async def get_encryption_data(self, uuid: str, profile: str) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "get_encryption_data",
-                "uuid": uuid,
-                "c2_profile": profile,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def update_callback_info(self, uuid: str, info: dict) -> MythicRPCResponse:
-        resp = await self.call(
-            {"action": "update_callback_info", "uuid": uuid, "data": info}
-        )
-        return MythicRPCResponse(resp)
-
-    async def add_event_message(
-        self, message: str, level: str = "info"
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {"action": "add_event_message", "level": level, "message": message}
-        )
-        return MythicRPCResponse(resp)
-
-    async def encrypt_bytes(
-        self, data: bytes, uuid: str, with_uuid: bool = False,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "encrypt_bytes",
-                "data": base64.b64encode(data).decode(),
-                "uuid": uuid,
-                "with_uuid": with_uuid,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def decrypt_bytes(
-        self, data: bytes, uuid: str, with_uuid: bool = False,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "decrypt_bytes",
-                "uuid": uuid,
-                "data": base64.b64encode(data).decode(),
-                "with_uuid": with_uuid,
-            }
-        )
-        return MythicRPCResponse(resp)

C2_Profiles/websocket/mythic/c2_functions/C2_RPC_functions.py

@@ -1,11 +0,0 @@
-from C2ProfileBase import *
-import MythicCallbackRPC
-
-# request is a dictionary: {"action": func_name, "message": "the input",  "task_id": task id num}
-# must return an RPCResponse() object and set .status to an instance of RPCStatus and response to str of message
-async def test(request):
-    response = RPCResponse()
-    response.status = RPCStatus.Success
-    response.response = "hello"
-    #resp = await MythicCallbackRPC.MythicCallbackRPC().add_event_message(message="got a POST message")
-    return response

C2_Profiles/websocket/mythic/c2_functions/websocket.py

@@ -1,70 +0,0 @@
-from C2ProfileBase import *
-
-
-class Websocket(C2Profile):
-    name = "websocket"
-    description = "Websocket C2 Server for poseidon"
-    author = "@xorrior"
-    is_p2p = False
-    is_server_routed = False
-    mythic_encrypts = True
-    parameters = [
-        C2ProfileParameter(
-            name="callback_host",
-            description="Callback Host",
-            default_value="ws://127.0.0.1",
-            verifier_regex="^(ws|wss)://[a-zA-Z0-9]+",
-        ),
-        C2ProfileParameter(
-            name="USER_AGENT",
-            description="User Agent",
-            default_value="Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="AESPSK",
-            description="Base64 of a 32B AES Key",
-            default_value="",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="callback_interval",
-            description="Callback Interval in seconds",
-            default_value="10",
-            verifier_regex="^[0-9]+$",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="encrypted_exchange_check",
-            description="Perform Key Exchange",
-            choices=["T", "F"],
-            parameter_type=ParameterType.ChooseOne,
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="domain_front",
-            description="Host header value for domain fronting",
-            default_value="",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="ENDPOINT_REPLACE",
-            description="Websockets Endpoint",
-            default_value="socket",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="callback_jitter",
-            description="Callback Jitter in percent",
-            default_value="37",
-            verifier_regex="^[0-9]+$",
-            required=False,
-        ),
-        C2ProfileParameter(
-            name="callback_port",
-            description="Callback Port",
-            default_value="8081",
-            verifier_regex="^[0-9]+$",
-            required=False,
-        ),
-    ]

C2_Profiles/websocket/mythic/c2_service.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-cd /Mythic/mythic
-
-export PYTHONPATH=/Mythic:/Mythic/mythic
-
-python3.8 mythic_service.py

C2_Profiles/websocket/mythic/mythic_service.py

@@ -1,410 +0,0 @@
-#!/usr/bin/env python3
-import aio_pika
-import os
-import time
-import sys
-import subprocess
-import _thread
-import base64
-import json
-import socket
-import asyncio
-import pathlib
-import traceback
-from C2ProfileBase import *
-from importlib import import_module, invalidate_caches
-from functools import partial
-
-credentials = None
-connection_params = None
-running = False
-process = None
-thread = None
-hostname = ""
-output = ""
-exchange = None
-container_files_path = None
-
-
-def deal_with_stdout():
-    global process
-    global output
-    while True:
-        try:
-            for line in iter(process.stdout.readline, b""):
-                output += line.decode("utf-8")
-        except Exception as e:
-            print("Exiting thread due to: {}\n".format(str(e)))
-            sys.stdout.flush()
-            break
-
-
-def import_all_c2_functions():
-    import glob
-
-    # Get file paths of all modules.
-    modules = glob.glob("c2_functions/*.py")
-    invalidate_caches()
-    for x in modules:
-        if not x.endswith("__init__.py") and x[-3:] == ".py":
-            module = import_module("c2_functions." + pathlib.Path(x).stem, package=None)
-            for el in dir(module):
-                if "__" not in el:
-                    globals()[el] = getattr(module, el)
-
-
-async def send_status(message="", routing_key=""):
-    global exchange
-    try:
-        message_body = aio_pika.Message(message.encode())
-        await exchange.publish(message_body, routing_key=routing_key)
-    except Exception as e:
-        print("Exception in send_status: {}".format(str(e)))
-        sys.stdout.flush()
-
-
-async def callback(message: aio_pika.IncomingMessage):
-    global running
-    global process
-    global output
-    global thread
-    global hostname
-    global container_files_path
-    with message.process():
-        # messages of the form: c2.modify.PROFILE NAME.command
-        try:
-            command = message.routing_key.split(".")[3]
-            username = message.routing_key.split(".")[4]
-            server_path = container_files_path / "server"
-            # command = body.decode('utf-8')
-            if command == "start":
-                if not running:
-                    # make sure to start the /Apfell/server in the background
-                    os.chmod(server_path, mode=0o777)
-                    output = ""
-                    process = subprocess.Popen(
-                        str(server_path),
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.STDOUT,
-                        cwd=str(container_files_path),
-                    )
-                    thread = _thread.start_new_thread(deal_with_stdout, ())
-                    time.sleep(3)
-                    process.poll()
-                    if process.returncode is not None:
-                        # this means something went wrong and the process is dead
-                        running = False
-                        await send_status(
-                            message="Failed to start\nOutput: {}".format(output),
-                            routing_key="c2.status.{}.stopped.start.{}".format(
-                                hostname, username
-                            ),
-                        )
-                        output = ""
-                    else:
-                        running = True
-                        await send_status(
-                            message="Started with pid: {}...\nOutput: {}".format(
-                                str(process.pid), output
-                            ),
-                            routing_key="c2.status.{}.running.start.{}".format(
-                                hostname, username
-                            ),
-                        )
-                        output = ""
-                else:
-                    await send_status(
-                        message="Already running...\nOutput: {}".format(output),
-                        routing_key="c2.status.{}.running.start.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-            elif command == "stop":
-                if running:
-                    try:
-                        process.kill()
-                        process.communicate()
-                    except Exception as e:
-                        pass
-                    try:
-                        thread.exit()
-                    except Exception as e:
-                        pass
-                    running = False
-                    await send_status(
-                        message="Process killed...\nOld Output: {}".format(output),
-                        routing_key="c2.status.{}.stopped.stop.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-                else:
-                    await send_status(
-                        message="Process not running...\nOld Output: {}".format(output),
-                        routing_key="c2.status.{}.stopped.stop.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-                # make sure to stop the /Apfell/server in the background
-            elif command == "status":
-                if running:
-                    await send_status(
-                        message="Output: {}".format(output),
-                        routing_key="c2.status.{}.running.status.{}".format(
-                            hostname, username
-                        ),
-                    )
-                    output = ""
-                else:
-                    await send_status(
-                        message="C2 is not running",
-                        routing_key="c2.status.{}.stopped.status.{}".format(
-                            hostname, username
-                        ),
-                    )
-            elif command == "get_config":
-                try:
-                    path = container_files_path / "config.json"
-                    file_data = open(path, "rb").read()
-                except Exception as e:
-                    file_data = b"File not found"
-                encoded_data = json.dumps(
-                    {
-                        "filename": "config.json",
-                        "data": base64.b64encode(file_data).decode("utf-8"),
-                    }
-                )
-                await send_status(
-                    message=encoded_data,
-                    routing_key="c2.status.{}.{}.get_config.{}".format(
-                        hostname, "running" if running else "stopped", username
-                    ),
-                )
-            elif command == "writefile":
-                try:
-                    message = json.loads(message.body.decode("utf-8"))
-                    file_path = container_files_path / message["file_path"]
-                    file_path = file_path.resolve()
-                    if container_files_path not in file_path.parents:
-                        response = {
-                            "status": "error",
-                            "error": "trying to break out of path",
-                        }
-                    else:
-                        file = open(file_path, "wb")
-                        file.write(base64.b64decode(message["data"]))
-                        file.close()
-                        response = {"status": "success", "file": message["file_path"]}
-                except Exception as e:
-                    response = {"status": "error", "error": str(e)}
-                await send_status(
-                    message=json.dumps(response),
-                    routing_key="c2.status.{}.{}.writefile.{}".format(
-                        hostname, "running" if running else "stopped", username
-                    ),
-                )
-            elif command == "sync_classes":
-                try:
-                    import_all_c2_functions()
-                    # c2profile = {}
-                    for cls in C2Profile.__subclasses__():
-                        c2profile = cls().to_json()
-                        break
-                    await send_status(
-                        message=json.dumps(c2profile),
-                        routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                            hostname, "running" if running else "stopped", username
-                        ),
-                    )
-                except Exception as e:
-                    await send_status(
-                        message='{"message": "Error while syncing info: {}"}'.format(
-                            str(traceback.format_exc())
-                        ),
-                        routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                            hostname, "running" if running else "stopped", username
-                        ),
-                    )
-            else:
-                print("Unknown command: {}".format(command))
-                sys.stdout.flush()
-        except Exception as e:
-            print("Failed overall message processing: " + str(e))
-            sys.stdout.flush()
-
-
-async def sync_classes():
-    try:
-        import_all_c2_functions()
-        c2profile = {}
-        for cls in C2Profile.__subclasses__():
-            c2profile = cls().to_json()
-            break
-        await send_status(
-            message=json.dumps(c2profile),
-            routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                hostname, "stopped", ""
-            ),
-        )
-    except Exception as e:
-        await send_status(
-            message='{"message": "Error while syncing info: {}"}'.format(
-                str(traceback.format_exc())
-            ),
-            routing_key="c2.status.{}.{}.sync_classes.{}".format(
-                hostname, "stopped", ""
-            ),
-        )
-
-
-async def rabbit_c2_rpc_callback(
-    exchange: aio_pika.Exchange, message: aio_pika.IncomingMessage
-):
-    with message.process():
-        request = json.loads(message.body.decode())
-        if "action" in request:
-            response = await globals()[request["action"]](request)
-            response = json.dumps(response.to_json()).encode()
-        else:
-            response = json.dumps(
-                {"status": "error", "error": "Missing action"}
-            ).encode()
-        try:
-            await exchange.publish(
-                aio_pika.Message(body=response, correlation_id=message.correlation_id),
-                routing_key=message.reply_to,
-            )
-        except Exception as e:
-            print(
-                "Exception trying to send message back to container for rpc! " + str(e)
-            )
-            sys.stdout.flush()
-
-
-async def connect_and_consume_rpc():
-    connection = None
-    global hostname
-    while connection is None:
-        try:
-            connection = await aio_pika.connect_robust(
-                host="127.0.0.1",
-                login="mythic_user",
-                password="mythic_password",
-                virtualhost="mythic_vhost",
-            )
-            channel = await connection.channel()
-            # get a random queue that only the apfell server will use to listen on to catch all heartbeats
-            queue = await channel.declare_queue("{}_rpc_queue".format(hostname))
-            await channel.set_qos(prefetch_count=50)
-            try:
-                task = queue.consume(
-                    partial(rabbit_c2_rpc_callback, channel.default_exchange)
-                )
-                result = await asyncio.wait_for(task, None)
-            except Exception as e:
-                print("Exception in connect_and_consume .consume: {}".format(str(e)))
-                sys.stdout.flush()
-        except (ConnectionError, ConnectionRefusedError) as c:
-            print("Connection to rabbitmq failed, trying again...")
-            sys.stdout.flush()
-        except Exception as e:
-            print("Exception in connect_and_consume_rpc connect: {}".format(str(e)))
-            # print("Exception in connect_and_consume connect: {}".format(str(e)))
-            sys.stdout.flush()
-        await asyncio.sleep(2)
-
-
-async def mythic_service():
-    global hostname
-    global exchange
-    global container_files_path
-    connection = None
-    config_file = open("rabbitmq_config.json", "rb")
-    main_config = json.loads(config_file.read().decode("utf-8"))
-    config_file.close()
-    if main_config["name"] == "hostname":
-        hostname = socket.gethostname()
-    else:
-        hostname = main_config["name"]
-    container_files_path = pathlib.Path(
-        os.path.abspath(main_config["container_files_path"])
-    )
-    container_files_path = container_files_path / "c2_code"
-    while connection is None:
-        try:
-            connection = await aio_pika.connect_robust(
-                host=main_config["host"],
-                login=main_config["username"],
-                password=main_config["password"],
-                virtualhost=main_config["virtual_host"],
-            )
-        except Exception as e:
-            await asyncio.sleep(2)
-    try:
-        channel = await connection.channel()
-        exchange = await channel.declare_exchange(
-            "mythic_traffic", aio_pika.ExchangeType.TOPIC
-        )
-        queue = await channel.declare_queue("", exclusive=True)
-        await queue.bind(
-            exchange="mythic_traffic", routing_key="c2.modify.{}.#".format(hostname)
-        )
-        # just want to handle one message at a time so we can clean up and be ready
-        await channel.set_qos(prefetch_count=30)
-        print("Listening for c2.modify.{}.#".format(hostname))
-        sys.stdout.flush()
-        task = queue.consume(callback)
-        await sync_classes()
-        task4 = asyncio.ensure_future(connect_and_consume_rpc())
-        result = await asyncio.gather(task, task4)
-        # send_status(message="", routing_key="c2.status.{}.stopped.stop".format(hostname))
-    except Exception as e:
-        print(str(traceback.format_exc()))
-        sys.stdout.flush()
-
-
-async def heartbeat_loop():
-    config_file = open("rabbitmq_config.json", "rb")
-    main_config = json.loads(config_file.read().decode("utf-8"))
-    config_file.close()
-    if main_config["name"] == "hostname":
-        hostname = socket.gethostname()
-    else:
-        hostname = main_config["name"]
-    while True:
-        try:
-            connection = await aio_pika.connect_robust(
-                host=main_config["host"],
-                login=main_config["username"],
-                password=main_config["password"],
-                virtualhost=main_config["virtual_host"],
-            )
-            channel = await connection.channel()
-            # declare our heartbeat exchange that everybody will publish to, but only the apfell server will are about
-            exchange = await channel.declare_exchange(
-                "mythic_traffic", aio_pika.ExchangeType.TOPIC
-            )
-        except Exception as e:
-            print(str(e))
-            await asyncio.sleep(2)
-            continue
-        while True:
-            try:
-                # routing key is ignored for fanout, it'll go to anybody that's listening, which will only be the server
-                await exchange.publish(
-                    aio_pika.Message("heartbeat".encode()),
-                    routing_key="c2.heartbeat.{}".format(hostname),
-                )
-                await asyncio.sleep(10)
-            except Exception as e:
-                print(str(e))
-                # if we get an exception here, break out to the bigger loop and try to connect again
-                break
-
-# start our service
-loop = asyncio.get_event_loop()
-loop.create_task(mythic_service())
-loop.create_task(heartbeat_loop())
-loop.run_forever()

C2_Profiles/websocket/mythic/rabbitmq_config.json

@@ -1,8 +0,0 @@
-{
-  "username": "mythic_user",
-  "password": "mythic_password",
-  "virtual_host": "mythic_vhost",
-  "host": "127.0.0.1",
-  "name": "hostname",
-  "container_files_path": "/Mythic/"
-}

Docker_Templates/Docker_C2_Profile_base_files/Dockerfile

@@ -1,9 +0,0 @@
-From python:3.6-jessie
-RUN pip install aio_pika
-
-RUN mkdir /Mythic_service 2>/dev/null
-COPY ["c2_service.sh", "/Mythic_service/c2_service.sh"]
-RUN chmod +x /Mythic_service/c2_service.sh
-WORKDIR /Mythic_service/
-
-ENTRYPOINT ["/Mythic_service/c2_service.sh"]

Docker_Templates/Docker_C2_Profile_base_files/c2_service.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-cd /Mythic/mythic
-
-export PYTHONPATH=/Mythic:/Mythic/mythic
-
-python3.8 mythic_service.py

Docker_Templates/Docker_C2_Profile_base_files/create_base_images.sh

@@ -1,4 +0,0 @@
-echo "Pruning old images..."
-docker image prune -f
-echo "Building golden python3.8 sanic image..."
-docker build -f "python38_sanic_dockerfile" --rm -t "python38_sanic_c2profile" .

Docker_Templates/Docker_C2_Profile_base_files/python38_sanic_dockerfile

@@ -1,6 +0,0 @@
-From python:3.8-buster
-RUN pip install aio_pika sanic requests
-
-ENV PYTHONWARNINGS="ignore:Unverified HTTPS request"
-
-ENTRYPOINT ["/Mythic/mythic/c2_service.sh"]

Docker_Templates/Docker_Mythic_Services_base_files/config_rabbit.sh

@@ -1,35 +0,0 @@
-#!/bin/bash
-
-# This script needs to be executed just once
-if [ -f /$0.completed ] ; then
-  echo "$0 `date` /$0.completed found, skipping run"
-  exit 0
-fi
-
-# Wait for RabbitMQ startup
-for (( ; ; )) ; do
-  sleep 2
-  rabbitmqctl -q node_health_check > /dev/null 2>&1
-  if [ $? -eq 0 ] ; then
-    echo "$0 `date` rabbitmq is now running"
-    break
-  else
-    echo "$0 `date` waiting for rabbitmq startup"
-  fi
-done
-
-# Execute RabbitMQ config commands here
-
-# Create user
-rabbitmqctl add_user mythic_user mythic_password
-rabbitmqctl add_vhost mythic_vhost
-rabbitmqctl set_user_tags mythic_user administrator
-rabbitmqctl set_permissions -p mythic_vhost mythic_user ".*" ".*" ".*"
-echo "$0 `date` user mythic_user created"
-
-# Create queue
-#rabbitmqadmin declare queue name=QUEUE durable=true
-#echo "$0 `date` queues created"
-
-# Create mark so script is not ran again
-touch /$0.completed

Docker_Templates/Docker_Mythic_Services_base_files/create_base_images.sh

@@ -1,12 +0,0 @@
-echo "Pruning old images..."
-docker image prune -f
-echo "Building golden postgres image..."
-docker build -f "mythic_postgres" --rm -t "mythic_postgres" .
-
-docker image prune -f
-echo "Building golden rabbitmq image..."
-docker build -f "mythic_rabbitmq" --rm -t "mythic_rabbitmq" .
-
-docker image prune -f
-echo "Building golden server image..."
-docker build -f "mythic_server" --rm -t "mythic_server" .

Docker_Templates/Docker_Mythic_Services_base_files/init.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-
-# Launch config script in background
-# Note there is no RabbitMQ Docker image support for executing commands after server (PID 1) is running (something like "ADD schema.sql /docker-entrypoint-initdb.d" in MySql image), so we are using this trick
-/config_rabbit.sh &
-
-# Launch
-/docker-entrypoint.sh rabbitmq-server

Docker_Templates/Docker_Mythic_Services_base_files/mythic_postgres

@@ -1,6 +0,0 @@
-From postgres:9.4
-COPY postgres.conf /etc/postgresql/postgresql.conf
-ENV config_file=/etc/postgresql/postgresql.conf
-ENV POSTGRES_USER 'mythic_user'
-ENV POSTGRES_PASSWORD 'super_secret_mythic_user_password'
-ENV POSTGRES_DB 'mythic_db'

Docker_Templates/Docker_Mythic_Services_base_files/mythic_rabbitmq

@@ -1,7 +0,0 @@
-FROM rabbitmq:3.7.6-management
-
-ADD init.sh /
-ADD config_rabbit.sh /
-RUN chmod +x /init.sh /config_rabbit.sh
-
-ENTRYPOINT ["/init.sh"]

Docker_Templates/Docker_Mythic_Services_base_files/mythic_server

@@ -1,5 +0,0 @@
-From python:3.8-buster
-RUN mkdir /Mythic
-WORKDIR /Mythic
-COPY ["requirements.txt", "/Mythic/requirements.txt"]
-RUN pip install -r /Mythic/requirements.txt

Docker_Templates/Docker_Mythic_Services_base_files/requirements.txt

@@ -1,21 +0,0 @@
-sanic
-psycopg2-binary
-peewee-async
-aiopg
-peewee
-jinja2
-uvloop==0.14.0.rc1
-git+https://github.com/mikekeda/sanic-wtf
-pycryptodome
-wtforms
-anytree
-websockets
-sanic-jwt
-fpdf
-aio-pika
-requests
-dijkstar
-exrex
-treelib
-shortuuid
-ujson

Docker_Templates/Docker_Payload_Type_base_files/bootstrap_pure.sh

@@ -1,38 +0,0 @@
-#!/bin/bash
-#
-# Contains the Go tool-chain pure-Go bootstrapper, that as of Go 1.5, initiates
-# not only a few pre-built Go cross compilers, but rather bootstraps all of the
-# supported platforms from the origin Linux amd64 distribution.
-#
-# Usage: bootstrap_pure.sh
-#
-# Environment variables for remote bootstrapping:
-#   FETCH         - Remote file fetcher and checksum verifier (injected by image)
-#   ROOT_DIST     - 64 bit Linux Go binary distribution package
-#   ROOT_DIST_SHA - 64 bit Linux Go distribution package checksum
-#
-# Environment variables for local bootstrapping:
-#   GOROOT - Path to the lready installed Go runtime
-set -e
-
-# Download, verify and install the root distribution if pulled remotely
-if [ "$GOROOT" == "" ]; then
-  $FETCH $ROOT_DIST $ROOT_DIST_SHA
-
-  tar -C /usr/local -xzf `basename $ROOT_DIST`
-  rm -f `basename $ROOT_DIST`
-
-  export GOROOT=/usr/local/go
-fi
-export GOROOT_BOOTSTRAP=$GOROOT
-
-echo "Bootstrapping linux/arm64..."
-GOOS=linux GOARCH=arm64 CGO_ENABLED=1 CC=aarch64-linux-gnu-gcc-5 go install std
-
-echo "Bootstrapping darwin/amd64..."
-GOOS=darwin GOARCH=amd64 CGO_ENABLED=1 CC=o64-clang go install std
-
-# Install xgo within the container to enable internal cross compilation
-echo "Installing xgo-in-xgo..."
-go get -u github.com/karalabe/xgo
-ln -s /go/bin/xgo /usr/bin/xgo

Docker_Templates/Docker_Payload_Type_base_files/build.sh

@@ -1,126 +0,0 @@
-#!/bin/bash
-#
-# Contains the main cross compiler, that individually sets up each target build
-# platform, compiles all the C dependencies, then build the requested executable
-# itself.
-#
-# Usage: build.sh <import path>
-#
-# Needed environment variables:
-#   REPO_REMOTE    - Optional VCS remote if not the primary repository is needed
-#   REPO_BRANCH    - Optional VCS branch to use, if not the master branch
-#   DEPS           - Optional list of C dependency packages to build
-#   ARGS           - Optional arguments to pass to C dependency configure scripts
-#   PACK           - Optional sub-package, if not the import path is being built
-#   OUT            - Optional output prefix to override the package name
-#   FLAG_V         - Optional verbosity flag to set on the Go builder
-#   FLAG_X         - Optional flag to print the build progress commands
-#   FLAG_RACE      - Optional race flag to set on the Go builder
-#   FLAG_TAGS      - Optional tag flag to set on the Go builder
-#   FLAG_LDFLAGS   - Optional ldflags flag to set on the Go builder
-#   FLAG_BUILDMODE - Optional buildmode flag to set on the Go builder
-#   TARGETS        - Comma separated list of build targets to compile for
-#   GO_VERSION     - Bootstrapped version of Go to disable uncupported targets
-#   EXT_GOPATH     - GOPATH elements mounted from the host filesystem
-
-# Define a function that figures out the binary extension
-function extension {
-  if [ "$FLAG_BUILDMODE" == "archive" ] || [ "$FLAG_BUILDMODE" == "c-archive" ]; then
-    if [ "$1" == "windows" ]; then
-      echo ".lib"
-    else
-      echo ".a"
-    fi
-  elif [ "$FLAG_BUILDMODE" == "shared" ] || [ "$FLAG_BUILDMODE" == "c-shared" ]; then
-    if [ "$1" == "windows" ]; then
-      echo ".dll"
-    elif [ "$1" == "darwin" ] || [ "$1" == "ios" ]; then
-      echo ".dylib"
-    else
-      echo ".so"
-    fi
-  else
-    if [ "$1" == "windows" ]; then
-      echo ".exe"
-    fi
-  fi
-}
-
-# Configure some global build parameters
-NAME=`basename $1/$PACK`
-if [ "$OUT" != "" ]; then
-  NAME=$OUT
-fi
-
-if [ "$FLAG_V" == "true" ];    then V=-v; fi
-if [ "$FLAG_X" == "true" ];    then X=-x; fi
-if [ "$FLAG_RACE" == "true" ]; then R=-race; fi
-if [ "$FLAG_TAGS" != "" ];     then T=(--tags "$FLAG_TAGS"); fi
-if [ "$FLAG_LDFLAGS" != "" ];  then LD="$FLAG_LDFLAGS"; fi
-
-if [ "$FLAG_BUILDMODE" != "" ] && [ "$FLAG_BUILDMODE" != "default" ]; then BM="--buildmode=$FLAG_BUILDMODE"; fi
-
-# If no build targets were specified, inject a catch all wildcard
-if [ "$TARGETS" == "" ]; then
-  TARGETS="./."
-fi
-
-# Build for each requested platform individually
-for TARGET in $TARGETS; do
-  # Split the target into platform and architecture
-  XGOOS=`echo $TARGET | cut -d '/' -f 1`
-  XGOARCH=`echo $TARGET | cut -d '/' -f 2`
-
-  # Check and build for Linux targets
-  if ([ $XGOOS == "." ] || [ $XGOOS == "linux" ]) && ([ $XGOARCH == "." ] || [ $XGOARCH == "amd64" ]); then
-    echo "Compiling for linux/amd64..."
-    #HOST=x86_64-linux PREFIX=/usr/local $BUILD_DEPS /deps ${DEPS_ARGS[@]}
-    #GOOS=linux GOARCH=amd64 CGO_ENABLED=1 go get $V $X "${T[@]}" --ldflags="$V $LD" -d ./$PACK
-    GOOS=linux GOARCH=amd64 CGO_ENABLED=1 go build $V $X "${T[@]}" --ldflags="$V $LD" $R $BM -o "/build/$NAME-linux-amd64$R`extension linux`" ./$PACK
-
-  fi
-
-  # Check and build for OSX targets
-  if [ $XGOOS == "." ] || [[ $XGOOS == darwin* ]]; then
-    # Split the platform version and configure the deployment target
-    PLATFORM=`echo $XGOOS | cut -d '-' -f 2`
-    if [ "$PLATFORM" == "" ] || [ "$PLATFORM" == "." ] || [ "$PLATFORM" == "darwin" ]; then
-      PLATFORM=10.06 # OS X Snow Leopard
-    fi
-    export MACOSX_DEPLOYMENT_TARGET=$PLATFORM
-
-    # Strip symbol table below Go 1.6 to prevent DWARF issues
-    LDSTRIP=""
-    if [ "$GO_VERSION" -lt 160 ]; then
-      LDSTRIP="-s"
-    fi
-    # Build the requested darwin binaries
-    if [ $XGOARCH == "." ] || [ $XGOARCH == "amd64" ]; then
-      echo "Compiling for darwin-$PLATFORM/amd64..."
-      #CC=o64-clang CXX=o64-clang++ HOST=x86_64-apple-darwin15 PREFIX=/usr/local $BUILD_DEPS /deps ${DEPS_ARGS[@]}
-      #CC=o64-clang CXX=o64-clang++ GOOS=darwin GOARCH=amd64 CGO_ENABLED=1 go get $V $X "${T[@]}" --ldflags="$LDSTRIP $V $LD" -d ./$PACK
-      CC=o64-clang CXX=o64-clang++ GOOS=darwin GOARCH=amd64 CGO_ENABLED=1 go build $V $X "${T[@]}" --ldflags="$LDSTRIP $V $LD" $R $BM -o "/build/$NAME-darwin-$PLATFORM-amd64$R`extension darwin`" ./$PACK
-    fi
-    # Remove any automatically injected deployment target vars
-    unset MACOSX_DEPLOYMENT_TARGET
-  fi
-done
-
-# Clean up any leftovers for subsequent build invocations
-#echo "Cleaning up build environment..."
-#rm -rf /deps
-
-#for dir in `ls /usr/local`; do
-#  keep=0
-
-  # Check against original folder contents
-#  for old in $USR_LOCAL_CONTENTS; do
-#    if [ "$old" == "$dir" ]; then
-#      keep=1
-#    fi
-#  done
-  # Delete anything freshly generated
-#  if [ "$keep" == "0" ]; then
-#    rm -rf "/usr/local/$dir"
-#  fi
-#done

Docker_Templates/Docker_Payload_Type_base_files/create_base_images.sh

@@ -1,16 +0,0 @@
-echo "Pruning old images..."
-docker image prune -f
-echo "Building golden csharp image..."
-docker build -f "csharp_dockerfile" --rm -t "csharp_payload" .
-
-docker image prune -f
-echo "Building golden python3.8 image..."
-docker build -f "python38_dockerfile" --rm -t "python38_payload" .
-
-docker image prune -f
-echo "Building golden xgo image..."
-docker build -f "xgolang_dockerfile" --rm -t "xgolang_payload" .
-
-docker image prune -f
-echo "Building golden leviathan image..."
-docker build -f "leviathan_dockerfile" --rm -t "leviathan_payload" .

Docker_Templates/Docker_Payload_Type_base_files/csharp_dockerfile

@@ -1,19 +0,0 @@
-from mono:latest
-RUN apt-get update
-RUN apt-get install software-properties-common apt-utils make build-essential libssl-dev zlib1g-dev libbz2-dev \
-libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev libncursesw5-dev \
-xz-utils tk-dev libffi-dev liblzma-dev -y
-RUN apt-get update
-RUN wget https://www.python.org/ftp/python/3.8.6/Python-3.8.6.tgz
-RUN tar xvf Python-3.8.6.tgz
-RUN Python-3.8.6/configure --with-ensurepip=install
-RUN make -j8
-RUN make altinstall
-RUN python3.8 -m pip install aio_pika
-
-RUN mkdir -p "/Windows/assembly/GAC_MSIL/System.Management.Automation/1.0.0.0__31bf3856ad364e35"
-COPY ["System.Management.Automation.dll", "/Windows/assembly/GAC_MSIL/System.Management.Automation/1.0.0.0__31bf3856ad364e35/System.Management.Automation.dll"]
-RUN mkdir -p "/Windows/Microsoft.NET/assembly/GAC_MSIL/System.Management.Automation/v4.0_3.0.0.0__31bf3856ad364e35"
-COPY ["System.Management.Automation.dll-v4", "/Windows/Microsoft.NET/assembly/GAC_MSIL/System.Management.Automation/v4.0_3.0.0.0__31bf3856ad364e35/System.Management.Automation.dll"]
-
-ENTRYPOINT ["/Mythic/mythic/payload_service.sh"]

Docker_Templates/Docker_Payload_Type_base_files/fetch.sh

@@ -1,27 +0,0 @@
-#!/bin/bash
-#
-# Contains a simple fetcher to download a file from a remote URL and verify its
-# SHA1 or SHA256 checksum (selected based on provided length).
-#
-# Usage: fetch.sh <remote URL> <SHA1/SHA256 checksum>
-set -e
-
-# Skip the download if no operands specified
-if [ "$1" == "" -o "$2" == "" ]; then
-  echo "Fetch operands missing, skipping..."
-  exit
-fi
-
-# Pull the file from the remote URL
-file=`basename $1`
-echo "Downloading $1..."
-wget -q $1
-
-# Generate a desired checksum report and check against it
-echo "$2  $file" > $file.sum
-if [ "${#2}" == "40" ]; then
-  sha1sum -c $file.sum
-else
-  sha256sum -c $file.sum
-fi
-rm $file.sum

Docker_Templates/Docker_Payload_Type_base_files/leviathan_dockerfile

@@ -1,10 +0,0 @@
-From python:3.8-buster
-RUN pip install aio_pika
-
-RUN apt-get update
-RUN apt-get install software-properties-common apt-utils -y
-RUN apt-get -y install git
-RUN git clone https://github.com/xorrior/CRX3-Creator.git /CRX3-Creator
-RUN cd /CRX3-Creator; pip install -r requirements.txt;
-
-ENTRYPOINT ["/Mythic/mythic/payload_service.sh"]

Docker_Templates/Docker_Payload_Type_base_files/payload_service.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-cd /Mythic/mythic
-
-export PYTHONPATH=/Mythic:/Mythic/mythic
-
-python3.8 mythic_service.py

Docker_Templates/Docker_Payload_Type_base_files/python38_dockerfile

@@ -1,4 +0,0 @@
-From python:3.8-buster
-RUN pip install aio_pika
-
-ENTRYPOINT ["/Mythic/mythic/payload_service.sh"]

Docker_Templates/Docker_Payload_Type_base_files/xgolang_dockerfile

@@ -1,98 +0,0 @@
-# Go cross compiler (xgo): Base cross-compilation layer
-# Copyright (c) 2014 Péter Szilágyi. All rights reserved.
-#
-# Released under the MIT license.
-# pulled and modified from https://github.com/karalabe/xgo/blob/master/docker/go-1.13.4/Dockerfile
-
-FROM ubuntu:18.04
-# Mark the image as xgo enabled to support xgo-in-xgo
-ENV XGO_IN_XGO 1
-
-# Configure the Go environment, since it's not going to change
-ENV PATH   /usr/local/go/bin:$PATH
-ENV GOPATH /go
-
-
-# Inject the remote file fetcher and checksum verifier
-ADD fetch.sh /fetch.sh
-ENV FETCH /fetch.sh
-RUN chmod +x $FETCH
-
-
-# Make sure apt-get is up to date and dependent packages are installed
-RUN \
-  apt-get update && \
-  apt-get install -y automake autogen build-essential ca-certificates cmake                   \
-    gcc-5-aarch64-linux-gnu g++-5-aarch64-linux-gnu libc6-dev-arm64-cross                \
-    gcc-5-multilib g++-5-multilib clang llvm-dev             \
-    libtool libxml2-dev uuid-dev libssl-dev swig openjdk-8-jdk pkg-config patch          \
-    make xz-utils cpio wget zip unzip p7zip git mercurial bzr texinfo help2man           \
-    --no-install-recommends
-
-RUN \
-    apt-get install -y python3 python3-pip
-
-RUN pip3 install aio_pika
-
-# Fix any stock package issues
-RUN ln -s /usr/include/asm-generic /usr/include/asm
-
-##########################
-# Darwin Toolchain build #
-##########################
-
-# Configure the container for OSX cross compilation
-ENV OSX_SDK MacOSX10.11.sdk
-ENV OSX_SDK_PATH https://s3.dockerproject.org/darwin/v2/$OSX_SDK.tar.xz
-
-# Make libxar known to the ld64 and cctools build
-ENV LD_LIBRARY_PATH=/osxcross/target/lib
-
-# Download the osx sdk and build the osx toolchain
-# We download the osx sdk, patch it and pack it again to be able to throw the patched version at osxcross
-RUN \
-  $FETCH $OSX_SDK_PATH dd228a335194e3392f1904ce49aff1b1da26ca62 && \
-  tar -xf `basename $OSX_SDK_PATH` && rm -f `basename $OSX_SDK_PATH`
-ADD patch.tar.xz $OSX_SDK/usr/include/c++
-RUN tar -cf - $OSX_SDK/ | xz -c - > $OSX_SDK.tar.xz && rm -rf $OSX_SDK
-
-# Actually build the toolchain
-RUN \
-  git clone https://github.com/tpoechtrager/osxcross.git && \
-  cd osxcross && git checkout 88cb6e8d0d7675cae7c8a2d66c11f58237101df0 && cd ../ && \
-  mv  $OSX_SDK.tar.xz /osxcross/tarballs/ && \
-  OSX_VERSION_MIN=10.10 UNATTENDED=1 LD_LIBRARY_PATH=/osxcross/target/lib /osxcross/build.sh
-ENV PATH /osxcross/target/bin:$PATH
-
-# Inject the new Go root distribution downloader and bootstrapper
-ADD bootstrap_pure.sh /bootstrap_pure.sh
-ENV BOOTSTRAP_PURE /bootstrap_pure.sh
-RUN chmod +x $BOOTSTRAP_PURE
-
-# Inject the container entry point, the build script
-ADD build.sh /build.sh
-ENV BUILD /build.sh
-RUN chmod +x $BUILD
-
-ENV GO_VERSION 11304
-# Make libxar known to the ld64 and cctools build
-ENV LD_LIBRARY_PATH=/osxcross/target/lib
-
-RUN \
-  export ROOT_DIST=https://storage.googleapis.com/golang/go1.13.4.linux-amd64.tar.gz    && \
-  export ROOT_DIST_SHA=692d17071736f74be04a72a06dab9cac1cd759377bd85316e52b2227604c004c && \
-  \
-  $BOOTSTRAP_PURE
-
-ENV GOROOT /usr/local/go
-ENV GOPATH /go/src:/go/src/poseidon
-
-RUN go get github.com/google/shlex \
-    github.com/kbinani/screenshot \
-    github.com/tmc/scp \
-    github.com/xorrior/keyctl \
-    golang.org/x/crypto/ssh \
-    golang.org/x/sync/semaphore \
-    github.com/gorilla/websocket
-
-ENTRYPOINT ["/Mythic/mythic/payload_service.sh"]

Example_C2_Profile/Dockerfile

@@ -1 +0,0 @@
-From itsafeaturemythic/python38_sanic_c2profile:0.0.1

Example_C2_Profile/c2_code/config.json

@@ -1,17 +0,0 @@
-{
-  "instances": [
-  {
-    "ServerHeaders": {
-      "Server": "NetDNA-cache/2.2",
-      "Cache-Control": "max-age=0, no-cache",
-      "Pragma": "no-cache",
-      "Connection": "keep-alive",
-      "Content-Type": "application/javascript; charset=utf-8"
-    },
-    "port": 80,
-    "key_path": "",
-    "cert_path": "",
-    "debug": true
-    }
-  ]
-}

Example_C2_Profile/c2_code/fake.html

@@ -1,10 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <title>Page Not Found!</title>
-</head>
-<body>
-
-</body>
-</html>

Example_C2_Profile/c2_code/server

@@ -1,115 +0,0 @@
-#!/usr/bin/env python3
-
-from sanic import Sanic
-from sanic.response import html, redirect, text, raw
-from sanic.exceptions import NotFound
-import sys
-import asyncio
-import ssl
-from pathlib import Path
-import requests
-import json
-import os
-
-config = {}
-
-async def print_flush(message):
-    print(message)
-    sys.stdout.flush()
-
-
-async def server_error_handler(request, exception):
-    return html("Error: Requested URL {} not found".format(request.url), status=404, headers=config[request.app.name]['headers'])
-
-
-async def agent_message(request, **kwargs):
-    global config
-    try:
-        if config[request.app.name]['debug']:
-            await print_flush("agent_message request from: {} with {} and {}".format(request.url, request.cookies, request.headers))
-            await print_flush(" and URI: {}".format(request.query_string))
-        if config[request.app.name]['debug']:
-            await print_flush("Forwarding along to: {}".format(config['mythic_address']))
-        if request.method == "POST":
-            # manipulate the request if needed
-            #await MythicCallbackRPC().add_event_message(message="got a POST message")
-            response = requests.post(config['mythic_address'], data=request.body, verify=False, cookies=request.cookies, headers=request.headers)
-        else:
-            # manipulate the request if needed
-            #await MythicCallbackRPC().add_event_message(message="got a GET message")
-            response = requests.get(config['mythic_address'] + "?{}".format(request.query_string), verify=False, data=request.body, cookies=request.cookies, headers=request.headers)
-        return raw(response.content, headers=config[request.app.name]['headers'], status=response.status_code)
-    except Exception as e:
-        if config[request.app.name]['debug']:
-            await print_flush("error in agent_message: {}".format(str(e)))
-        return await no_match(request, NotFound)
-
-
-if __name__ == "__main__":
-    sys.path.append("/Mythic/mythic")
-    from C2ProfileBase import *
-    from MythicCallbackRPC import *
-    config_file = open("config.json", 'rb')
-    main_config = json.loads(config_file.read().decode('utf-8'))
-    print("Opening config and starting instances...")
-    sys.stdout.flush()
-    # basic mapping of the general endpoints to the real endpoints
-    try:
-        config['mythic_address'] = os.environ['MYTHIC_ADDRESS']
-    except Exception as e:
-        print("failed to find MYTHIC_ADDRESS environment variable")
-        sys.stdout.flush()
-        sys.exit(1)
-    # now look at the specific instances to start
-    for inst in main_config['instances']:
-        config[str(inst['port'])] = {'debug': inst['debug'],
-                                     'headers': inst['ServerHeaders']}
-        if inst['debug']:
-            print("Debugging statements are enabled. This gives more context, but might be a performance hit")
-        else:
-            print("Debugging statements are disabled")
-        sys.stdout.flush()
-        # now to create an app instance to handle responses
-        app = Sanic(str(inst['port']))
-        app.config['REQUEST_MAX_SIZE'] = 1000000000
-        app.config['REQUEST_TIMEOUT'] = 600
-        app.config['RESPONSE_TIMEOUT'] = 600
-        app.add_route(agent_message, "/<uri:path>", methods=['GET','POST'])
-        app.add_route(agent_message, "/", methods=['GET','POST'])
-        app.error_handler.add(Exception, server_error_handler)
-        keyfile = Path(inst['key_path'])
-        certfile = Path(inst['cert_path'])
-        if keyfile.is_file() and certfile.is_file():
-            context = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)
-            context.load_cert_chain(inst['cert_path'], keyfile=inst['key_path'])
-            if inst['debug']:
-                server = app.create_server(host="0.0.0.0", port=inst['port'], ssl=context, debug=False, return_asyncio_server=True, access_log=True)
-            else:
-                server = app.create_server(host="0.0.0.0", port=inst['port'], ssl=context, debug=False, return_asyncio_server=True, access_log=False)
-            if inst['debug']:
-                print("using SSL for port {}".format(inst['port']))
-                sys.stdout.flush()
-        else:
-            if inst['debug']:
-                print("not using SSL for port {}".format(inst['port']))
-                sys.stdout.flush()
-            if inst['debug']:
-                server = app.create_server(host="0.0.0.0", port=inst['port'], debug=False, return_asyncio_server=True, access_log=True)
-            else:
-                server = app.create_server(host="0.0.0.0", port=inst['port'], debug=False, return_asyncio_server=True, access_log=False)
-        task = asyncio.ensure_future(server)
-
-    try:
-        loop = asyncio.get_event_loop()
-        def callback(fut):
-            try:
-                fetch_count = fut.result()
-            except:
-                print("port already in use")
-                sys.stdout.flush()
-                sys.exit()
-        task.add_done_callback(callback)
-        loop.run_forever()
-    except:
-        sys.exit()
-        loop.stop()

Example_C2_Profile/mythic/C2ProfileBase.py

@@ -1,130 +0,0 @@
-from enum import Enum
-from abc import abstractmethod
-import json
-
-
-class ParameterType(Enum):
-    String = "String"
-    ChooseOne = "ChooseOne"
-    Array = "Array"
-    Date = "Date"
-    Dictionary = "Dictionary"
-
-
-class C2ProfileParameter:
-    def __init__(
-        self,
-        name: str,
-        description: str,
-        default_value: str = "",
-        randomize: bool = False,
-        format_string: str = "",
-        parameter_type: ParameterType = ParameterType.String,
-        required: bool = True,
-        verifier_regex: str = "",
-        choices: [str] = None,
-    ):
-        self.name = name
-        self.description = description
-        self.randomize = randomize
-        self.format_string = format_string
-        self.parameter_type = parameter_type
-        self.required = required
-        self.verifier_regex = verifier_regex
-        self.choices = choices
-        self.default_value = ""
-        if self.parameter_type == ParameterType.ChooseOne and choices is not None:
-            self.default_value = "\n".join(choices)
-        else:
-            self.default_value = default_value
-
-
-    def to_json(self):
-        return {
-            "name": self.name,
-            "description": self.description,
-            "default_value": self.default_value if self.parameter_type not in [ParameterType.Array, ParameterType.Dictionary] else json.dumps(self.default_value),
-            "randomize": self.randomize,
-            "format_string": self.format_string,
-            "required": self.required,
-            "parameter_type": self.parameter_type.value,
-            "verifier_regex": self.verifier_regex,
-        }
-
-
-class C2Profile:
-    @property
-    @abstractmethod
-    def name(self):
-        pass
-
-    @property
-    @abstractmethod
-    def description(self):
-        pass
-
-    @property
-    @abstractmethod
-    def author(self):
-        pass
-
-    @property
-    @abstractmethod
-    def is_p2p(self):
-        pass
-
-    @property
-    @abstractmethod
-    def is_server_routed(self):
-        pass
-
-    @property
-    @abstractmethod
-    def mythic_encrypts(self):
-        pass
-
-    @property
-    @abstractmethod
-    def parameters(self):
-        pass
-
-    def to_json(self):
-        return {
-            "name": self.name,
-            "description": self.description,
-            "author": self.author,
-            "mythic_encrypts": self.mythic_encrypts,
-            "is_p2p": self.is_p2p,
-            "is_server_routed": self.is_server_routed,
-            "params": [x.to_json() for x in self.parameters],
-        }
-
-
-class RPCStatus(Enum):
-    Success = "success"
-    Error = "error"
-
-
-class RPCResponse:
-    def __init__(self, status: RPCStatus = None, response: str = None):
-        self.status = status
-        self.response = response
-
-    @property
-    def status(self):
-        return self._status
-
-    @status.setter
-    def status(self, status):
-        self._status = status
-
-    @property
-    def response(self):
-        return self._response
-
-    @response.setter
-    def response(self, response):
-        self._response = response
-
-    def to_json(self):
-        return {"status": self.status.value, "response": self.response}

Example_C2_Profile/mythic/MythicBaseRPC.py

@@ -1,99 +0,0 @@
-from aio_pika import connect_robust, IncomingMessage, Message
-import asyncio
-import uuid
-import json
-from enum import Enum
-
-
-class MythicStatus(Enum):
-    Success = "success"
-    Error = "error"
-
-
-class RPCResponse:
-    def __init__(self, resp: dict):
-        self._raw_resp = resp
-        if resp["status"] == "success":
-            self.status = MythicStatus.Success
-            self.response = resp["response"] if "response" in resp else ""
-            self.error_message = None
-        else:
-            self.status = MythicStatus.Error
-            self.error_message = resp["error"]
-            self.response = None
-
-    @property
-    def status(self):
-        return self._status
-
-    @status.setter
-    def status(self, status):
-        self._status = status
-
-    @property
-    def error_message(self):
-        return self._error_message
-
-    @error_message.setter
-    def error_message(self, error_message):
-        self._error_message = error_message
-
-    @property
-    def response(self):
-        return self._response
-
-    @response.setter
-    def response(self, response):
-        self._response = response
-
-
-class MythicBaseRPC:
-    def __init__(self):
-        self.connection = None
-        self.channel = None
-        self.callback_queue = None
-        self.futures = {}
-        self.loop = asyncio.get_event_loop()
-
-    async def connect(self):
-        config_file = open("/Mythic/mythic/rabbitmq_config.json", "rb")
-        main_config = json.loads(config_file.read().decode("utf-8"))
-        config_file.close()
-        self.connection = await connect_robust(
-            host=main_config["host"],
-            login=main_config["username"],
-            password=main_config["password"],
-            virtualhost=main_config["virtual_host"],
-        )
-        self.channel = await self.connection.channel()
-        self.callback_queue = await self.channel.declare_queue(exclusive=True)
-        await self.callback_queue.consume(self.on_response)
-
-        return self
-
-    def on_response(self, message: IncomingMessage):
-        future = self.futures.pop(message.correlation_id)
-        future.set_result(message.body)
-
-    async def call(self, n, receiver: str = None) -> RPCResponse:
-        if self.connection is None:
-            await self.connect()
-        correlation_id = str(uuid.uuid4())
-        future = self.loop.create_future()
-
-        self.futures[correlation_id] = future
-        if receiver is None:
-            router = "c2rpc_queue"
-        else:
-            router = "{}_rpc_queue".format(receiver)
-        await self.channel.default_exchange.publish(
-            Message(
-                json.dumps(n).encode(),
-                content_type="application/json",
-                correlation_id=correlation_id,
-                reply_to=self.callback_queue.name,
-            ),
-            routing_key=router,
-        )
-
-        return RPCResponse(json.loads(await future))

Example_C2_Profile/mythic/MythicCallbackRPC.py

@@ -1,124 +0,0 @@
-from MythicBaseRPC import *
-import base64
-
-
-class MythicRPCResponse(RPCResponse):
-    def __init__(self, resp: RPCResponse):
-        super().__init__(resp._raw_resp)
-        if resp.status == MythicStatus.Success:
-            self.data = resp.response
-        else:
-            self.data = None
-
-    @property
-    def data(self):
-        return self._data
-
-    @data.setter
-    def data(self, data):
-        self._data = data
-
-
-class MythicCallbackRPC(MythicBaseRPC):
-    # returns dictionary of `{"raw": raw_tasking, "encrypted": base64(uuid+encrypted_tasking)}`
-    async def get_tasking(
-        self, uuid: str, tasking_size: int = 1
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "get_tasking",
-                "uuid": uuid,
-                "tasking_size": tasking_size,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def add_route(
-        self,
-        source_uuid: str,
-        destination_uuid: str,
-        direction: int = 1,
-        metadata: str = None,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "add_route",
-                "source": source_uuid,
-                "destination": destination_uuid,
-                "direction": direction,
-                "metadata": metadata,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def remove_route(
-        self,
-        source_uuid: str,
-        destination_uuid: str,
-        direction: int = 1,
-        metadata: str = None,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "remove_route",
-                "source": source_uuid,
-                "destination": destination_uuid,
-                "direction": direction,
-                "metadata": metadata,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def get_callback_info(self, uuid: str) -> MythicRPCResponse:
-        resp = await self.call({"action": "get_callback_info", "uuid": uuid})
-        return MythicRPCResponse(resp)
-
-    async def get_encryption_data(self, uuid: str, profile: str) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "get_encryption_data",
-                "uuid": uuid,
-                "c2_profile": profile,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def update_callback_info(self, uuid: str, info: dict) -> MythicRPCResponse:
-        resp = await self.call(
-            {"action": "update_callback_info", "uuid": uuid, "data": info}
-        )
-        return MythicRPCResponse(resp)
-
-    async def add_event_message(
-        self, message: str, level: str = "info"
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {"action": "add_event_message", "level": level, "message": message}
-        )
-        return MythicRPCResponse(resp)
-
-    async def encrypt_bytes(
-        self, data: bytes, uuid: str, with_uuid: bool = False,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "encrypt_bytes",
-                "data": base64.b64encode(data).decode(),
-                "uuid": uuid,
-                "with_uuid": with_uuid,
-            }
-        )
-        return MythicRPCResponse(resp)
-
-    async def decrypt_bytes(
-        self, data: bytes, uuid: str, with_uuid: bool = False,
-    ) -> MythicRPCResponse:
-        resp = await self.call(
-            {
-                "action": "decrypt_bytes",
-                "uuid": uuid,
-                "data": base64.b64encode(data).decode(),
-                "with_uuid": with_uuid,
-            }
-        )
-        return MythicRPCResponse(resp)