GBA-Hashcat: Cracking SHA256 on a Nintendo Game Boy Advance 

Password cracking typically relies on powerful hardware. As our previous research has shown, the latest GPUs can test large numbers of password candidates quickly, making processing power a major factor in any cracking attempt.

However, weak passwords can reduce the search space so significantly that even hardware never designed for security research may be capable of finding the right plaintext. That raises an interesting question: how little computing power does an attacker actually need when the target password is predictable enough?

Last week, several media outlets reported that a security engineer had created a port of Hashcat, the popular password cracking utility, to the Nintendo Game Boy Advance (GBA) handheld console. This was described as a mobile game able to crack SHA256, a hashing algorithm that we’ve written about in the past. While this app can be used to crack SHA256 hashes, calling it a full port of Hashcat is not entirely accurate. 

In this research, we build, install and run the “GBA-Hashcat” project to crack a given SHA256 hash. This shows what is possible on meagre hardware when a hash is weak enough and the attacker has some luck with where in the wordlist the matching plain is. Even a Nintendo GBA, in this case a 3DS running a GBA game, can crack some hashes. 

How GBA-Hashcat works

GBA-Hashcat can crack passwords, but it works very differently from Hashcat. Hashcat implements its hashing modules as massively parallel, GPU-accelerated code. GBA-Hashcat does not appear to use code from those modules and instead runs on the console’s CPU. It is better understood as a separate SHA256 cracking application built for the Game Boy Advance rather than a direct port of Hashcat.

The cracking process is also far simpler. Hashcat uses a rules engine and can utilize wordlists, whereas this application does not recreate the rules engine, and simply attempts to iterate through a wordlist and see if any of the hashes match. While Hashcat takes in a list of hashes to attempt to crack, this application hardcodes a specific hash and applies the given wordlist: 

Target hash hardcoded in main.cpp 

During operation, the program iterates through ignis-1M.txt, although the interface refers to the file as rockyou.txt. The ‘rockyou’ data dump is a widely used password wordlist that we have covered in previous research, but it is not the list used in this test. The reason for the mismatched name is unclear.

Cracking on limited hardware

The GBA has only a 16MHz ARM7 CPU, so performance is predictably limited and falls far below the rates associated with modern cracking hardware against SHA256. A single Nvidia RTX 5090 can crack SHA256 hashes at a rate of 27681.6 MH/s; a rig with eight RTX 5090s, like the one we used in our Argon2 research, is around 304 million times faster than the GBA at cracking SHA256.

Even so, the experiment makes a useful point. Cracking speed matters, but so does the quality and ordering of the candidate list. When a password is already present in a wordlist, the task is no longer to search every possible combination. The application only needs to reach the correct entry.

In this case, hunter2 appears at position 20,240 in the Ignis-1M wordlist. At the recorded rate of around 727 attempts per second, GBA-Hashcat should recover the plaintext from the hardcoded SHA-256 hash in approximately 27 seconds.

The takeaway is similar to our previous research into Argon2 performance with mdxfind and Hashcat: hardware limitations offer little protection when a password is predictable, reused or already present in an attacker’s wordlist. Even a handheld console can recover it under the right conditions.

Running GBA-Hashcat on a Nintendo 3DS 

We will be running this project on the Nintendo DS mode of a Nintendo 3DS. While this is not specifically the Game Boy Advance that this project was built for, it is possible to run GBA games on the ARM7 hardware available on the handheld, which is used to provide GBA compatibility. This is functionally equivalent to running the application on the original GBA hardware because Nintendo implemented a 16MHz ARM7 that is utilized to provide hardware-level compatibility. 

The mechanism of building and loading the game is outside of the scope of this writeup, but rest assure this is functionally equivalent in performance to the original GBA hardware. It is also easier to load it on the 3DS hardware due to some modern affordances in running ‘homebrew’ software. 

How the application is built

The project is implemented with Butano, an open source C++ based game engine for the GBA. Butano handles the underlying game loop and platform-specific boilerplate. The project then adds its SHA256 implementation in C++ to loop through the wordlist, update the UI, and check for matches. When it finds a hash that matches, it returns to the user that it was found, and what the plaintext record was that matched when hashed in SHA256. 

GBA-Hashcat launching in GBA mode on a Nintendo 3DS

How the application performs

As mentioned, a 16 MHz ARM7 processor is extremely limited by modern password-cracking standards. Even so, the application recovered the target plaintext in around 27 seconds, matching the estimate from our earlier calculation.

Successful crack of the hardcoded SHA256 hash

An important caveat is that the target password appeared in the first percentage of the wordlist, which is early enough for the device to reach it quickly. Overall, the GBA-Hashcat project is not fast, but it does not need to be when the candidate is predictable and the search space has already been narrowed. Given enough time, or enough devices working through different parts of a wordlist, the task remains computationally possible.

Weak passwords remain the real risk

SHA256 is a reasonably strong hashing algorithm, but it cannot compensate for a weak or previously exposed password. Once a credential appears in a breach corpus or common wordlist, an attacker can test likely candidates against the hash until they find a match.

GBA-Hashcat is an unusual, but effective way to display the dangers of not having strong password complexity rules and the risks of not using a breached corpus such as Specops Breached Password Protection. When credentials leak, the systems and information protected by these credentials have a half-life. If it’s possible to crack an SHA256 hash with something as underpowered as a 16MHz GBA, one can surmise what is possible in the hands of a skilled hacker with access to more powerful hardware and skills. 

When possible, organizations should implement Zero Trust principles to further protect identities, even those protected with weak passwords like hunter2. Solutions such as Specops Device Trust reduce the impact of a compromised credential by binding identities to specific devices, meaning valid credentials are insufficient by themselves as proof of trust.

A weak or leaked password can become an open door, even if the attacker uses a handheld game console. If you’re interested in strengthening your identity security and reducing the risk of compromised credentials, contact us today.