PostHeaderIcon Decapsulate Locked STM32G030C6T6 Firmware: LQFP48 32 KB Recovery

The STM32G030C6T6 is the value-line entry of ST’s G0 family in a 48-lead body: an Arm Cortex-M0+ at 64 MHz with 32 KB of flash and 8 KB of SRAM inside a 7×7 mm LQFP48 package. Boards around it tend to be cost-sensitive controllers where the firmware was never archived, so the MCU itself is the only copy left. To decapsulate locked STM32G030C6T6 firmware you first have to defeat the read protection, and on a part this common and this small the productive path runs through the package rather than around it.

What the forty-eight lead body gives you

The LQFP48 exposes a generous pin set for the G0 value line, and both the serial wire debug pair and the USART bootloader pins are present and reachable on the board. On paper that looks like an open door into the flash. In practice the debug access port links at the physical layer and then refuses to return the main array, because the lock is enforced by the flash controller rather than by how the pins are wired. The STM32G030C6T6 carries no USB at all, so there is no DFU side entrance to slip through, and the ROM bootloader over USART answers to the same protection decision. Pin count is not the bottleneck; the readout protection is.

Where the readout protection lives

The protection on the STM32G030C6T6 is not compiled into the application. It sits in the option bytes, in a security-protection level field that the flash memory controller samples out of reset. Level 0 leaves the part open, level 1 blocks SWD and bootloader reads of main flash, and level 2 seals the device permanently. Nearly every locked field unit we see sits at level 1, which is recoverable. The familiar advice to unlock by dropping to level 0 is a trap on this family: stepping the part back to level 0 triggers a mass erase of the very 32 KB you were sent to recover. The mechanism echoes the fuse-and-lock schemes in our notes on AVR lock-bit protection, and the same rule — never trade the image for the unlock — drives our flash recovery work.

Decapsulated microcontroller die under firmware recovery

Why the electrical route stalls

Connect a probe and the SWD port answers, then fails the moment it reads the window at 0x08000000. Put the part into system bootloader mode and the read-memory command declines in the same place. Two different cables, one decision: the security level is evaluated before any user code runs, and both interfaces are gated by it. Ordinary programmers therefore return nothing but error codes from an otherwise healthy part. The part is alive and talking; it is simply refusing to hand over its memory.

Decapsulated microcontroller die under firmware recovery

Opening the package to reach the die

When both electrical doors are shut, the package is the way in. We remove the moulding compound over the die by chemical etch, exposing the silicon face with the bonding wires intact. An LQFP48 is a comfortable body for this work — the die sits centred and roomy, and the part stays electrically live after decapping. The process is documented on our silicon package decapsulation page, and the same route applies to neighbouring parts such as the STM32G030F6P6 in TSSOP20.

Decapsulated microcontroller die under firmware recovery

Reading the die after the cap comes off

Decapsulation alone does not hand over the image; it creates the working surface. With the silicon exposed, a precisely timed optical fault aimed at the security check while the part boots can make the verification fall through, leaving the debug port open long enough to stream the array out. On the STM32G030C6T6 the 32 KB of flash is a fast capture once the port holds. Where power or clock glitching is the cleaner attack, our power glitch work and clock glitch notes describe the alternative timing windows.

Decapsulated microcontroller die under firmware recovery

What the protection levels mean for recovery

The table below maps each level on the STM32G030C6T6 to what can be read and what it takes to get there.

Protection level SWD read USART boot Path to image
0 – open yes yes no recovery needed
1 – read lock no no decap plus fault or probing
2 – sealed no no microprobing only
Decapsulated microcontroller die under firmware recovery

What you receive when the read closes

Before anything leaves the bench the image is read twice and the passes are checksummed against each other; a mismatch means the port closed mid-read and the block is captured again. You receive the complete binary together with the option bytes showing the original lock state, and a disassembly-based source reconstruction where that is the goal. Where the aim is a replacement controller, the same verified file is what gets written to a blank firmware clone. Related G0 work includes the STM32G030C8T6 clone and the STM32G030K6T6 decode.

Comments are closed.

Categories