[ Hardware Hacking — Links & Resources ]

External tools, hardware, and references that pair with the guides
and scripts on the Hardware Hacking parent page.
Grouped by what they're for:

  Boards / Pentest / Accessories   Physical platforms
       (Arduino, Pi, Teensy, BeagleBone), HID-attack hardware,
       and the 3D-printable mounts that hold it all together.

  Firmware RE / Serial / IDA      The reverse-engineering
       stack — firmware unpacking (binwalk, FMK), serial baud
       discovery, MPSSE-bridge libraries, IDA plugins.

  IDEs / PCB / Calculators       The "build something
       from scratch" side — toolchains, schematic CAD,
       fuse-bit calculators, Ohm's-law math.

  Blogs / Books / Tutorials      Reading list and
       walkthroughs. The places people publish RE post-mortems and
       step-by-step intros worth bookmarking.

Note on URLs: Several projects originally hosted on Google
Code (shut down March 2015) have been migrated to GitHub; entries
below point at the current mirrors. A few mid-2010s projects have
gone quiet entirely — flagged inline where that's the case.

Open-source prototyping platform built around AVR (and increasingly
ARM/RISC-V) microcontrollers. The reference board for "I want to
flash some firmware and read a sensor" projects without buying a
proprietary dev kit.

ARM Linux single-board computer, $25-100 depending on model. Pairs
with the
CAN-bus dev stack,
Home Assistant deployments, and the
ISP-programming flows on this site. Pi 4 (4-8 GB) is the sensible
default; Pi Zero 2 W when you need it small.

ARM Linux single-board computer family aimed at industrial / embedded
use. Two real-time PRU cores alongside the main ARM are the
distinguishing feature — useful for things that need sub-millisecond
GPIO timing where the Pi's Linux scheduling jitter would matter.

Compact USB-native ARM microcontroller boards from Paul Stoffregen at
PJRC. Native USB stack means HID-emulation projects (keyboards, mice,
joysticks) work without any external chip or board mod. Teensy 4.x
runs at 600 MHz on a thumbnail-sized board.

The original platform behind a lot of the HID-attack tooling on this
site — including
BruteForceAndroidPIN
and
APT (Arduino Pwn Tool).

Toolkit for easy use of Human Interface Devices for offensive
security and pentesting. Provides ready-made HID payloads
(reverse shells, credential capture, lateral movement) targeting
Windows, Linux, macOS — flash to a Teensy / Arduino / Rubber
Ducky-class device and plug into the target machine.

Same goal as the on-site
APT
but with a much larger ready-made payload library.

3D-printable STL that holds an Arduino Uno and a 400-tie-point
breadboard together on a single base plate. Saves your fingers
when you're poking at a circuit and the boards keep sliding around.

STL files lost — project listed for historical reference only.

3D-printable case / bumper for the Teensy 2.0. Drops over the
exposed board so a USB-plug-in pentest tool doesn't get bent /
shorted in transit.

STL files lost — project listed for historical reference only.

The canonical firmware-analysis tool: scans binary blobs for
embedded file systems, executables, compressed archives, certificates,
and other structures via a signature library. Simple to use, fully
scriptable, extensible via custom signatures + extraction rules +
plugin modules.

Originally on Google Code; now actively maintained by ReFirmLabs on
GitHub. pip install binwalk for the Python version,
or the Rust rewrite (cargo install binwalk) for ~10x
faster scans on large images.

Collection of scripts + utilities to extract and rebuild
Linux-based firmware images. Useful when you've identified an
embedded filesystem with Binwalk and want to actually modify its
contents (insert your own binary, swap a config, patch a string)
and repackage the firmware for re-flashing.

Originally Google Code project; GitHub mirror linked above.

Tools + scripts for analyzing bFLT (binary flat) executables
distributed with uClinux, including an IDA bFLT loader. Useful when
you encounter older embedded targets running uClinux instead of full
Linux + glibc — routers, set-top boxes, embedded NAS firmware
from the late 2000s / early 2010s.

Project sunset on Google Code; archive link above. If you can't get
the archive contents, search GitHub for community mirrors.

Database of private SSL / SSH keys recovered from embedded-device
firmware. Useful for two things: (1) confirming a target device
reuses a known-leaked key (security audit context), and (2) seeing
how widespread firmware-baked credential reuse really is across
consumer hardware lineups.

Maintained by Craig Heffner (devttys0). Originally Google Code,
now GitHub.

Identify the baud rate of an unknown serial device interactively.
Displays received data while letting you change the host serial
port's baud rate on the fly — press up/down to step through
common rates until the gibberish resolves into readable text.

Faster than running through 11 standard rates manually with
minicom; particularly useful when scoping the UART pins on an
unknown router or IoT device.

C library + Python wrapper for SPI / I2C communication via FTDI's
FT-2232 family of USB chips, based on libftdi. Lets a host computer
speak to SPI flash chips, EEPROMs, sensors, and other serial
peripherals through a $15 FTDI breakout instead of buying a
dedicated programmer.

Pairs with binwalk
for the read-flash → analyze-firmware workflow on chips that
require in-system programming (no removal needed).

Collection of IDA Pro scripts and plugins useful during firmware RE
— the parent repo containing the standalone tools listed below
plus several smaller helpers. Targets older MIPS / ARM embedded
firmware analysis specifically.

IDA plugin to graph all execution paths between two functions.
Useful for "is this sink reachable from that source?" analysis on
firmware blobs where you've identified a tainted-input function
and want to map call-graph reachability to a sensitive sink (memcpy,
sprintf, system, etc.).

Wrapper around IDA Pro that makes it easy to automate IDA script
execution against target files from the command line. Same scripts
can be run interactively in IDA's GUI without any code change.
Useful for batch-analyzing a corpus of firmware binaries with the
same RE script.

Integrated development environment for Atmel AVR and ARM Cortex-M
microcontrollers, now under Microchip's brand since the 2016
acquisition. Built on Visual Studio Shell — familiar UI if
you've used VS / Visual Studio Code.

Windows-only. Most of the AVR projects on this site use avr-gcc +
avrdude on Linux instead, but Microchip Studio is still the right
answer for in-circuit debugging via an Atmel-ICE or similar tool.

Lightweight Windows code / text editor with syntax highlighting for
~80 languages out of the box. The
Replacing
Arduino IDE with Notepad++ guide on this site uses it as a
command-line-driven Arduino dev environment for people who don't
want the official IDE.

User-defined Notepad++ syntax language file for Arduino C/C++ —
auto-complete and call-tip hints for the Arduino API, types, and
constants. Pairs with the on-site guide above for end-to-end
Notepad++-based Arduino workflow.

Robotics control software. Drag-and-drop UI for sensor + motor +
behavior wiring on EZ-Robot hardware specifically; also supports
Arduino / Raspberry Pi backends via plugins. Listed for completeness
— not directly used by anything else on this site.

PCB designer originally from CadSoft, acquired by Autodesk in 2017,
folded into Fusion 360 Electronics in 2023. The standalone "Eagle"
product reached end-of-life June 2026; existing schematics open in
Fusion 360 Electronics without conversion. Free tier covers
hobbyist board sizes; paid tier needed for larger / multi-layer
designs.

Schematic + breadboard-layout designer aimed specifically at
makers / hobbyists. The breadboard view (drag-and-drop
representations of real component pictures onto a virtual
breadboard) is what makes it distinctive — great for
documenting a project so someone else can recreate the wiring
visually without reading a schematic. PCB export available but
not as polished as KiCad / Fusion Electronics.

Browser-based breadboard editor with realtime circuit simulation
(Autodesk's hobbyist version of EAGLE / Fusion Electronics; replaced
the discontinued 123D Circuits in 2017). Free, no install —
useful for "does this circuit work in theory" sanity checks before
breadboarding for real.

Web-based AVR fuse-bit calculator. Pick your chip from a dropdown,
toggle the fuse options visually, and get the matching -U
lfuse:w:0x..:m -U hfuse:w:0x..:m avrdude command line. Saves
re-reading the datasheet's fuse bit tables every time you reflash a
chip.

The AVR Fuse
Tutorial linked in the Tutorials section below pairs well with
this for "what are fuses and why do I need to think about them".

Web-based Ohm's-law calculator. Voltage / current / resistance /
power — enter any two, calculates the others. Quick sanity
check when sizing a current-limiting resistor or a power-supply
rail without breaking out a real calculator.

Visual color-band resistor decoder. Click bands to match the
markings on a real resistor; reads out the resistance value +
tolerance + temperature coefficient. 4-band, 5-band, and 6-band
resistors all supported.

Useful when you've got a junk-box mystery resistor and want to know
what it is faster than reading the color bands manually.

Craig Heffner's blog on embedded-device hacking. Long-form
write-ups of router / IoT / firmware RE projects. The original
home of binwalk and most of the IDA plugins linked above; the
posts walking through specific vulnerability discoveries (often on
SOHO routers) are particularly worth reading for the methodology.

Sergei Skorobogatov's reference page (University of Cambridge
Computer Lab) on breaking copy protection in modern microcontrollers
— non-invasive (glitching / voltage / clock fault injection),
semi-invasive (UV / laser), and invasive (decap + microscope)
attack categories with example targets and references to academic
papers.

Cited in most subsequent MCU security work; the canonical "what's
actually possible against your secure boot fuse" reference.

Forum community for Atmel / Microchip AVR users. Decades of
archived threads cover specific chip behaviors, fuse settings,
toolchain gotchas, and obscure datasheet errata. Searches usually
turn up someone who already hit your exact problem in 2008.

Oscar Liang's blog on FPV drone builds and embedded hardware. Useful
beyond the drone niche for the embedded systems / soldering /
flight controller firmware writeups — lots of "I broke this,
here's how I fixed it" content.

Project-driven introduction to the Arduino platform. 65+ hands-on
projects, second edition updated for current Arduino IDE and
modern boards (Uno R4, Nano). No Starch Press — reliably good
press for hands-on technical books.

The "hello world" of Arduino tutorials — blink the on-board
LED. Built-in example in every Arduino IDE since the platform
launched; canonical starting point for "did I install the toolchain
correctly?"

Hackaday tutorial covering how to turn an Arduino Uno R2/R3 into a
USB keyboard / HID device by reflashing the ATmega16U2 USB chip.
The same technique the on-site
Arduino HID
Device guide uses as its starting point.

Arduino tutorials and parts shop — long-running collection of
sketch-driven write-ups covering specific shields (Ethernet, RFID,
GPS, LCD) and component types. Useful when you want a working
example for a specific shield before writing your own driver from
scratch.

Walk-through of unpacking and analyzing a Linux-based embedded
firmware image with binwalk + standard reverse-engineering tooling.
Beginner-to-intermediate; good first-pass tutorial if you've
identified a target firmware but never opened one before.

Open textbook chapter on reverse-engineering proprietary file
formats — the methodology behind projects like OpenOffice
parsing Microsoft Office files, or forensic tools recovering data
from undocumented binary structures. Tools-agnostic; covers the
mental model rather than specific software.

Tagged collection of ~26 AVR microcontroller tutorials on
ElectroSchematics — ranges from basic GPIO / timers / ADC up
through bus protocols (I2C, SPI, UART) and interrupt handling.
Good for filling in specific peripheral knowledge gaps.

Solid introduction to programming Atmel AVR microcontrollers in C
with the free avr-gcc toolchain. Skips the Arduino abstraction
layer entirely — useful when you want to understand what
digitalWrite() actually compiles down to, or when
you're working without the Arduino libraries.

Fuses are an extremely important part of programming an AVR chip,
but rarely explained thoroughly. You only set them once, but if you
do it wrong, you can brick a chip until you have an HV programmer
to reset it. This tutorial walks through what each fuse does, why
it matters, and how to set them safely.

Pairs with the Engbedded Fuse Calculator
above — the calculator gives you the bytes, this tutorial
tells you what the bytes mean.

Part 1 — Schematic Design /
Part 2 — Printed Circuit Board Layout

Two-part YouTube walkthrough of designing a simple schematic +
laying out the corresponding PCB in EAGLE. Pre-Autodesk-acquisition
era so the UI looks slightly different from current
Fusion Electronics, but the schematic-to-board
workflow concepts carry over directly.

On-site walkthrough of making your own PCB at home using the
laser-printer-toner-transfer method: print mirrored schematic from
EAGLE onto magazine paper, iron onto copper-clad blank, etch in
ferric chloride. Cheap, reasonably reliable single-sided PCBs in
about an hour without sending anything to a fab house.