Pick

A multiplatform penetration testing connector built with Dioxus and integrated with the Strike48 Connector SDK.

Pick connects Strike48 to local penetration testing tools, executing them securely on the machine where it runs.

Each app IS a connector - it registers with Strike48 and executes tools locally on the machine where it runs:

┌─────────────────────────────────────────────────────────────────┐
│                     Strike48 Backend                             │
│                   (Routes tool requests)                        │
└───────┬─────────────────┬─────────────────┬─────────────────┬───┘
        │                 │                 │                 │
        ▼                 ▼                 ▼                 ▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│   Desktop     │ │     Web       │ │    Mobile     │ │   Headless    │
│  (dioxus-     │ │  (dioxus-     │ │  (dioxus-     │ │  (dioxus-     │
│   desktop)    │ │   liveview)   │ │   mobile)     │ │   liveview)   │
├───────────────┤ ├───────────────┤ ├───────────────┤ ├───────────────┤
│ UI + Tools    │ │ UI + Tools    │ │ UI + Tools    │ │ Tools only    │
│ run locally   │ │ run on server │ │ run on device │ │ no local UI   │
└───────────────┘ └───────────────┘ └───────────────┘ └───────────────┘

• Docker (Linux host): follow docs/DOCKER_INSTALL.md. It starts with a setup choice, runs a preflight check, and has a section for installing with an AI coding agent.
• Native app (macOS, Windows, Linux): download it from the releases page.
• From source: see docs/INSTALLATION.md and Building below.

• 8 Built-in Themes: Dark, Light, Dracula, Gruvbox, Tokyo Night, Matrix, Cyberpunk, Nord
• Custom Themes: Import your own CSS themes with security validation
• Keyboard Shortcuts: Ctrl+Shift+1-8 for instant theme switching
• Shape Customization: 5 border radius options (Sharp to Pill)
• Density Control: Compact, Normal, or Comfortable spacing
• Smooth Transitions: Animated theme changes with 300ms easing
• Easter Eggs: Konami code (↑↑↓↓←→←→BA) activates Matrix rain animation

See docs/UI_FEATURES.md for complete customization guide.

Pick integrates 100+ penetration testing tools across multiple categories:

Native Tools (24):

• Network scanning (port_scan, arp_table, ssdp_discover, network_discover)
• WiFi testing (wifi_scan, wifi_scan_detailed, autopwn suite)
• Web vulnerability scanning
• Credential testing and harvesting
• Evidence collection (screenshot, traffic_capture)
• System enumeration and command execution

External Tool Integrations (70+):

• Network: nmap, masscan, rustscan, unicornscan
• Web: nikto, sqlmap, nuclei, ffuf, feroxbuster, gobuster
• WiFi: aircrack-ng, bettercap, responder
• Enumeration: subfinder, amass, enum4linux, smbmap
• Exploitation: hydra, john, hashcat, crackmapexec
• And many more...

See docs/TOOLS.md for the complete tool catalog.

Evidence quality assurance through specialized agents:

• Red Team Agent - Tool execution and evidence generation
• Validator Agent - Quality verification and validation
• Report Agent - Finding synthesis and reporting

Autonomous agents that execute attacker-influenced content need defense against two failure modes: attacks (adversarial content hijacking the agent) and aislop (AI-generated noise and decoys that grind an agent down, burning tokens on dead ends until it gets stuck in the mud).

We borrowed the defensive playbook from honeyslop: self-identifying markers that make forged output instantly triageable, layered defense-in-depth, provenance consistency checks, bounded iteration budgets, and a CI "doctor" that re-verifies every control on every PR. Pick adopts that playbook incrementally: each control below is marked shipped or planned, and the CI doctor (C4) is not shipped yet.

In short: agent output must be triageable, agent context must be sanitized, agent work must be budgeted, and agent controls must be CI-verified.

• C1: Seed-channel fail-closed sanitization - neutralize injection before Validator/Report seeds (shipped in v0.1.11)
• C2: Injection-flag publish gate - findings flagged for injected-instruction markers at ingestion are refused at the report boundary; webwright severity hygiene (explicit info stays Info, unlabeled descends to Low, same-title duplicates merge) (provenance-consistency checking is planned, not shipped)
• C3: Session budget envelope + stall detector - per-engagement tool-spend cap with a wind-down refusal, advisory stall detection, and a bounded begin_scan reset so an agent cannot restart its own envelope (advisory only - the stall detector warns, it does not yet kill dead-end loops)
• C4: Doctor-style CI validator - re-verify every control on every PR (planned; tracked in pick#453, not shipped in v0.1.11)
• C5: Canary markers + triage gate - per-engagement nonces make forged output self-identify (planned)
• C6-C8: Handoff hygiene, target scope fence, persona distrust boundary (P1)
• C9-C10: Marker rotation, evidence flood control + loop breaker (P2)

Full rationale, the attack-surface analysis behind these choices, and the trade-off decisions are in docs/AGENT_HARDENING_REVIEW.md.

• Android Root Detection (PR #123) - Detect rooted Android devices
• Agent ERROR Status Detection (PR #134) - Surface token limit notices
• Strike48 Default Theme (PR #120) - Professional default theme
• Chat Panel Routing (PR #132) - Fixed LiveView event handling

pick/
├── crates/
│   ├── core/          # Core types, state management, SDK integration
│   ├── platform/      # Platform abstraction (desktop, android, ios)
│   ├── ui/            # Shared Dioxus UI components + LiveView server
│   └── tools/         # Tool implementations
├── apps/
│   ├── headless/      # Headless agent (pentest-agent binary)
│   ├── desktop/       # Desktop app (dioxus-desktop)
│   ├── web/           # Web app (dioxus-liveview + axum)
│   └── mobile/        # Mobile app (dioxus-mobile)

• Rust 1.92+ (with cargo)
• For desktop: Native development tools for your OS
• For mobile: cargo-mobile2 and platform SDKs
• Linux builds target glibc >= 2.35 (Ubuntu 22.04 / Debian 12+).

The Linux release tarballs are self-contained for their shared-library dependencies: every shared library a binary links other than the desktop's webkit stack is bundled inside the tarball under lib/ and resolved through an $ORIGIN/lib rpath baked into the binaries at link time. That includes the transitive closure of each bundled library, not just the direct links — libpcap (agent, web, desktop), OpenSSL 3 (libssl/libcrypto; agent, web, desktop), libxcb (agent, web, desktop) and libxdo (desktop) drag along the libdbus → libsystemd → lzma/zstd/lz4/gcrypt/gpg-error/cap stack and libXau/libXdmcp → libbsd/libmd. The closure is the difference between "resolves on the release runner" and "resolves on NixOS or in a minimal container". The release pipeline enforces this with scripts/check-linux-deps.sh (every ldd resolution must land in lib/ or be a base-system/allowed library, whole-entry rpath present, glibc floor held). What a host must still provide:

License attribution for the redistributed libraries (BSD-3-clause, Apache-2.0/OpenSSL dual, MIT/X11) ships inside each Linux tarball as THIRD-PARTY-NOTICES.md.

The headless agent (pick-agent-linux-x86_64.tar.gz) has no host library dependencies beyond the glibc/libgcc base system — the binary and the bundled lib/ are enough on any glibc-2.35+ host, including NixOS and minimal containers. One caveat for consumers: StrikeHub's fetch path currently stages only the binary and drops the sibling lib/, so a strikehub-fetched agent is still affected on minimal hosts until Strike48-public/strikehub#108 lands; extract the tarball directly in the meantime.

The desktop tarball's entry point is the pentest-connector launcher (next to the real pentest-connector-bin). Because the binary links WebKit2GTK as a NEEDED library, a host without it used to die inside the dynamic loader before any of Pick's own code could print an error. The launcher probes for that gap up front and turns it into an actionable message with the exact package line. The failure mode it replaces, verbatim from the field (released agent, NixOS host, stderr discarded by its supervisor):

error while loading shared libraries: libpcap.so.0.8

libpcap is now bundled; the only remaining host gap on the desktop app is the WebKit2GTK stack (the web engine plus its GTK/X11 package closure), which the launcher names by its exact apt package.

Two notes about the bundled OpenSSL: the $ORIGIN/lib rpath makes the bundled libcrypto/libssl win over any host copy (rpath is searched before LD_LIBRARY_PATH and the default directories), so OpenSSL security fixes reach users through Pick releases rather than host package updates. And legacy OpenSSL provider operations (e.g. legacy PKCS#12/RC4 paths) are dlopen'd from the host's compiled-in ossl-modules directory; a host that needs them must ship the libssl3/openssl package's module directory alongside.

The headless agent (pentest-agent) runs without a GUI and serves its workspace app via Dioxus LiveView over a Unix socket. It can run standalone or be managed by StrikeHub as the "Pick" connector app.

# Standalone — connects to Strike48 directly
STRIKE48_HOST=grpc://connectors-studio.example.com:80 \
    STRIKE48_TENANT=non-prod \
    STRIKE48_INSTANCE_ID=pick-local \
    STRIKE48_TLS=false \
    MATRIX_TLS_INSECURE=true \
    cargo run --package pentest-headless

# StrikeHub IPC mode — launched automatically by StrikeHub with
# STRIKEHUB_SOCKET set. No STRIKE48_HOST required (liveview-only).

Environment variables (standalone):

# Development (requires sudo for WiFi hardware access)
sudo cargo run --package pentest-desktop

# Release build
cargo build --release --package pentest-desktop
sudo ./target/release/pentest-desktop

Why sudo? WiFi penetration testing tools (autopwn, wifi_scan, airmon-ng) require direct hardware access to wireless adapters, which needs real root privileges. See docs/BWRAP_SUDO_EXPLAINED.md for details.

# Development (starts server on http://localhost:3000)
cargo run --package pentest-web

# Release build
cargo build --release --package pentest-web

# Install cargo-mobile2
cargo install cargo-mobile2

# Initialize mobile project (first time)
cd apps/mobile
cargo mobile init

# Build for Android
cargo mobile android build

# Build for iOS
cargo mobile ios build

The connector connects to a Strike48 backend server. Configuration options:

• Strike48 Host: gRPC or WebSocket endpoint (e.g., grpc://localhost:50061)
• Tenant ID: Strike48 tenant identifier
• Auth Token: JWT or One-Time Token (OTT) for authentication

Environment variables:

• STRIKE48_HOST / STRIKE48_URL - Strike48 server URL
• STRIKE48_TENANT / TENANT_ID - Tenant ID
• STRIKE48_INSTANCE_ID / INSTANCE_ID - Connector instance ID
• CONNECTOR_NAME - Gateway identity name (default: pentest-connector)
• RUST_LOG - Logging level (e.g., pentest=debug)

1. You run one of the apps (desktop, web, headless, mobile)
2. The app connects to the Strike48 backend and registers as a connector
3. Apps with a UI (desktop, web, mobile) present it for manual tool execution; headless has no local UI
4. Tools can also be triggered remotely via the Strike48 API (e.g., by an AI agent)
5. All tool execution happens locally on the machine running the app

Pick is a native app that is both a UI and a connector - the same architecture proven in production environments.

1. Create tool file in crates/tools/src/
2. Implement PentestTool trait
3. Add to create_tool_registry() in lib.rs
4. Implement platform-specific functionality in crates/platform/

1. Create platform module in crates/platform/src/
2. Implement all platform traits (NetworkOps, SystemInfo, CaptureOps, CommandExec)
3. Add feature flag to Cargo.toml
4. Update get_platform() function

For WiFi scanning and pentesting features, we recommend using a dedicated external WiFi adapter. This prevents disconnection issues when your primary adapter enters monitor mode.

If you're connected to the internet via WiFi and try to scan with your built-in adapter:

1. Your adapter enters monitor mode
2. You lose your internet connection
3. Pick disconnects from the Strike48 backend
4. The scan fails

Solution: Use an external adapter for scanning while keeping your internet connection active via built-in WiFi or Ethernet.

Alfa AWUS036ACHM (MT7610U / MediaTek chipset)

• Dual-band (2.4 & 5 GHz)
• Excellent range/sensitivity
• Reliable monitor mode + packet injection
• Native Linux driver support (mt76 series)
• Plug-and-play on modern Kali
• Compact/mini form factor
• ~$40-50 range

Alfa AWUS036AXML (MT7921AU / MediaTek WiFi 6E chipset)

• WiFi 6E support (adds 6 GHz)
• Very strong 2025 performance
• Good drivers in recent kernels
• Excellent range on 2.4/5 GHz
• Reliable injection
• ~$60-70 range

Alfa AWUS036ACS or AWUS036AC (Realtek RTL8811AU / RTL8812AU)

• Budget-friendly (~$30 range)
• Dual-band (2.4 & 5 GHz)
• Solid out-of-the-box Kali support
• Good for beginners
• Reliable for basic-intermediate aircrack-ng tasks

Alfa AWUS1900 (Realtek RTL8814AU)

• 4 antennas, very long range
• High power output
• Great for wardriving or distant targets
• Slightly bulkier and more expensive (~$80-100)

• Alfa AWUS036NHA (Atheros AR9271) - Gold standard for years, rock-solid injection, 2.4 GHz only
• Panda PAU05 / PAU09 - Low-profile, cheap, reliable 2.4 GHz injection
• TP-Link TL-WN722N v1 (Atheros AR9271) - Very cheap and effective (avoid v2/v3)

This tool is designed for authorized penetration testing and security research. Features include:

• Network reconnaissance capabilities
• System information gathering
• Traffic interception (requires elevated privileges)
• Command execution

Always ensure you have proper authorization before using these tools on any system or network.

Mozilla Public License 2.0 (MPL-2.0) - See the LICENSE file for details. The vendored strike48-connector and strike48-proto SDK crates are Strike48 proprietary components distributed under their own license (vendor/strike48-connector/LICENSE) and are outside the MPL-2.0 grant.

• Dioxus - Cross-platform UI framework
• Strike48 Connector SDK - gRPC/WebSocket connector framework
• Based on android-pentest-connector