# How sandbox-profile.md Maps Tools Across Different Runtime Environments in reverse-skill

> Discover how sandbox-profile.md maps tools to runtime environments like Android Linux and Windows for reverse engineering. Understand tool execution across diverse systems.

- Repository: [ZhaoXu/reverse-skill](https://github.com/zhaoxuya520/reverse-skill)
- Tags: how-to-guide
- Published: 2026-08-28

---

**The [`sandbox-profile.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/sandbox-profile.md) file acts as a canonical lookup table that bridges the capabilities defined in [`bootstrap-manifest.json`](https://github.com/zhaoxuya520/reverse-skill/blob/main/bootstrap-manifest.json) with the specific runtime environments—Android devices, Linux hosts, Windows systems, and Docker containers—where those reverse engineering tools execute.**

The [`sandbox-profile.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/sandbox-profile.md) in the `zhaoxuya520/reverse-skill` repository serves as a runtime-centric façade over the generic capability list. It translates high-level tool requirements into concrete environment specifications, ensuring that each capability lands in the correct execution context whether you are analyzing Android binaries, web applications, or native code.

## Understanding the Runtime Mapping Architecture

The mapping system operates through a bidirectional relationship between two critical files. The [`skills/scripts/bootstrap-manifest.json`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/scripts/bootstrap-manifest.json) defines the technical metadata—`name`, `bootstrapKind`, `canAutoInstall`, and `verifyCommand`—while [`skills/ops/sandbox-profile.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/ops/sandbox-profile.md) organizes these entries by operational context.

### The Bootstrap Manifest Connection

In [`skills/scripts/bootstrap-manifest.json`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/scripts/bootstrap-manifest.json), each tool entry contains the fields necessary for automated installation. For example, `frida` is defined as a **pip-package** with `canAutoInstall: true` and a `verifyCommand` of `frida`. The sandbox profile does not duplicate this metadata; instead, it references these capabilities through the **"能力 | 典型场景"** (Capability | Typical Scenario) table, grouping tools by their target runtime.

### Canonical Lookup Table Structure

The primary mapping occurs in the table spanning **lines 9-19** of [`sandbox-profile.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/sandbox-profile.md). This section pairs each auto-installable tool with its target environment:

- **Android Runtime**: `jadx`, `apktool`, `adb`, `frida`, `frida-ps`
- **Binary CLI Runtime**: `r2` (radare2), binary analysis utilities
- **IDA MCP Runtime**: IDA Pro-related tooling
- **Web/JS Runtime**: Browser-based and JavaScript analysis tools
- **Ghidra Runtime**: Native Ghidra script execution environment
- **Pentest Runtime**: Network security assessment tools

## Runtime Environment Categories

The sandbox profile organizes tools into distinct runtime silos based on their execution requirements and target platforms.

### Android Runtime Environment

Tools listed under the Android row require either a physical device connection via ADB or an emulator instance. The profile places `frida` alongside `jadx` and `apktool`, signaling that these tools operate within the **Android runtime** context. When `bootstrap-reverse.ps1` processes the manifest, it consults this mapping to determine whether to verify Android SDK availability before attempting installation.

### Binary CLI and IDA MCP Environments

For native binary analysis, the profile distinguishes between standalone command-line tools and IDA Pro plugin environments. The **Binary CLI** category encompasses `r2` and similar utilities that run directly on the host operating system, while the **IDA MCP** category identifies tools requiring IDA Pro's specific plugin architecture and runtime hooks.

### Web/JS and Ghidra Runtimes

The profile dedicates separate rows to browser-based analysis tools (**Web/JS**) and Ghidra script execution environments. This separation ensures that JavaScript-heavy analysis workflows do not conflict with Java-based Ghidra operations, each requiring distinct runtime dependencies and JVM configurations.

## Handling Non-Auto-Installed Tools

Between **lines 25-36**, the **"Z3r0 sandbox tools not auto-installed"** section documents utilities that the upstream Z3r0 image provides but `reverse-skill` does not provision automatically. Each entry includes a **"reverse-skill 策略"** (reverse-skill strategy) column describing the provisioning method:

- **Manual install**: Tools like `subfinder` that require explicit user intervention
- **Kali script**: Utilities available through Kali Linux package repositories
- **External MCP**: Tools requiring Managed Code Provider integration outside the bootstrap process

This distinction tells a sandbox whether the runtime already contains the binary or if additional provisioning steps are required before execution.

## Docker Profile Mappings

The sandbox profile provides three lightweight Docker configurations between **lines 37-45**, translating high-level use cases into specific container requirements.

### Minimal, Mobile, and Reverse Engineering Profiles

The table defines three concise profiles:

1. **最小 (Minimal)**: Core utilities for basic operations
2. **移动 (Mobile)**: Android-specific tooling including `jadx`, `apktool`, and `frida`
3. **逆向 (Reverse Engineering)**: Comprehensive binary analysis suites

These profiles imply the underlying Docker image must include the relevant runtime libraries. For example, selecting the **移动** profile requires a container with Android SDK binaries and USB debugging capabilities.

## Network Policy Integration

Between **lines 49-55**, the **"network_profile 联动"** (network_profile linkage) section enforces that container-based scanning respects the case scope's `network_profile`. This ties the runtime's **network access level**—`offline` versus `authorized_target_only`—to the allowed toolset.

Certain tools listed in the capability table trigger network restrictions automatically. The profile maps sandbox-profile modes to network policies, ensuring that `nmap` or `nuclei` operations execute only within authorized network boundaries.

## Practical Implementation Examples

Querying the mapping system and translating profiles into actionable commands requires interaction with both the manifest and the profile documentation.

### Querying Tool Runtime Assignments

To determine which runtime environment a specific tool requires, extract the mapping directly from the manifest and cross-reference the profile:

```powershell

# PowerShell: Extract runtime category for frida from the bootstrap manifest

$manifest = Get-Content "$env:SKILL_ROOT\skills\scripts/bootstrap-manifest.json" | ConvertFrom-Json
$tool = $manifest.capabilities | Where-Object { $_.name -eq 'frida' }
Write-Host "Tool: $($tool.name) – Runtime: Android (implied by sandbox-profile table)"

```

### Building Docker Commands from Profiles

The lightweight profiles translate directly into container orchestration commands:

```bash

# Bash: Assemble a Docker run command for the "移动" (Mobile) profile

TOOLS="jadx apktool frida"
docker run -it --rm \
  -v "$HOME/Tools:/opt/tools" \
  ghcr.io/zhaoxuya520/reverse-skill:mobile \
  /bin/bash -c "install-tools $TOOLS && start-reverse-session"

```

This command references the **移动** profile, automatically including the Android runtime dependencies specified in [`skills/ops/sandbox-profile.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/ops/sandbox-profile.md).

## Summary

- **sandbox-profile.md** serves as the authoritative mapping between [`bootstrap-manifest.json`](https://github.com/zhaoxuya520/reverse-skill/blob/main/bootstrap-manifest.json) capabilities and their target runtime environments.
- The **"能力 | 典型场景"** table (lines 9-19) categorizes tools into Android, Binary CLI, IDA MCP, Web/JS, Ghidra, and Pentest runtimes.
- **Z3r0 sandbox tools** (lines 25-36) document manually-provisioned utilities with specific installation strategies.
- **Docker profiles** (lines 37-45) provide minimal image specifications for 最小, 移动, and 逆向 use cases.
- **Network profile linkage** (lines 49-55) enforces case-scope network restrictions on tool execution.
- The `bootstrap-reverse.ps1` and `refresh-tool-index.ps1` scripts consume these mappings to create reproducible environments.

## Frequently Asked Questions

### What is the relationship between bootstrap-manifest.json and sandbox-profile.md?

The [`bootstrap-manifest.json`](https://github.com/zhaoxuya520/reverse-skill/blob/main/bootstrap-manifest.json) file provides the technical specification for each tool—including installation methods and verification commands—while [`sandbox-profile.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/sandbox-profile.md) organizes these capabilities by runtime context. The manifest answers "how do we install this tool," while the profile answers "where does this tool run."

### How does the sandbox profile determine which runtime to use for a tool?

The profile relies on the **"能力 | 典型场景"** table that pairs each capability with its typical operational scenario. For example, `frida` appears alongside `apktool` and `jadx` under the Android scenario, indicating that the Android runtime—whether a device or emulator—is required for its operation.

### Can I use sandbox-profile.md without the auto-bootstrap system?

Yes. The profile functions as documentation for manual environment configuration. The **Z3r0 sandbox tools** section (lines 25-36) specifically addresses tools that are not auto-installed, providing manual installation strategies for Kali Linux, external MCPs, or direct package management.

### How do network profiles restrict tool usage in sandbox environments?

The **network_profile 联动** section (lines 49-55) defines which sandbox-profile modes are compatible with `offline` versus `authorized_target_only` network scopes. When a container initializes, the system checks this mapping to ensure that network-scanning tools like `nmap` or `nuclei` execute only within permitted network boundaries, preventing accidental scanning of unauthorized targets.