Microcorruption: Beginner's Guide to the Embedded CTF (2026)

CTF & Practice
14 min read
Microcorruption: Beginner's Guide to the Embedded CTF (2026)
On this page
  1. What Is Microcorruption?
  2. Is Microcorruption Good for Beginners?
  3. The Microcorruption Debugger in 5 Minutes
  4. The MSP430 Assembly You Actually Need
    1. The three interrupts that open doors
  5. How to Solve the Microcorruption Tutorial, Step by Step
  6. Every Microcorruption Level: Points and Prerequisites
  7. Spoiler-Free Hints for the First Three Levels
    1. New Orleans
    2. Sydney
    3. Hanoi
  8. Microcorruption vs Other Reverse Engineering Practice
  9. Legal and Ethical Considerations
  10. Frequently Asked Questions
  11. Your Next Steps

Microcorruption is a free capture the flag game that hands you a debugger, a fake smart lock and one job: open the door without knowing the password. Every level is real MSP430 machine code, and the bugs you exploit are the same memory corruption flaws that break real embedded devices. If you want a reversing target on a normal Linux binary afterwards, HackerDNA's License Key Crackme lab is the natural next step.

This guide covers what Microcorruption is, the debugger commands you will type a thousand times, the handful of MSP430 instructions that matter, and the tutorial level solved step by step. Then you get a full map of the levels with their points and prerequisites, plus spoiler-free hints for the first three locks. No assembly background needed.

TL;DR: Microcorruption is a free, browser-based embedded security CTF built by Square and Matasano in 2014 and now run with NCC Group. You reverse engineer the firmware of a fictional Lockitall lock on an emulated MSP430 chip, then send the input that opens it. No account is needed, the tutorial takes about 15 minutes, and the first real levels teach reading memory, little-endian values and your first buffer overflow.

What Is Microcorruption?

What is Microcorruption? Microcorruption is an online embedded security CTF where each level is the firmware of a fictional electronic lock, the Lockitall LockIT Pro, running on an emulated Texas Instruments MSP430 microcontroller. You get a disassembly, a memory view and a debugger, and you win a level by finding an input that makes the lock call its door-opening routine.

The story is pure comedy. Briefcases of "Cy Yombinator bearer bonds" sit in warehouses protected by Lockitall locks, and your operatives are waiting outside each one for you to trick the lock open. The code is serious, though: real MSP430 assembly, with a debugger that behaves much like GDB attached to a remote chip.

A bit of history helps you trust the material:

  • January 2014: Square announced the "Matasano/Square Capture the Flag Challenge" on its engineering blog, promising players would "learn assembly, overflow buffers, and crack DRM."
  • Matasano Security built the interface. NCC Group had acquired Matasano in 2012, and the site today carries an NCC Group and Square copyright and links to NCC Group's privacy notice.
  • October 2022: NCC Group published new Microcorruption challenges for a second lock generation, the LockIT 2, based on bug classes its hardware team had found in real products.

One practical surprise: the current site has no accounts. Your solved levels live in your browser's local storage, so clearing your browser data wipes your progress.

Is Microcorruption Good for Beginners?

Yes, with one condition: you need to be comfortable with basic programming ideas like variables, loops and functions. The game's own About page says it was designed for people who have never used a low-level debugger or read assembly. Square's launch post said the same thing in plainer words: the only things you need are "curiosity and time."

Where Microcorruption shines for beginners:

  • Zero setup. Everything runs in the browser through a WebAssembly emulator. No VM, no toolchain, no downloads.
  • A tiny architecture. The MSP430 is a 16-bit chip with 16 registers and a short instruction list. You learn assembly concepts without drowning in x86 quirks.
  • A real tutorial. The first level walks you through every debugger feature with guided pop-ups.
  • One idea per level. Most locks have a single bug. When you find it, you know exactly what you learned.

Our honest take: Microcorruption is the best free way to understand what a buffer overflow actually does to memory. It is not the best first CTF if you have never written code. In that case, start with our beginner's guide to CTFs and come back after a few easy web or forensics challenges.

💻
Practice this now: Binary Secrets - dig a hidden flag out of a mystery binary's raw bytes. It trains the same habit Microcorruption rewards: reading memory instead of guessing.

The Microcorruption Debugger in 5 Minutes

The screen has five areas you will use constantly: the disassembly on the left, the live memory dump, the register panel, the debugger console where you type commands, and the I/O console where the lock prints messages and asks for input.

Type help in the console and you get the full command list. These are the ones that matter on day one:

CommandShort formWhat it does
continuecRun until the next breakpoint or input prompt
step [count]sExecute one instruction, or count instructions
break [addr]bSet a breakpoint on an address or a label like main
unbreak [addr]uRemove a breakpoint
finish / outfRun until the current function returns
read [addr] [n]rDump n bytes of memory from an address
let [reg/addr] = [value]lWrite to a register or memory
reset-Restart the CPU from scratch
solve-Send your answer to the "real" lock and finish the level

Three details save beginners a lot of confusion:

  1. Every number is base 16. step 10 runs sixteen instructions, not ten. You do not type 0x: the debugger even prints a reminder if you do.
  2. The input box has a hex checkbox. Ticked, it lets you type raw bytes, so 74657374 sends the same thing as the text test. You will need this as soon as an exploit includes addresses or null bytes.
  3. Debugging and solving are separate. You experiment on a test lock with full debugger access. When you type solve, debugging stops and you get one input for the real lock.

You can also chain commands with semicolons and create aliases with #define, which helps once you repeat the same reset; b check_password; c routine for the tenth time.

The MSP430 Assembly You Actually Need

The official LockIT Pro manual (15 short pages, in the game under "Manual") describes the MSP430 as "a conventional 16 bit register RISC architecture with a RAM-based stack, 16 registers, and a simple memory map." Instructions are written opcode source, destination, which is backwards from what Intel-syntax readers expect.

Learn these instructions and you can read the first ten levels:

  • mov src, dst: copy a value. mov.b copies a single byte.
  • add, sub, inc: arithmetic. inc r12 adds one to r12.
  • cmp src, dst: compute dst - src, set the flags, throw away the result.
  • tst r14: check whether a value is zero.
  • jeq/jz and jne/jnz: jump if the last comparison was equal (zero) or not.
  • call, ret, push, pop: functions and the stack. call pushes a return address, ret pops it.

Registers follow a few conventions. r0 is the program counter (pc), r1 the stack pointer (sp) and r2 the status register (sr). Function arguments start in r15, and return values come back in r15. Operands like @r15 mean "the memory at the address in r15."

The three interrupts that open doors

The lock talks to hardware through software interrupts. The manual lists them all, and three decide whether you win:

  • INT 0x7F opens the deadbolt directly. If you can make the CPU reach it, the level is solved.
  • INT 0x7D asks the HSM-1 security module to check a password and set a flag in memory if it is correct. The firmware then reads that flag.
  • INT 0x7E asks the HSM-2 module to check a password and open the door itself if it matches.

That difference is the whole game in miniature. With HSM-1 the lock trusts a byte in memory, and bytes in memory can be overwritten. With HSM-2 the decision happens outside the CPU, so you need a different trick, usually making the code call INT 0x7F on your behalf.

How to Solve the Microcorruption Tutorial, Step by Step

The tutorial level walks you through this itself, so nothing below spoils a scored puzzle. The method is the one you will use on every lock afterwards. Here is the function that matters, exactly as the game disassembles it:

4484 <check_password>
4484:  6e4f           mov.b  @r15, r14
4486:  1f53           inc    r15
4488:  1c53           inc    r12
448a:  0e93           tst    r14
448c:  fb23           jnz    #0x4484 <check_password+0x0>
448e:  3c90 0900      cmp    #0x9, r12
4492:  0224           jeq    #0x4498 <check_password+0x14>
4494:  0f43           clr    r15
4496:  3041           ret
4498:  1f43           mov    #0x1, r15
449a:  3041           ret

Follow the same steps the tutorial asks you to type:

  1. Run it blind. Type c, enter test as the password, and read the "Invalid password" message. Then reset.
  2. Break on the check. Type break check_password, then c, and enter test again. The CPU stops at 4484 with r15 pointing at your input in memory (0x439c in the tutorial).
  3. Step through the loop. Press s a few times. Each pass loads one byte of your password into r14, moves r15 forward and adds one to r12. The loop stops when it reaches the null byte at the end of the string.
  4. Read the comparison. At 448e the code compares r12 with 9. With "test", r12 is 5: four characters plus the null terminator. The check never looks at what you typed, only how long it is.
  5. Solve it. Any 8-character password makes r12 equal 9. The tutorial suggests password. Confirm it on the test lock, then type solve and send the same input to the real lock.

The tutorial also shows a cheat: let pc=4498 jumps straight past the failed check on the test lock. It teaches you that the program counter is just a register. It cannot work on the real lock, because solve only accepts input. That rule forces you to find bugs instead of patching the CPU.

In practice, the pattern from this level repeats everywhere: find the function that decides, break on it, watch what your input does to registers and memory, then work out what input produces the winning branch.

Every Microcorruption Level: Points and Prerequisites

The map is not a straight line. Levels open up in branches, and the big Algiers level only opens once you have cleared four separate paths. The table below comes from the level data the site ships to your browser, and the last column quotes the overview each lock's manual page shows before you start, so it reveals nothing you would not see in the game.

LevelPointsRequiresWhat the lock manual says
New Orleans10TutorialThe first LockIT Pro, no security module
Sydney15New OrleansRevised software, password "removed from memory"
Hanoi20SydneyFirst lock attached to the HSM-1
Cusco25HanoiFixed "passwords which may be too long"
Reykjavik35Sydney"Military-grade" on-device encryption
Johannesburg20CuscoFirmware rejects passwords that are too long
Whitehorse50CuscoFirst lock attached to the HSM-2
Montevideo50WhitehorseRewritten under a "secure development process"
Santa Cruz50JohannesburgFurther rejects long passwords
Jakarta40JohannesburgFurther rejects long passwords
Addis Ababa50HanoiUsernames printed back to the user
Novosibirsk40Addis AbabaHSM-2 with features from the previous lock
Algiers100Reykjavik, Novosibirsk, Montevideo, JakartaNew LockIT Pro Account Manager
Vladivostok100AlgiersHardware randomization
Bangalore100VladivostokFirst MSP430 with memory protection
Lagos150AlgiersPasswords limited to alphanumeric characters
Chernobyl300Lagos, BangaloreAccount Manager again
Hollywood400Chernobyl"New randomization improves code security"
Vancouver10TutorialLockIT 2 with a debug interface
Cold Lake20VancouverBuilt "from bits of leftover scrap"
Halifax20VancouverHardened mode, 0x7f interrupt disabled
Churchill30Cold Lake"All vulnerabilities in our old locks are now resolved"
St. John's20ChurchillFirmware update for a vulnerability
Baku10Tutorial"Military grade encryption"

Do not let the points fool you. Johannesburg (20) comes after Cusco (25) on the map, and the LockIT 2 levels from NCC Group start at 10 points but assume you already read MSP430 code comfortably. Our suggested route: the original line from New Orleans to Cusco first, then Reykjavik, then Whitehorse and Johannesburg. Leave the LockIT 2 branch until Cusco feels easy.

Hanoi and Cusco are where Microcorruption becomes a lesson in memory corruption. If you want the theory behind them in x86 terms, the buffer overflow chapter of HackerDNA's Binary Exploitation course covers stack layout and return address overwrites with GDB.

Spoiler-Free Hints for the First Three Levels

Write-ups for every level are one search away, and reading one too early wastes the level forever. Give each lock at least an hour first. When you are stuck, use these nudges instead.

New Orleans

There is a function in the disassembly that runs before you are ever asked for a password. Read its name, read what it does, and then read the memory it writes to. That is the entire level.

Sydney

The password is no longer stored in memory, but check_password still has to compare your input against something. Look closely at the numbers inside the cmp instructions. Then remember that the MSP430 is little-endian: a 16-bit value is stored low byte first. Plenty of players get the right characters in the wrong order on their first try.

Hanoi

The lock prints "passwords are between 8 and 16 characters." Find the getsn call and compare that promise with the length the code actually allows. Then find the byte the firmware checks to decide whether you are in, and work out how far it sits from the start of your input. This is your first buffer overflow, and it needs no addresses or shellcode at all. Our article on how a buffer overflow works explains the idea if the term is new to you.

Tip: Keep a notes file per level with the key addresses, what each function does and the inputs you tried. From Cusco onwards you will reuse those notes, because later locks recycle the same library functions at shifted addresses.

Microcorruption vs Other Reverse Engineering Practice

Microcorruption is one excellent tool, not a full curriculum. It never touches x86, Linux binaries or decompilers like Ghidra. Here is how it fits with the other places beginners practice:

PlatformArchitectureSetupBest for
MicrocorruptionMSP430 (16-bit)Browser onlyLearning debuggers and memory corruption from zero
crackmes.oneWindows and Linux binariesYour own VMStatic reversing, keygens, Ghidra practice
pwn.collegex86-64 LinuxBrowser workspaceA structured, university-style exploitation path
HackerDNA labsLinux binariesBrowser, no VPNGuided reversing and exploitation on realistic targets

A good order for most beginners: Microcorruption through Cusco to learn what memory corruption looks like, a few easy crackmes to learn static analysis in Ghidra (our crackme walkthrough for beginners builds three practice ones with you), then x86-64 exploitation. The skills transfer directly: once you have overwritten a return address on a 16-bit chip, the x86 version is the same idea with wider registers.

Microcorruption is legal to play because the locks are fictional and the firmware was written to be broken. The skills are not fictional. Debugging firmware, reading memory and triggering overflows are exactly how researchers find bugs in real door locks, routers and medical devices.

Critical reminder: Never test real locks, devices or firmware you do not own or have explicit written authorization to assess. Dumping and modifying firmware on someone else's hardware can break computer misuse and anti-circumvention laws, even if your intent is curiosity.

  • Practice on CTFs, emulators and lab environments built for it.
  • If you find a bug in a real product you own, report it through the vendor's disclosure process.
  • Do not post full solutions under someone else's name, and avoid spoiling levels for others in public forums without warning.

Frequently Asked Questions

Is Microcorruption free?

Yes. Microcorruption is free to play in any current browser, and the site does not require an account. Progress is stored in your browser's local storage, so clearing site data resets your solved levels.

Who made Microcorruption?

Square and Matasano Security launched it in January 2014. Matasano was already part of NCC Group, and NCC Group added the LockIT 2 levels in 2022. The site footer today credits NCC Group and Square.

Do I need to know assembly for Microcorruption?

No. The game is designed to teach assembly as you go, and the in-game manual includes a short MSP430 reference. You do need basic programming knowledge such as loops, functions and variables.

What is the password for the Microcorruption tutorial?

Any 8-character input works, because the tutorial's check_password function only counts characters and compares the count, including the null terminator, with 9. The guided tutorial suggests typing "password."

How many levels does Microcorruption have?

The current level data includes the tutorial plus 24 scored locks: 18 original LockIT Pro levels from New Orleans to Hollywood, and 6 LockIT 2 levels such as Vancouver, Cold Lake and Halifax. Points range from 10 to 400.

Is Microcorruption good preparation for CTFs?

For the reversing and pwn categories, yes. It teaches debugger habits, reading assembly and stack-based overflows. You will still need practice with x86-64 Linux binaries and tools like GDB and Ghidra for most competition challenges.

Last verified: November 2026. Debugger commands, tutorial steps, level names, points and prerequisites checked against the live microcorruption.com application. Interrupt details quoted from the official LockIT Pro manual. History from Square's January 2014 announcement and NCC Group's October 2022 research post. MSP430 background from Wikipedia's TI MSP430 entry.

Your Next Steps

Microcorruption is the friendliest door into memory corruption there is: a free browser game where every level teaches one real bug. Open microcorruption.com, do the full tutorial instead of skipping it, and give New Orleans, Sydney and Hanoi an honest hour each before you look anything up. By Cusco you will understand stack overflows better than most people who only read about them.

When you want the same skills on a modern Linux target, move to HackerDNA's License Key Crackme: recover a hidden flag from an ARM64 client, rebuild its license check and forge your own key. Pair it with the buffer overflow chapter of the Binary Exploitation course. Everything runs in your browser, and you can start with HackerDNA's free tier - no credit card required.

HackerDNA Team

HackerDNA Team

Written by the HackerDNA team - cybersecurity professionals building hands-on hacking labs and educational content to help you develop real-world security skills.

Meet the Team

Ready to put this into practice?

Stop reading, start hacking. Real machines, in your browser, free.

Start Hacking Free
40,000+ Hackers Real labs Free
Start Hacking Free or solve today's hack, no account needed