Ellipal Joy – Unboxing, Review & Hacking – Malicious Firmware, DIY Device (STM32), Firmware Flashing
The Ellipal Joy is not your usual hardware wallet. It is a small offline mnemonic generator, and it matters because if you are securing serious crypto funds, the quality of your seed generation is part of the security model. A seed phrase is effectively your wallet. If the device that creates it is compromised, poorly designed, or simply untrustworthy, then the rest of your setup can inherit that risk.
In this article, I am walking through what I covered in Watch the video: unboxing the retail Ellipal Joy, reviewing the open-source firmware, flashing custom and stock firmware using SWD, demonstrating why an offline seed generator can still be dangerous if compromised, and building a DIY version on a Nucleo board.
This is aimed at advanced users who care about trust models, supply-chain risk, and being able to verify what their hardware is actually doing. If you just want a simple wallet experience, this may be more than you need. But if you like understanding the machinery underneath your security assumptions, this one goes pretty deep.
What Is in the Box?
The retail Ellipal Joy arrives as a small plastic cube with a USB-C cable, a silicone lanyard, and instructions. That is basically it. The device itself has a display and buttons, and once you get it running, the workflow is straightforward: choose your mnemonic length, generate the seed, write it down, then import it into your wallet.

Out of the box, the device works as advertised for basic use. It supports 12, 15, 18, 21, and 24 word mnemonics. You press buttons to navigate, pick a length, generate the phrase, and then you are done. The important part is that it is designed to be offline while generating your seed.
That sounds reassuring, but I want to be clear about something early: offline does not automatically mean secure. A device can be fully disconnected from the internet and still produce predictable seeds if the firmware or hardware has been tampered with. That is a big part of why this review goes beyond “it works” and into the code, flashing process, and trust assumptions.
Hardware and Code Review: Why This Device Is Interesting
The Ellipal Joy uses an STM32 microcontroller from STMicroelectronics. What makes that relevant here is not just that it has a CPU, but that this class of MCU includes specialized hardware for true random number generation. That is the kind of thing you also see in other serious crypto hardware. You are not relying on a weak pseudo-random function pretending to be good enough.
ST also publishes ways to validate the RNG functionality using standardized test suites, which helps with confidence on the hardware side.
The firmware itself is open source, and that changes what you can do as an advanced user. You can inspect it, build it, flash your own version, compare implementations, and even run similar code on a DIY board. That is not common in this space. Most hardware wallets ask for a lot more blind trust.
The part of the firmware I care about most is the BIP39 implementation. In the Ellipal repository, the important logic is in the User area, and specifically in the BIP39 code. When you compare it with Trezor’s BIP39 implementation, the result is pretty compelling: the core logic is extremely close to a well-known, battle-tested implementation.
The main difference I highlighted is that Ellipal swapped in use of the STM32 hardware random number generator instead of relying on the same software-style random source used elsewhere. That is exactly the kind of improvement you want from an offline seed generator.

There are still small things to note. For example, the code does not check the return value of the RNG call in a way I would personally prefer for defensive programming. But on this particular STM32, the function is expected to behave correctly only if the hardware RNG is working properly, so it is not as alarming as it might be in another context.
The bigger takeaway is that Ellipal did not reinvent the wheel. They built on a known BIP39 implementation and added hardware-based randomness. That is a good sign, especially for an open-source device where you can actually verify this yourself.
Building the Firmware in STM32CubeIDE
If you want to build the firmware yourself, you need STM32CubeIDE from STMicroelectronics. You will also need an account to download it. Once installed, you can create a workspace with default settings; that is just where the IDE stores project files.
After that, you need the Ellipal Joy source code. You can get it from the official Ellipal GitHub repository, or from my fork if you want the version I used for testing and documentation. The official repo is the safest default choice unless you specifically want my extra drivers and Nucleo support.
Here is the basic build process:
- Download or clone the Ellipal Joy repository.
- Extract the source archive if you downloaded a ZIP file.
- Open the C project file in STM32CubeIDE.
- Let the IDE import the project.
- Build the project.
- Locate the generated
.hexfile in the build output folder.
That is all there is to producing firmware you can flash. The hard part starts when you try to get it onto a retail Ellipal Joy, because the USB port on that device is not a full programming interface.
Why You Cannot Just Flash It Over USB
This is where the official documentation can be misleading if you are expecting a normal developer experience. The retail Ellipal Joy has a USB-C port, but the data lines are not connected for firmware flashing. In other words, that port is effectively charge-only.
From a security standpoint, that is actually good. It means the MCU runs standalone and there is no easy data path from a compromised computer into the device through USB. From a developer or advanced user standpoint, it makes things more complicated if you want to flash your own firmware.
So to flash custom firmware on a retail unit, you need to open the device and use SWD (Serial Wire Debug). That means soldering a small header onto the board so an ST-Link can connect.
Adding SWD Access to a Retail Ellipal Joy
If you are not comfortable with soldering, stop here. This part is for people who actually want to modify and verify their own device.
The process is:
- Disassemble the retail Ellipal Joy.
- Locate the SWD pads on the board.
- Solder a four-wire header to those pads.
- Connect an ST-Link V2 programmer to that header.
Once you have done that, the device becomes much more accessible as a development target. You can flash custom firmware, restore stock firmware, and inspect what is actually running on the chip.

You can also solder serial access if you want debugging output from a USB-to-serial adapter, but for basic flashing and verification, SWD is the key.
Flashing Firmware with STM32CubeProgrammer
Once your ST-Link is connected, you use STM32CubeProgrammer to talk to the device. The workflow is straightforward in principle: connect, select firmware, program.
In practice, I hit one annoying issue that is worth mentioning because it can waste your time if you do not know about it. My cheap ST-Link clone initially showed a serial number of B and would freeze when used normally. The workaround was to enable Shared mode in the ST-LINK configuration panel, refresh, and then connect again. Once that worked, the tool could see the target properly.

From there, flashing is simple:
- Open STM32CubeProgrammer.
- Make sure the device is powered appropriately.
- Connect via SWD.
- Go to the Download tab.
- Browse to your
.hexfile from the CubeIDE build output. - Start programming.
If you run into erase failures or a locked core, do not panic. In my case, I resolved it by performing a full chip erase and then flashing again. After that, the device accepted the firmware without issue.
One useful thing about this setup is that because the retail Joy exposes SWD access after modification, you can download the stock firmware from the device itself. I put a copy of what shipped with mine on my GitHub, which matters for transparency even if full reproducible-build verification is still limited by tooling costs and practical constraints.
Serial Debugging: A Small Quality-of-Life Upgrade
If you use custom firmware that has serial logging enabled, you can connect a USB-to-serial adapter to the board and open a terminal such as PuTTY. In my setup, I used COM9 at 115200 baud on one target and COM3 on another.
This is not essential for normal operation, but it is useful if you are debugging buttons, display behavior, or firmware logic. It gives you visibility into what the device is doing when you press keys and move through menus. For a hardware project where you want to understand exactly how inputs map to actions, that kind of logging can save you a lot of guesswork.
The Malicious Firmware Demo: Offline Does Not Mean Safe
This is the part I think matters most for people who are serious about seed security.
I demonstrated a malicious firmware scenario on an Ellipal Joy where the device generates the same predictable seed every time, even when it is completely offline and unplugged from any computer. I am not going to show the exact method here, but the point is that this kind of tampering is conceptually simple if someone has physical access to the device or supply chain before you do.

A scammer does not need to make something as obvious as one repeated seed forever. They could modify a device so it only chooses from, say, 1,000 or even 1,000,000 possible seeds. A million may sound like a lot, but compared with the full space of valid BIP39 mnemonics, it is tiny. That makes it feasible for an attacker to monitor those outputs and wait until one of them holds enough value to steal.
That attack could happen days, months, or even years after the device was sold. And here is the uncomfortable part: a deterministic seed that looks random can be extremely hard to distinguish from a truly random one if you are just looking at the words.
This is why trust in the generator matters so much. If your seed comes from a malicious or incompetent source, the fact that the device never touched the internet does not save you. The damage already happened at generation time.
Building a DIY Ellipal Joy on a Nucleo Board
The second half of this project is where it gets really fun: building your own offline mnemonic generator using off-the-shelf parts.
For my DIY version, I used an STM32 Nucleo-H7A3ZI-Q board. It was the closest readily available match to the retail Ellipal Joy chip that I could find from ST. These boards are easy to obtain and cost around $30 in the video context, which makes them very reasonable for a serious DIY crypto hardware project.
The rest of the build is simple:
- Nucleo-H7A3ZI-Q board
- A few momentary push buttons
- An SSD1306 OLED display (SPI or I2C)
- Breadboard and jumper wires

The buttons emulate the inputs from the retail device. The layout is not identical, because the display hardware is different, but the functionality is there: you can generate mnemonics in the same general way as the stock device, with on-screen prompts and button navigation. One of my test buttons also simulates a “plugged in / charged” state that resets the unit on the official device.
Setting Up the DIY Firmware
The workflow for the Nucleo build is similar to the retail firmware build, but you need to use the correct project for the target board. This matters because although both devices are STM32H7-based, they are not identical. You cannot just flash retail-targeted firmware onto the Nucleo board and expect it to work. The pinout and package differences matter, and doing that can leave the device frozen.
So here is what you do:
- Use my fork or the appropriate Nucleo branch if you want the DIY setup.
- Download the repository.
- Open the correct C project in STM32CubeIDE for your target board.
- Build the firmware.
- Flash it to the Nucleo board using ST-Link.
One configuration detail is important: if you are using an SSD1306 OLED, you need to make sure ssd1306conf.h matches your display type. The default in my setup uses I2C, not SPI. If you have a different display interface, comment out the wrong option and enable the correct one before building.

Once that is set, you can run it and debug it just like any other STM32 project. The ST-Link also exposes a serial port on your system, so if your firmware has logging enabled, you can open PuTTY or another terminal program, select the correct COM port, set 115200 baud, and watch button events and boot messages in real time.
Why the DIY Version Is Interesting From a Trust Perspective
The retail Ellipal Joy is already more transparent than most hardware wallets because it is open source. But the DIY version goes one step further: you are not just trusting open-source software, you are also using open-source hardware that you assembled yourself from parts you bought directly.
That changes the trust model in a meaningful way. With a closed wallet, you have to place a lot of faith in the vendor’s manufacturing process, firmware, supply chain, and integrity. With an Ellipal Joy, at least you can inspect the code and flash your own firmware. With a DIY Nucleo build, you reduce even more of that blind trust because you control the physical assembly too.
There is another practical benefit: buying a generic dev board does not announce to anyone that you are building crypto hardware. That may matter if you care about operational privacy during procurement.
Open Source Is Powerful, But It Is Not Magic
I want to be careful here, because open source can make people feel safer than they actually are. The Ellipal Joy is a good example of why transparency helps, but it does not remove all risk.
Open source lets you:
- inspect the firmware
- build your own version
- compare implementations against known-good code
- flash trusted firmware yourself
- verify that the chip is what you expect
- reduce reliance on vendor claims
But it does not automatically stop someone from:
- selling tampered devices
- modifying firmware in the supply chain
- creating a device that looks legitimate but generates predictable seeds
That is why provenance still matters. If you buy an Ellipal Joy, buying directly from Ellipal is the obvious first step. Security seals help a little, but they are not a complete answer. The stronger move is to open the device, check the hardware, and flash firmware you built yourself if you want maximum trust.
There is also a realistic limitation: firmware builds may not be fully reproducible in every environment, and deep verification of shipped binaries can require expensive tooling. I could not justify spending thousands of dollars on decompilation tools just to verify every byte of the stock firmware myself. But the important point remains: if someone, including Ellipal, were to ship malicious firmware, there would still be a way for an advanced user to inspect what is actually on the device. That is far better than a closed-source black box where you are simply asked to trust the vendor completely.
Who Should Use This?
The Ellipal Joy makes sense if you want a fast, secure way to generate seed phrases without relying on your wallet vendor’s generation process and without resorting to dice-based entropy collection. If you write the generated mnemonic to paper or steel first, then import it into your hardware wallet, you also get the benefit of verification as you enter it.
It is especially useful for people who want:
- an offline seed generator
- open-source firmware
- a device that can be flashed and inspected
- a path toward a more trustless setup
- an advanced DIY option using common STM32 hardware
If you just want a plug-and-play wallet with minimal tinkering, this may still be more work than you want. But if you are the type of person who wants to understand exactly what your crypto security depends on, this is one of the better options I have seen from Ellipal so far.
Conclusion
The Ellipal Joy is an interesting step for a company that has previously offered much more closed products. It gives advanced users something valuable: visibility. You can look at the BIP39 code, see that it closely follows a known Trezor-derived implementation, confirm hardware-based randomness on STM32, flash your own firmware over SWD, and even build a DIY version on a Nucleo board.
At the same time, this project also makes a broader point: open source is powerful, but supply-chain risk still exists. A device can be offline and still dangerous if its seed generation has been compromised before you ever use it. The best defense is not just “trust me,” it is a setup where you can inspect, rebuild, flash, and verify as much of the chain as possible.
If you want to go deeper with hands-on steps, screenshots, and the full demo, watch the video linked at the top. And if you have questions about the retail device, the DIY build, firmware flashing, or seed-generation trust models, leave a comment. I try to answer what I can, especially when it helps people make safer crypto decisions.
Questions from viewers
Common questions from the comments on this video, with my answers.
Can I recover my wallet seeds from a factory-reset iPhone using BTCRecover?
No. If you perform a factory reset on your device, all data is permanently deleted and there is nothing left to recover. This applies regardless of whether you are using an Android or iOS device; if you do not have a seed backup, wiping the phone means your funds are gone. If you’d like hands-on help, see wallet recovery services.
How can I manually calculate the last checksum word of a BIP39 mnemonic phrase?
The first words in a mnemonic simply represent 11-bit indices from the word list. The final word includes a checksum that requires a SHA-256 operation, which is very difficult to do by hand. If you want to generate a seed manually without software, your best option is to use a BIP39 dice list to select the first 11 words, then try random 12th words until one validates correctly (which has a 1/16 chance for a 12-word seed).
Do hardware wallets like Trezor ship with full firmware installed, or just a bootloader?
Trezor devices ship with a minimal bootloader flashed on them, but they require you to load a separate official firmware file to get full functionality. While the official bootloader and firmware are signed and work together, this model does mean that malicious actors could theoretically ship devices that direct users to load lookalike or compromised software.
Are there open-source hardware wallet alternatives to closed-source offline generators?
Yes. You can build a Trezor from scratch, which involves using open-source hardware and firmware. Another option is using tools like SeedSigner. It is odd that some retail devices are produced as closed systems when open-source alternatives exist that allow you to verify the entropy source yourself.
How do I use a KeepKey hardware wallet for U2F two-factor authentication on websites?
KeepKey works out of the box for any website supporting U2F. You generally do not need to unlock the device; you just plug it in and press the button when prompted, similar to how a Yubikey functions.
Why doesn't the Ellipal Joy allow me to input my own entropy, such as coin tosses?
It is a shame that Ellipal did not add features allowing users to introduce their own entropy sources like coin tosses or dice rolls. However, if you have the technical expertise, you can modify the firmware yourself to add these capabilities since the hardware and code are accessible.
Choosing a hardware wallet?
See how this device stacks up against the others I’ve tested: security model, supported coins, backup options and price.
Some links on this site are affiliate links: if you buy through them I may earn a commission at no extra cost to you. It doesn’t change what I recommend.
Found this useful?
These guides are free and ad-free. You can support them by sharing them, subscribing on YouTube, or sending a tip.







