,

Verify Wallet Downloads with SHA-256, GPG & Sparrow

“Don’t trust, verify” is a common motto in self-custody, but it only means something if you actually know how to check the software you are running. Downloading from an official website is not enough by itself. Wallet software and firmware are high-value targets for scammers, so I like to use more than one layer of verification before installing anything that touches my funds.

In this article, I’ll walk through the practical process shown in Watch the video: checking SHA-256 checksums, using social verification where it helps, manually verifying Sparrow with GPG4Win/Cleopatra, and then using Sparrow’s built-in download verification feature to check many other wallet and hardware releases. I’ll also cover Electrum’s multi-signer GPG workflow and Windows code signing as extra checks.

A GitHub repository file viewer showing a compromised monero CLI binary incident
Why verifying downloads matters: malicious binaries do happen.

Why “official website” is not enough

An official website can be compromised, spoofed, or served through a bad CDN. A browser may show HTTPS, and Windows may show a signed installer, but those checks do not prove that the file you downloaded is exactly what the project intended to publish.

For self-custody software, I want two things:

  1. Integrity: Did the file change in transit?
  2. Authorship: Is this really from the people who maintain the project?

SHA-256 checksums help with integrity. GPG signatures can help with authorship when you have properly verified the signer’s public key. Social verification is not magic, but it can be useful as part of a broader trust process.

What SHA-256 checksums do and do not prove

A SHA-256 checksum is like a fingerprint for a file. You feed the file into the algorithm, and it produces a long hash value. If even one byte changes, the checksum changes dramatically. The same file should always produce the same SHA-256 value.

In the video example, I downloaded Foundation Passport firmware v2.3.1 from its GitHub release page. The release listed the expected SHA-256 hash for the firmware binary. On a fresh Windows 11 machine, I could compute the local file’s hash without installing extra tools by using PowerShell and certutil.

Checksum verification on Windows

Here is the basic flow:

  1. Download the file from the project’s official release page.
  2. Open File Explorer to the folder containing the downloaded file.
  3. Right-click in an empty area and open a terminal/PowerShell window there.
  4. Run the hash command for the file.
  5. Compare the result with the checksum published by the project.

For the firmware file, the command pattern is:

certutil -hashfile v2.3.1-passport.bin SHA256

The output should match the expected value shown on the release page.

Windows PowerShell showing certutil computing the SHA-256 of the Passport firmware
Computing the local SHA-256 hash with Windows PowerShell.

If the hashes match, that is good: your file appears intact relative to what was published. But this still does not prove who created the file. If an attacker controlled both the download and the checksum page at the same time, a matching checksum could be misleading. That is why I like to check against multiple independent sources when possible.

Checking checksums on another device: Foundation Passport example

One useful trick is to compute the checksum on a different system or even a simpler device. In the video, I copied the firmware file to a micro SD card and inserted it into a Foundation Passport. From the device menu, I could list files from the SD card and generate a SHA-256 digest independently of my PC.

Split-screen comparison: Windows PowerShell hash on left, Foundation Passport SHA-256 output on right
The same firmware file produces the same SHA-256 on two different systems.

This helps confirm that you are looking at the same file across multiple environments. It can also be useful for DIY hardware like SeedSigner, where you should verify firmware before running it. Retail devices such as Foundation Passport may do their own internal verification before flashing, but checking externally is still a good habit when learning these processes.

The limits of social verification

A matching checksum does not tell you who made the file. If you want more confidence, you can ask people you trust what they see. For example:

  • Ask in a trusted community whether their hash matches yours.
  • Compare with someone who has already done deeper GPG verification.
  • Check multiple official channels if available.
  • Use another device to recompute the hash.

Social verification is not perfect. People can be mistaken, accounts can be compromised, and communities can be manipulated. But it adds a practical layer: you are no longer relying only on one website saying “this file is correct.”

For me, social checks are best used alongside technical checks, not instead of them.

GPG verification: adding authorship assurance

GNU Privacy Guard, or GPG, lets you verify that a file was signed by someone who controls a known private key. The public part is the signer’s public key; the secret part stays with the signer. When you verify a signature, you are checking whether the file matches the signature and whether it came from a key you trust.

The hard part is not running GPG. The hard part is making sure the public key you import really belongs to the person or project you think it does. That is where certification comes in.

Installing GPG4Win on Windows

For this walkthrough, I used GPG4Win, which provides a Windows-friendly version of GNU Privacy Guard plus Kleopatra, a certificate manager with a graphical interface.

  1. Go to the official GnuPG/GPG4Win download area.
  2. Download the latest installer.
  3. Run the installer.
  4. Check the Windows User Account Control prompt for the verified publisher and file origin.
  5. Install with defaults if you are comfortable with that initial trust decision.
Windows UAC dialog showing Gpg4win installer publisher details
Checking the code signing information before installing GPG4Win.

There is a chicken-and-egg problem here: to verify GPG itself, you need some existing trust anchor. In this case, I relied on Windows checking the signed installer and comparing the certificate details against published documentation. That is not perfect either, but it is a reasonable starting point for many users.

After installing, open Kleopatra. The next step is to create your own local key pair. This key will be used to certify other public keys that you import later. The name and email can be anything because this is only for your local trust system. You should set a passphrase so that certifying new keys requires an extra confirmation step.

Verifying Sparrow manually with GPG4Win

Sparrow Wallet publishes files that can be verified using GPG signatures. In the video, I used Sparrow 2.1.2 as the example. The process involves downloading several related items:

  • The Sparrow installer file
  • The manifest file listing SHA-256 checksums for release files
  • The signature for the manifest
  • The public signing key of the Sparrow maintainer, Craig Raw

Importing and certifying the signer key

  1. Find the correct public GPG key from an official or cross-checked source.
  2. Save the ASCII-armored public key file to your computer.
  3. In Kleopatra, import the public key.
  4. Before certifying it, compare its fingerprint against independent references.
  5. Certify the key with your local Kleopatra key if you are satisfied.
Craig Raw’s X/Twitter profile showing a GPG fingerprint for cross-checking
Cross-checking the imported public key fingerprint against a public profile.

In this example, I compared the imported key with the fingerprint shown on Craig Raw’s public social profile. That is not proof by itself, but it helps confirm that the key has been publicly associated with the maintainer over time. The more independent references you can check, the better.

Once certified, the key changes from “not certified” to “certified” in Kleopatra. That means your local system will treat signatures made with that key as trusted.

Verifying the manifest signature

Next, verify the signed manifest file:

  1. Right-click the manifest file in File Explorer.
  2. Use the GPGEX verification option.
  3. Confirm that the signature is valid and matches the expected signer.
Kleopatra showing a valid signature for the Sparrow manifest
The manifest signature verifies successfully against the certified Sparrow signing key.

A valid manifest signature tells you two useful things:

  • The manifest file was not altered after signing.
  • It was signed by the key you have chosen to trust for this project.

After that, I opened the manifest and saw a list of SHA-256 checksums for the Sparrow release files. Then I returned to PowerShell and computed the hash of the actual installer file I downloaded. If the local hash matches the hash in the signed manifest, I can be much more confident that the installer is intact and comes from the expected release.

Using Sparrow’s built-in download verification feature

Once Sparrow is installed, it has a very useful built-in feature: Tools → Verify Download. This lets you verify downloads without manually running GPG commands each time.

Sparrow Verify Download dialog showing a successful check
Sparrow’s built-in verification confirms the download is signed and matches the manifest.

In the video, I used this feature to re-check the Sparrow installer itself. It verified that the file was signed by the expected maintainer and matched the expected hash. The nice part is that it does this in a self-contained way without requiring you to manually use GPG4Win for every check.

Sparrow also bundles public keys for other projects, which makes it possible to verify many useful releases directly from Sparrow. In the video example, I verified Foundation Passport firmware using its signature file and the bundled Foundation Devices signer key.

Sparrow verifying Foundation Passport firmware with a bundled project signing key
Verifying third-party firmware inside Sparrow without extra GPG setup.

This is one of my favorite features because it lowers the barrier to doing useful verification more often. You can check releases for projects such as SeedSigner, Trezor, BitBox02, Coldcard, and others that support this workflow, depending on what signatures and keys are available or imported.

You can also import additional public key bundles into Kleopatra if you want to manage them separately. In the video, I mentioned importing a bundle of public keys from Sparrow’s GitHub repository. That lets you add many project signing keys at once. You still need to certify each one appropriately, but it gives you a convenient starting point for comparing fingerprints and building your local web of trust.

Verifying Electrum with multiple signers

Electrum uses a slightly different approach: its releases are signed by multiple people. This is useful because if one signer’s key were compromised or leaked, the other signatures can still help identify legitimate release files.

In the video example, I verified Electrum 4.5.8 for Windows using GPG4Win/Kleopatra.

Basic Electrum verification steps

  1. Go to the official Electrum download page.
  2. Download the installer file for your platform.
  3. Download the signature file for that installer.
  4. Import the relevant signing public keys into Kleopatra.
  5. Certify each key after checking its fingerprint against reliable references.
  6. Right-click the installer and verify it with GPGEX.

At first, verification may show problems because you do not yet have all required signing keys or have not certified them. That is expected. You need to import the public keys for the signers associated with that release.

Kleopatra showing imported Electrum signing keys before full certification
Imported Electrum signer keys still need social verification and certification.

For each key, I checked public references where possible. In one case, a Bitcoin Talk thread helped confirm that a particular fingerprint had been associated with an Electrum signer over time. In another case, the same public key appeared in both the Electrum download materials and the Sparrow public key bundle, which added useful corroboration.

After importing and certifying the relevant keys, I verified the installer again. This time Kleopatra showed that all signatures were valid.

Kleopatra showing three valid signatures for the Electrum installer
The Electrum installer passes verification with multiple certified signers.

That is a strong result: the file was intact, and it matched signatures from multiple independent release signers that I had chosen to trust.

Windows code signing as an extra layer

Some installers also use Windows code signing certificates. For example, when installing Electrum, Windows can show information about the certificate publisher. This does not replace GPG verification, but it adds another layer of protection.

I still recommend checking the signature details and comparing them with what you expect from official documentation. A signed installer is better than an unsigned one, but code signing alone should not be your only check for wallet software.

Practical checklist I use before installing wallet software

Here is a simple version of the process I follow:

  1. Download from the official project page
    Avoid random mirrors unless you have a strong reason and independent verification.

  2. Check SHA-256 checksums
    Compare your local file hash with published hashes, ideally on more than one system if possible.

  3. Use GPG signatures when available
    Verify the signature for the installer or manifest using the project’s signing key.

  4. Certify keys carefully
    Do not certify a public key just because it is convenient. Compare fingerprints across official pages, long-standing social profiles, forums, and trusted communities where appropriate.

  5. Use built-in verification tools when they exist
    Sparrow’s Verify Download feature makes this much easier for many projects.

  6. Treat Windows code signing as extra evidence, not the whole story
    It can help, but it is not a substitute for project-specific signatures.

Conclusion

Verifying wallet downloads takes more effort than clicking “Download” and running an installer. But that extra effort is exactly what separates careful self-custody from careless downloading. SHA-256 checksums give you integrity checking. GPG signatures can give you authorship assurance when the keys are properly verified. Social checks help connect public keys to real maintainers, though they should be used with judgment.

The best part of modern wallet ecosystems is that some tools make this easier for regular users. Sparrow’s built-in download verification feature is a great example: it lets you check not only Sparrow itself but also many other hardware and software releases without needing to become an advanced GPG user every time.

If you are using self-custody wallets, I strongly encourage you to practice these steps before you need them. The goal is not paranoia for its own sake. The goal is confidence: when you install wallet software or flash firmware, you want to know that what you downloaded is really the file the project intended to publish.

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.

Stuck on this?

Book a one-hour session and I’ll walk you through it, or ask about a trusted recovery.

Recovery guides

More guides