FPBInject

English | 中文

Runtime code injection for ARM Cortex-M. Replace any function on a running MCU through a serial connection — no reflashing, no debugger, no downtime.

FPBInject uses the Flash Patch and Breakpoint (FPB) hardware unit to intercept function calls and redirect them to your custom code in RAM, while the original Flash stays untouched.

Traditional vs FPBInject

gantt
    title Iteration cycle comparison (typical STM32 project)
    dateFormat  s
    axisFormat  %Ss

    section Traditional
    Edit code          : a1, 0, 5s
    Compile & link     : a2, after a1, 15s
    Erase flash        : a3, after a2, 3s
    Flash write        : a4, after a3, 5s
    MCU reboot         : a5, after a4, 2s
    Reproduce issue    : a6, after a5, 5s

    section FPBInject
    Edit code          : b1, 0, 5s
    Compile & inject   : b2, after b1, 1s
    Reproduce issue    : b3, after b2, 5s

The traditional cycle touches flash on every iteration — compile, erase, write, reboot, then finally reproduce the issue. With FPBInject, the MCU never stops: save your patch, it's live in under a second. No pit stop required.

How It Works

flowchart LR
    A["caller()<br/>calls foo()"] -->|"FPB intercepts<br/>foo's address"| B["Trampoline<br/>in Flash"]
    B -->|"Jump to RAM"| C["Your Code<br/>in RAM"]

The FPB unit matches the target function's address, redirects execution through a trampoline in Flash, which jumps to your replacement function in RAM. All handled by hardware — zero software overhead on the call path.

Workbench

FPBInject ships with a browser-based workbench for the full workflow: browse symbols, read disassembly, write patches, and inject — all from one interface.

Symbol Search & Disassembly

Search the firmware's symbol table, click a function to view its disassembly or decompiled source.

Manual Inject

Write your replacement function in C, then hit inject. The workbench compiles, uploads, and patches — typically under a second.

Auto Inject

Point the workbench at your source directory and enable file watching. Add /* FPB_INJECT */ before any function you want to patch, then just save the file — the workbench detects the change, recompiles, and re-injects automatically.

File Transfer (Optional)

FPBInject also supports file transfer over serial — browse, upload, and download files on the device's filesystem. Supports drag-and-drop (files and folders), CRC verification, and progress tracking.

Filesystem backends: POSIX (NuttX VFS, Linux), FatFS, standard C library (stdio), or custom implementations via the fl_fs_ops_t interface.

Memory Access

Read and write arbitrary memory addresses on the device over the same serial connection — handy for inspecting or poking a variable's live value without a debugger attached.

fpbinject --port /dev/ttyACM0 mem-read 0x20000000 64
fpbinject --port /dev/ttyACM0 mem-write 0x20000000 DEADBEEF

Unpatch

Every patch can be removed at any time, instantly restoring the original Flash behavior — the safety net that makes live patching low-risk to experiment with.

fpbinject --port /dev/ttyACM0 unpatch --comp 0   # or --all

Remote Control & Auto-Discovery

The workbench advertises itself over mDNS, so the CLI and SDK can find it on the LAN without knowing its IP:

fpbinject discover                       # list visible WebServers
fpbinject -s bench-pc:5500 info          # control one by host:port

This also means one workbench can be shared by multiple engineers, or one script can drive several devices across the network — each identified by its own handle.

Virtual Serial Passthrough

The workbench can expose a PTY device file (e.g. /tmp/fpb-ttyACM0) that mirrors the full byte stream to/from the device, so external tools (minicom, pyserial, a legacy logging script) can attach without disconnecting the workbench.

fpbinject vserial-start     # start
fpbinject vserial-status    # check the symlink path
fpbinject vserial-stop      # stop

Quick Start

1. Build & Flash Firmware

git clone https://github.com/FASTSHIFT/FPBInject.git
cd FPBInject

cmake -B build -DAPP_SELECT=3 -DCMAKE_TOOLCHAIN_FILE=cmake/arm-none-eabi-gcc.cmake
cmake --build build

st-flash write build/FPBInject.bin 0x08000000

2. Install the Host Tools

Install from PyPI — this provides the fpbinject-server (workbench) and fpbinject (CLI) commands, plus the Python SDK:

pip install fpbinject

cd Tools/WebServer
pip install -r ../requirements.txt
python main.py           # workbench
python fpb_cli.py --help # CLI

3. Start the Workbench

fpbinject-server

Open http://127.0.0.1:5500 in your browser, connect to the serial port, load your ELF file, and start patching.

4. Or Use the CLI

All commands output JSON, designed for scripting and AI agent integration.

# Search for functions
fpbinject search firmware.elf "gpio"

# View disassembly
fpbinject disasm firmware.elf digitalWrite

# Inject a patch
fpbinject --port /dev/ttyACM0 --elf firmware.elf \
    --compile-commands build/compile_commands.json \
    inject digitalWrite patch.c

See the CLI Guide for the full command reference.

5. Or Use the Python SDK

Drive everything the CLI can do from Python:

from fpbinject import Client

# Auto-discover a running WebServer on the LAN (mDNS)
client = Client.discover(token="...")
client.serial_send("help\r\n")
print(client.serial_read()["raw_data"])
client.inject("digitalWrite", "patch.c", elf="firmware.elf")

# Or skip the WebServer entirely — talk to the serial port directly
with Client.direct("/dev/ttyACM0") as dev:
    dev.inject("digitalWrite", "patch.c", elf="firmware.elf")

# Or analyze an ELF offline — no device needed
off = Client.offline()
print(off.signature("firmware.elf", "digitalWrite"))

See the SDK Guide for the full API.

Writing Patches

Create a C file with the /* FPB_INJECT */ marker. The function signature must match the original.

#include <Arduino.h>

/* FPB_INJECT */
__attribute__((section(".fpb.text"), used))
void digitalWrite(uint8_t pin, uint8_t value) {
    printf("Patched: pin=%d val=%d\n", pin, value);
    value ? digitalWrite_HIGH(pin)
          : digitalWrite_LOW(pin);
}

To call the original function from injected code, you need two things: a function pointer pointing directly at the original address (bypassing the FPB redirect), and temporarily disabling the patch around the call. Direct calls by name will still be intercepted by FPB and cause infinite recursion.

/* Define a function pointer to the original address (| 1 sets the Thumb bit) */
typedef void (*digitalWrite_fn_t)(uint8_t, uint8_t);
static digitalWrite_fn_t const ORIG_DIGITALWRITE = (digitalWrite_fn_t)(0x08001234 | 1);

/* FPB_INJECT */
__attribute__((section(".fpb.text"), used))
void digitalWrite(uint8_t pin, uint8_t value) {
    printf("Patched: pin=%d val=%d\n", pin, value);

    /* Disable patch -> call original via pointer -> re-enable */
    fpb_enable_patch(0, false);
    ORIG_DIGITALWRITE(pin, value);
    fpb_enable_patch(0, true);
}

The workbench generates this pattern automatically when the original function address is known.

Supported Hardware

FPBInject/
├── Source/                 # FPB driver, trampoline, DebugMonitor
├── App/
│   ├── func_loader/        # Serial protocol, memory allocator, FPB control
│   ├── inject/             # Injection helpers
│   └── tests/              # Firmware unit tests (host-based, with coverage)
├── Project/                # Platform HAL (STM32F10x, Arduino API)
├── Tools/
│   └── WebServer/          # Workbench (Flask backend + JS frontend) & CLI
└── Docs/                   # Architecture, CLI reference, WebServer guide

Documentation

License

MIT

References

• ARM Cortex-M3 Technical Reference Manual
• ARMv7-M Architecture Reference Manual
• STM32F103 Reference Manual