Skip to the content
2 layers89.8 × 58.4 mmPico glitcher v1.1, the printed circuit board in 3D

Adaptation of https://github.com/MKesenheimer/fault-injection-library

Size
89.8 × 58.4 mm
Copper layers
2
Thickness
1.6 mm
Parts
72
Nets
80
Pads
314
Tracks, vias
764, 86
Pours
2
Routed
Yes
KiCad
KiCad 8.0 (file 20240108)
Created
29 May 2025
Updated
6 Nov 2025

Overview

Pico glitcher v1.1 is an open-source printed circuit board by christiangroothuis, from the christiangroothuis/fault-injection-library repository on GitHub, published under the GPL-3.0 licence. It is a 2-layer board of 89.8 × 58.4 mm with 72 parts on 80 nets, routed with 764 tracks and 86 vias.

It is built around the IRF7807PBF-HXY, IRLML2502 and TPS2041D. Its parts include 19 resistors, 10 capacitors, 5 diodes, 4 transistors and 3 crystals. It belongs with the RP2040 boards of this library.

Main components

3

README

README.md

Usage with examples

Findus (aka the fault-injection-library) is a toolchain to perform fault-injection attacks on microcontrollers and other targets. This library offers an easy entry point to carry out fault-injection attacks against microcontrollers, SoCs and CPUs. With the provided and easy to use functions and classes, fault-injection projects can be realized quickly with cheap and available hardware.

Findus supports the ChipWhisperer Pro, the ChipWhisperer Husky and the PicoGlitcher. More information about the ChipWhisperer Pro and the ChipWhisperer Husky can be found on https://chipwhisperer.readthedocs.io/en/latest/index.html.

Table of contents

Purchasing the Pico Glitcher

Only a Raspberry Pi Pico and a few other components are required to use this software. However, in order to achieve the best results, a circuit board was developed that was adapted directly for the fault-injection-library.

The board consists of a Raspberry Pi Pico, two level shifters for in- and outputs with any voltage, and glitching transistors that can switch up to 66 amps. A multiplexing stage to quickly switch between up to four different voltage levels was added in revision 2.

There are several connection options for different voltage sources, from 1.8V, 3.3V to 5V. The Pico Glitcher can also be supplied with any external voltage via VCC_EXTERN. To power the target board, it is supplied with power via the VTARGET connection. The output of this voltage source can be controlled via software, i.e. the target can be completely disconnected from power by executing the power_cycle_target() command. This allows a cold start of the target to be carried out in the event of error states that cannot be eliminated by a reset.

Assembled Pico Glitcher v1

The Pico Glitcher can be purchased from the tindie online store: https://www.tindie.com/products/faulty-hardware/picoglitcher-v21/. If you have questions or special requests, please feel free to contact me.

Documentation

The documentation of the source code and how to use the library and the hardware can be found on https://fault-injection-library.readthedocs.io/.

Installing findus

If you just want to get started quickly and don't want to bother with the source code of findus, findus can be installed via pip. The findus library can be found on https://pypi.org/project/findus/ and can be installed locally in a Python environment using the following command:

bash
mkdir my-fi-project && cd my-fi-project
python -m venv .venv
source .venv/bin/activate
pip install findus

Install the optional RD6006 python bindings if you have a RK6006 or a RD6006 power supply from Riden:

bash
pip install rd6006

This external power supply can be used optionally to supply the target with power. It is possible to control the RD6006 power supply via the findus library using the power supply's USB interface. Suitable functions for this are implemented in the findus library. Don't worry if you don't have this power supply. The Pico Glitcher can also supply the target with voltage.

Now you can use findus:

bash
python
>>> from findus import Database, PicoGlitcher
...

The next step is to copy an existing glitching script and to adapt it to your needs. Start by copying https://github.com/MKesenheimer/fault-injection-library/blob/master/example/pico-glitcher.py. More example projects are located at https://github.com/MKesenheimer/fault-injection-library/tree/master/projects.

See examples for more information how to use findus and the Pico Glitcher.

Updating the Pico Glitcher firmware

Your Pico Glitcher should come with the latest firmware already installed. If not, follow the following procedure to update the software on the Pico Glitcher.

Step 1: MicroPython firmware

Download the MicroPython firmware from https://micropython.org/download/RPI_PICO/. Unplug the Pico Glitcher from your computer, press and hold the 'BOOTSEL' button on the Raspberry Pi Pico and connect it back to your computer. The Raspberry Pi Pico should come up as a flash-storage device. Copy the MicroPython firmware ('RPI_PICO-xxxxxxxx-vx.xx.x.uf2') to this drive and wait until the Raspberry Pi Pico disconnects automatically. More information about setting up the Raspberry Pi Pico can be found here.

Step 2: Install the findus library

Skip this step, if you already installed findus previously.

If you want to make sure that the libraries to be installed do not collide with your local Python environment, use a virtual environment. Set it up by generating a new virtual environment and by activating it:

bash
python -m venv .venv
source .venv/bin/activate

After these steps we have to install findus (aka fault-injection-library). Make sure to have pip installed.

bash
pip install findus

Step 3: Upload the Pico Glitcher MicroPython script

If everything went well, you should have the upload script available for execution in your command-line environment. Connect the Pico Glitcher to your computer and check which serial device comes up:

bash
ls /dev/tty*

Take note of the device path. Next upload the Pico Glitcher firmware and the specific configuration for your Pico Glitcher hardware version (config_v1/config.json, config_v2.1-2/config.json or config_v2.3/config.json) via the following command:

bash
cd .venv/lib/python3.12/site-packages/findus/firmware
upload --port /dev/tty.<rpi-tty-port> --files AD910X.py FastADC.py Globals.py \ 
    PicoGlitcher.py PulseGenerator.py Spline.py <config-path>/config.json

Your Pico Glitcher should now be ready to perform fault-injection attacks.

Installing from source

If you want to get involved in the development or to have access to all the resources of this repository, clone the findus library:

bash
git clone --depth 1 --recurse-submodules \ 
    https://github.com/MKesenheimer/fault-injection-library.git

Install the findus and the optional rd6006 library:

bash
cd fault-injection-library
pip install .
cd rd6006
pip install .

Then:

bash
cd findus/firmware
upload --port /dev/tty.<rpi-tty-port> --files AD910X.py FastADC.py Globals.py \ 
    PicoGlitcher.py PulseGenerator.py Spline.py <config-path>/config.json

The next step is to copy an existing glitching script and to adapt it to your needs. Start by copying fault-injection-library/example/pico-glitcher.py. More example projects are located at fault-injection-library/projects.

Test the functionality of your Pico Glitcher

The following setup can be used to test the Pico Glitcher.

  • Connect 'TRIGGER' input with 'RESET'.
  • Between 'GLITCH' and 'VTARGET', connect a 10 Ohm resistor (this is the test target in this case).
  • Optionally connect channel 1 of an oscilloscope to 'RESET' and channel 2 to 'GLITCH'.

Example setup

Next, run the test script pico-glitcher.py located in fault-injection-library/example:

bash
cd example
python pico-glitcher.py --rpico /dev/<rpi-tty-port> --delay 1000 1000 --length 100 100

You should now be able to observe the glitches with an oscilloscope on the 10 Ohm resistor. Measure the expected delay and glitch length with the oscilloscope.

UART Trigger

  • Connect 'TRIGGER' input to 'RX' and 'TX' of a USB-to-UART adapter
  • Between 'GLITCH' and 'VTARGET', connect a 10 Ohm resistor (this is the test target in this case).
  • Optionally connect channel 1 of an oscilloscope to 'RESET' and channel 2 to 'GLITCH'.

Example setup

Next, run the test script pico-glitcher-uart.py located in fault-injection-library/example:

bash
cd example
python pico-glitcher-uart.py --rpico /dev/<rpi-tty-port> --target /dev/<target-tty-port> --delay 1000 1000 --length 100 100

You should now be able to observe the glitches with an oscilloscope on the 10 Ohm resistor. Measure the expected delay and glitch length with the oscilloscope.

More Examples

More examples can be found on https://fault-injection-library.readthedocs.io/en/latest/examples/# or under fault-injection-library/projects.

Analyzer

During your glitching campaign, run the analyzer script in a separate terminal window:

bash
analyzer --directory databases

This spins up a local web application on http://127.0.0.1:8080 which can be used to observe the current progress.

Parameter space web application

Parts

72
QtyValueFootprintReferences
16PINHDR_1X1Connector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_VerticalTP_1V8, TP_3V3, TP_GLITCH_EN0, TP_GND0, TP_RESET0, TP_TRIGGER2, TP_VTARGET0, X_ANALOG0, X_GLITCH0, X_GLITCH1, X_GLITCH2, X_HPGLITCH2, X_LPGLITCH2, X_TRIGGER0, X_TRIGGER1, X_VCC_EXTERN0
8PINHDR_3X1Connector_PinHeader_2.54mm:PinHeader_1x03_P2.54mm_VerticalX_1V8, X_3V3, X_5V0, X_GLITCH_EN0, X_GND0, X_RESET0, X_TRIGGER2, X_VTARGET0
70.1uFCapacitor_SMD:C_0603_1608MetricC3, C4, C5, C6, C7, C9, C10
4100Resistor_SMD:R_Array_Concave_4x0603R16, R17, R18, R19
410KResistor_SMD:R_0603_1608MetricR1, R2, R5, R11
410kResistor_SMD:R_Array_Concave_4x0603R12, R13, R14, R15
4150Resistor_SMD:R_0603_1608MetricR6, R7, R8, R10
21RResistor_SMD:R_0603_1608MetricR3, R4
2BU-SMApico-glitcher:BU-SMAX1, X2
2NH245Package_SO:TSSOP-24_4.4x7.8mm_P0.65mmU1, U2
110nFCapacitor_SMD:C_0603_1608MetricC1
12.2uCapacitor_SMD:C_0805_2012MetricC2
1220Resistor_SMD:R_0603_1608MetricR9
122uFpico-glitcher:PANASONIC_CC8
1IRF7807PBFPackage_SO:SOIC-8_3.9x4.9mm_P1.27mmQ2
1IRLML2502Package_TO_SOT_SMD:SOT-23Q1
1JMP_VCC_INTERNConnector_PinHeader_2.54mm:PinHeader_1x02_P2.54mm_VerticalJMP_VCC_INTERN0
1LED_BLUE_GLITCH_ENLED_SMD:LED_0603_1608MetricD2
1LED_BLUE_TRIGGER2LED_SMD:LED_0603_1608MetricD3
1LED_RED_HPGLITCHLED_SMD:LED_0603_1608MetricD5
1LED_RED_LPGLITCHLED_SMD:LED_0603_1608MetricD1
1LED_RED_TARGET_POWERLED_SMD:LED_0603_1608MetricD4
1M01PTHConnector_PinHeader_2.54mm:PinHeader_1x01_P2.54mm_VerticalTP_5V0
1M08X2Connector_PinHeader_2.54mm:PinHeader_2x08_P2.54mm_VerticalX3
1Micro Slide SwitchButton_Switch_SMD:SW_SP3T_PCM13S1
1Raspberry Pipico-glitcher:RPI_PICOPICO0
1SW_Push_ShieldedButton_Switch_SMD:SW_Push_1P1T_NO_CK_KSC7xxJS_RST0
1TPS 79318Package_TO_SOT_SMD:SOT-23-5Q3
1TPS2041Package_SO:SOIC-8_3.9x4.9mm_P1.27mmQ4

More from christiangroothuis/fault-injection-library

2
  • 2 layers57 × 25.5 mmLpc1311-target v1, the printed circuit board in 3D

    Lpc1311-target v1

    christiangroothuis/fault-injection-library

    Adaptation of https://github.com/MKesenheimer/fault-injection-library

    38 partsGPL-3.0
  • 2 layers37 × 33.5 mmStm32f205-breakout board, the printed circuit board in 3D

    Stm32f205-breakout board

    christiangroothuis/fault-injection-library

    Adaptation of https://github.com/MKesenheimer/fault-injection-library

    3 partsGPL-3.0

Similar boards

  • 2 layers79 × 50 mmK0swe mountaineer mountaineer, the printed circuit board in 3D

    K0swe mountaineer mountaineer

    punkfab/pcb-corpus

    235 real KiCad boards from open-source hardware repositories, prepared as a placement and routing benchmark

    71 parts1
  • 4 layers60 × 28 mmRailLink, the printed circuit board in 3D

    RailLink

    Misaka0x2730/RailLink

    Compact isolated version of J-Link v9.

    83 parts134
  • 8 layers120 × 60 mmDFTBoard, the printed circuit board in 3D

    DFTBoard

    juliancoy/zynqPCB

    An 8-layer board in Kicad built upon Xilinx Zynq Chip. Includes sound output, HDMI, DDR3, and Arduino Uno style header for screen connection

    299 parts75MIT
  • 2 layers92.5 × 82.8 mmRifle and sensors, the printed circuit board in 3D

    Rifle and sensors

    DAlexis/caustic-lasertag-system

    Caustic project is a full-featured indoor and outdoor lasertag system

    268 parts16
  • 4 layers122.2 × 115.1 mmScan controller kicad, the printed circuit board in 3D

    Scan controller kicad

    fwachsmuth/Filmkorn-Raw-Scanner

    The Filmkorn Raw Scanner, turning 8mm and 16mm films into lossless 12-bit CinemaDNG

    170 parts13MIT
  • 2 layers68 × 81.5 mmController, the printed circuit board in 3D

    Controller

    orlopau/coffee-scale

    Scale for espresso and filter coffee.

    55 parts11
  • 2 layers42.3 × 24.5 mmMq7adapter, the printed circuit board in 3D

    Mq7adapter

    fablab-paderborn/mq7-adapter-board

    MQ7 Adapter Board

    15 parts9
  • 2 layers158 × 34 mmTaggerMainboard, the printed circuit board in 3D

    TaggerMainboard

    Infinitag/Hardware

    Files for the INFINITAG hardware

    75 parts6

Questions

How big is the Pico glitcher v1.1 PCB?

It measures 89.8 × 58.4 mm and has 2 copper layers, 1.6 mm thick.

What parts does the Pico glitcher v1.1 use?

72 parts, built around the IRF7807PBF-HXY, IRLML2502 and TPS2041D. The full list of its parts is on this page, with links to each part's symbol and footprint where PCBKit's library has them.

Where can I download the Pico glitcher v1.1 KiCad files?

From the christiangroothuis/fault-injection-library repository on GitHub, at the commit this page was made from: the board is schematics/kicad/pico-glitcher-v1/pico-glitcher-v1.1.kicad_pcb and its schematic schematics/kicad/lpc1311-target-v1/lpc1311-target-v1.kicad_sch. PCBKit opens the board in the browser, with nothing to install.

Can I use the Pico glitcher v1.1 design in my own project?

Its repository publishes it under the GPL-3.0 licence: you may reuse it on that licence's terms (keep the author's notice, and for a copyleft licence share your changes alike).