Over the last couple of years, I have been doing a lot of work on ShieldSigner, a fork of SeedSigner. A big part of what makes this fork useful is that it combines familiar DIY hardware with ordinary smart cards — the kind of secure element you already see in passports and credit cards.
That opens up some interesting options: you can use one JavaCard for TOTP second-factor authentication, PIN-protected seed storage, on-card Bitcoin signing, OpenGPG key protection, bearer-style Bitcoin transfers, and more.
In this article, I will walk through the bundled ShieldSigner JavaCard applets, what each one is actually good for, and how to install them using a Luckfox Pico-based ShieldSigner device. If you want to see the full walkthrough, Watch the video.
Hardware Overview
For this setup, I am using a Luckfox Pico 1 based ShieldSigner with an integrated smart card reader on the bottom edge. This particular unit is running secure boot and has verified the microSD card before booting. If you are building your own setup, you can use something like the LuckFox Pico Mini or a complete kit such as the ShieldSigner+ Display Hat, Smartcard Reader & USB-C Power for Luckfox Pico.

I am using a blank J3H145 JavaCard. These are the same cards I sell in my web store, but you can also buy them from other established smart card vendors or in bulk from suppliers such as Fetian. The J3H145 Javacard is a good option if you want to avoid guessing whether a random AliExpress or Amazon card will actually work with the applets you need.
One important note: some blank DIY JavaCards, such as certain Satochip cards based on the J3R180, can run many of these applets too. But Specter DIY is an exception to watch out for. More broadly, buying random smart cards from marketplaces can be a minefield. If you want reliability, buy from a vendor who knows what they are selling.
Once the device has booted, insert the card contact-up into the reader and open:
Tools → Smartcard Tools
That menu is where most of the action happens for installing and managing JavaCard applets.
VivoKey OTP: A YubiKey-Compatible TOTP Token
The first applet I will show is probably useful to the largest number of people: VivoKey OTP. It turns a JavaCard into something like a YubiKey-compatible TOTP token, so you can use it with apps such as Yubico Authenticator for hardware-backed second-factor authentication.
This is useful for securing email, social media, cloud accounts, and other services that support TOTP. The key point is that the secret lives on the card, not just in a phone app or browser profile.
Install VivoKey OTP
- Insert the blank JavaCard into the ShieldSigner smart card reader.
- Go to Tools → Smartcard Tools.
- Select Install Applet.
- Choose the VivoKey OTP applet.
- Wait for installation to complete.

Enroll the card in Yubico Authenticator
Once installed, you can use it with a phone:
- Open Yubico Authenticator.
- Tap Add account.
- Scan the QR code for your TOTP account.
- Save the account details on screen.
- Tap the JavaCard against the phone’s NFC reader when prompted.

When you tap the card, it generates a fresh TOTP value. If you wait for the current value to expire, the phone will not refresh automatically; you need to tap the card again to get the next code.
That is a simple but powerful use case: one cheap smart card can become a hardware-backed second-factor token for many online accounts.
SeedKeeper: PIN-Protected Storage for Seeds and Passwords
The next applet is probably the most common way people will use these cards: SeedKeeper. It lets you use a JavaCard as a PIN-protected place to store things like mnemonics, descriptors, wallet scripts, passwords, and other secrets.
There are two SeedKeeper variants in ShieldSigner: one with NDEF in the name and one without. The difference matters for phone interaction.
What the NDEF version does
The NDEF variant includes a small record on the card that tells your phone which app to open when you tap it. So if you install the NDEF-enabled SeedKeeper applet, tapping the card against an Android phone can automatically launch the SeedKeeper app.
If you install the non-NDEF version, tapping the card may do nothing by itself. You would still need to open the app and use its scan or read function manually. But once inside the app, the card works the same way.
Install SeedKeeper
- Insert a blank JavaCard into ShieldSigner.
- Go to Tools → Smartcard Tools.
- Select Install Applet.
- Choose either: – SeedKeeper with NDEF, if you want tap-to-open on compatible phones; or – SeedKeeper without NDEF, if you do not need that behavior.
- Choose the storage size you want to allocate.
If you select more storage than the card supports, installation will fail. In the video, I leave it at the default of 8 kilobytes.

What you can store
With SeedKeeper, you can use the card as:
- A PIN-protected backup for BIP39 mnemonics.
- A place to store descriptors or other wallet-related secrets.
- A hardware-backed password manager for service passwords.
- A recovery mechanism if you lose access to your ShieldSigner device but still have a phone and the card.
This is one of my favorite uses because it gives you a physical, PIN-gated object that can hold sensitive data without relying on a computer or cloud account.
That said, I want to be clear: if you are storing real mnemonics on SeedKeeper cards, do not casually load them into the phone app unless you are in an actual recovery situation or otherwise need access through the phone. The whole point is that the secret stays protected on the card and requires deliberate action to use.
If you ever find yourself in a difficult recovery situation involving seeds, devices, or compromised setups, my recovery services and consultations page covers how I can help.
Satochip: On-Card Bitcoin Signing
The next two applets are different from the previous ones because you load a seed onto them, but after that, transaction signing happens on the JavaCard itself.
The first is Satochip. This turns the card into a self-contained Bitcoin signer. Once your private keys are imported into the card, they do not need to leave it for normal signing operations.
Install and initialize Satochip
- Insert the JavaCard into ShieldSigner.
- Go to Tools → Smartcard Tools.
- Select Install Applet.
- Choose the Satochip applet.
- Once installed, open Satochip Functions.
- Initialize the card.
- Set a device PIN.
- Import your seed and optional passphrase.
After that, you can use the card with ShieldSigner to sign transactions without exposing the private keys outside the secure element. You can also use the card directly with software such as Sparrow Wallet, but in that case it behaves more like a blind signer: you review transaction details on-screen or elsewhere, and the card signs them.
The key security benefit is that the signing happens inside the JavaCard. The private keys are not sitting loose on your computer or phone.
Keycard Applet and Duress PIN
The Keycard applet is very similar to Satochip: it turns a JavaCard into a self-contained Bitcoin signer. But there are two important differences.
First, it works seamlessly with the Keycard Shell device. The retail Keycard Shell comes with certain cards, but you can also use DIY JavaCards if you install the correct applet first. A blank card inserted into the shell will not be recognized as a valid Keycard until it has been provisioned properly.

Second, Keycard adds a duress PIN. That is useful if you ever need to sign something under pressure but do not want to expose your real seed or main signing identity. The duress PIN can be used for a separate, less sensitive purpose, depending on how you set it up.
Install and use Keycard
- Insert the JavaCard into ShieldSigner.
- Go to Tools → Smartcard Tools.
- Select Install Applet.
- Choose the Keycard applet.
- If needed, enable Keycard support in Settings under Advanced.
- Use Keycard Functions on ShieldSigner to configure the card.
- Alternatively, remove the card and set it up inside a Keycard Shell device.
Like Satochip, this is signer-only. You cannot pull the seed words or passphrase back out of the JavaCard after setup. It is not a replacement for your seed backup; it is a secure signing tool that uses keys stored on the card.
Specter DIY Mnemonic Storage
The Specter DIY applet is simpler than SeedKeeper, but it has a very specific job: store exactly one BIP39 mnemonic on a JavaCard so you can use it with a Specter DIY device or ShieldSigner.
This is not the broad storage option that SeedKeeper provides. It does not support seed plus passphrase in the same way, and it stores only one mnemonic. But if your goal is to have a small, PIN-protected hardware-backed card for a single wallet, this is clean and practical.
Install Specter DIY
- Insert the JavaCard into ShieldSigner.
- Go to Tools → Smartcard Tools.
- Select Install Applet.
- Choose the Specter DIY applet.
- Wait for installation to complete.

Store a mnemonic on the card
- Open the relevant Specter DIY or smart card tool menu in ShieldSigner.
- Select the option to save a seed to the JavaCard.
- Set a PIN for the card.
- Enter the mnemonic you want to store.
- Confirm the save operation.
Once saved, you can insert the card into a compatible device and log in with the PIN. The device can then load keys from the smart card.
This is useful if you want a dedicated physical token for one wallet. It is less flexible than SeedKeeper, but it is straightforward and works well with Specter DIY-style setups.
One practical note: Specter DIY does not always coexist smoothly with other applets on the same card. In the video, I had to free up space before installing another applet because of this. If you are planning multiple uses for one card, test your combinations and keep track of what is installed where.
SmartPGP / OpenGPG Card
The next applet is more niche, but it is very powerful: SmartPGP. It turns the JavaCard into an OpenGPG-compatible security token.
These particular J3H145 cards support RSA 4096. Some other JavaCards may only support weaker key sizes such as RSA 2048, so if you are using SmartPGP for serious signing or encryption work, check what your card actually supports before committing to a setup.
Install SmartPGP
- Insert the JavaCard into ShieldSigner.
- Go to Tools → Smartcard Tools.
- Select Install Applet.
- Choose the RSA 4096 SmartPGP applet if your card supports it.
- Wait for installation to complete.
If the card was previously used by another applet, you may need to reset or free up space first. In the video, I had to clear some previous applets before SmartPGP installed cleanly.
Use it with an Android GPG app
Once installed, the card can be used as a security token with apps such as OpenKeychain on Android:
- Open your GPG app.
- Choose to use a security token.
- Tap the JavaCard against the phone’s NFC reader when prompted.
- Generate or import a key onto the card.
- Keep the public key available for others, but keep signing and encryption operations on the card.

You can generate keys directly on the card or use compatible tooling to create them elsewhere and store them there. The important part is that the private key material stays protected by the secure element.
This is the same general idea people use when signing software releases, Sparrow builds, SeedSigner firmware, or other crypto-related artifacts with GPG keys — except instead of trying to protect a long-term signing key on an ordinary computer, you can put it on a hardware-backed card.
For most people, this may be overkill. But if you already use GPG for release signing, encrypted communication, or identity verification, this is a genuinely useful upgrade.
Satodime Bearer Cards
The final applet I will cover is Satodime. This one works differently from the others because it creates bearer-style cards. The card generates its own private key on-card, and you can provision slots that hold Bitcoin addresses tied to keys stored securely inside the JavaCard.
The idea is simple: generate a key on the card, seal an address in a slot, then physically give the card to someone else. Whoever holds the card can claim or redeem the funds associated with that slot, subject to the applet’s rules and PIN/ownership flow.
Install Satodime
- Insert the JavaCard into ShieldSigner.
- Go to Tools → Smartcard Tools.
- Select Install Applet.
- Choose the Satodime applet.
- Wait for installation to complete.

Provision and use a bearer card
You can then:
- Provision key slots on the card.
- Claim ownership of a slot.
- Transfer ownership to another person.
- Use the Satodime mobile app to tap the card and view or interact with addresses.
- Redeem funds from a sealed slot if you are authorized to do so.
This can be useful between trusted people: for example, giving someone physical custody of Bitcoin without giving them access to your main wallet or seed.
Important warning about DIY Satodime cards
I want to be very clear here: Satodime is the applet where I would least recommend using unverified DIY cards when receiving funds from strangers.
If you accept a DIY Satodime card from someone, that person could theoretically have tampered with the installed applet in a way that lets them see or compromise private keys associated with sealed slots. That makes this use case much more sensitive than simply storing your own seed on a card you personally provisioned.
If you want to accept bearer cards from other people, especially strangers, I would strongly prefer a verified retail Satodime card rather than a DIY one. Between trusted friends or family, it can still be useful, but do not treat an unverified third-party DIY card as if it were the same as a vetted product.
Conclusion
The biggest takeaway from all of this is that ShieldSigner turns ordinary JavaCards into surprisingly flexible secure elements. One card can do several different jobs depending on which applet you install:
- VivoKey OTP for TOTP second-factor authentication.
- SeedKeeper for PIN-protected storage of seeds, descriptors, and passwords.
- Satochip for on-card Bitcoin signing.
- Keycard for self-contained signing with a duress PIN and Keycard Shell support.
- Specter DIY for storing one BIP39 mnemonic on a card.
- SmartPGP for OpenGPG-compatible key protection.
- Satodime for bearer-style Bitcoin cards, with an important trust warning.
This is not an exhaustive list of every JavaCard applet that exists. There are other useful projects out there, including resources from the FlexSecure community if you want to explore more advanced or unusual secure-element uses. But for most DIY crypto users, these bundled ShieldSigner applets give you a practical way to add hardware-backed security without building an exotic device from scratch.
If you have questions about any of these applets — installation, compatibility, recovery use cases, or whether a particular card is safe for your setup — leave a reply in the comments. I do my best to answer them all.
Stuck with a wallet recovery?
I maintain BTCRecover and have helped people recover seed phrases, passphrases and wallet passwords since 2019. Book a one-hour video session and I’ll walk you through doing the recovery yourself, without sharing your seed. Or, if you’d rather I run it, a trusted recovery is charged only if it succeeds.
Private sessions: US$100 per hour. Trusted recovery: 10% of recovered funds. I never contact people first and will never ask for your seed phrase over chat or email.
Found this useful?
These guides are free and ad-free. You can support them by sharing them, subscribing on YouTube, or sending a tip.







