Buy
FOR SKEPTICS · AND EVERYONE ELSE

Don’t trust the seal. Check the bytes.

Every claim on this site is checkable. This page is how.

The three layers

  1. The seal. Your stick arrives in a tamper-evident bag. If the seal is broken or looks re-applied — don’t use it, contact us for a replacement. The seal deters casual tampering; it is not the proof.
  2. The hash. The stick’s entire contents can be fingerprinted with SHA-256 and compared against the official fingerprint published below. If even one byte were altered, the fingerprints would not match. This defeats any tampering — a counterfeit stick, a swapped image, an intercepted shipment — by anyone, anywhere in the supply chain, including us. Publishing the fingerprint reveals nothing about our code: it is a one-way fingerprint, not a blueprint.
  3. The audit. The entropy path — the code that creates your randomness — is independently reviewed before we ship. The hash proves your stick is authentically ours; the audit proves ours is sound.

Official release fingerprint

koinikeystick-v1.0-rc2.iso  ·  14,137,344 bytes  ·  SHA-256
7d90019cdc40632ab53a3b0ea218904229b4c29dd3ba71ad1965a1025cd413a0

Independently audited and signed 29 August 2026. This is the only image we ship. Every stick we seal was flashed from this image, then read back and re-hashed before it went into the bag — a stick that did not match was never sealed. Fingerprints are always shown here in full: anyone who shows you a truncated hash is asking you to trust the part you cannot see.

What exactly to hash

Hash the stick’s contents, not its partition table. The first 32,768 bytes of any USB stick hold its partition table. Windows rewrites a few of those bytes the moment a stick is plugged in — it stamps its own disk signature there — silently, on every stick, whether or not the stick is ours. That area is not part of our software. So the check skips it and hashes everything after it: bytes 32,768 through 14,137,344 of the raw stick, which is the entire boot image, byte for byte. Hashing the whole stick will not match, because the stick is physically far larger than the image. Hashing from byte 0 on a stick Windows has touched will not match either. Neither is a fault.

stick fingerprint  ·  bytes 32,768 – 14,137,344 of koinikeystick-v1.0-rc2.iso  ·  14,104,576 bytes  ·  SHA-256
23530e069c0ba0c220523549886a40a88477934308b6698b443f0c68e3384486

This is the fingerprint every command below should print. It is derived from the signed release image above by skipping its first 32,768 bytes; the release fingerprint itself is unchanged and remains the signed artifact of record. Nor can you hash the files you see when the stick is mounted — the fingerprint covers the raw image, not the files inside it. Every command below reads the raw device. None of them writes anything, to the stick or to your computer.

macOS. Find the stick with diskutil list external physical, then replace 4 with your disk number:

diskutil unmountDisk /dev/disk4
sudo dd if=/dev/rdisk4 bs=512 skip=64 count=27548 2>/dev/null | shasum -a 256

Linux. Find the stick with lsblk, then replace sdb with your device:

sudo dd if=/dev/sdb bs=512 skip=64 count=27548 2>/dev/null | sha256sum

Windows. Open PowerShell as Administrator. First, find your stick’s disk number:

Get-Disk | Select-Object Number,FriendlyName,@{N='SizeGB';E={[math]::Round($_.Size/1GB,2)}} | Format-Table -AutoSize

Find your KŌINIkeystick in that list — it’s the small USB drive, a few GB in size. Put its Number on the first line below, in place of the 2, then paste the whole block:

$Disk = 2
$Skip = 32768
$Size = 14104576
$ok = $false
if (-not (Get-Disk -Number $Disk -ErrorAction SilentlyContinue)) {
  Write-Host "STOP: no disk numbered $Disk. Re-check the list above." -ForegroundColor Red
} else {
  try { $fs = New-Object System.IO.FileStream("\\.\PhysicalDrive$Disk",'Open','Read','Read'); [void]$fs.Seek($Skip,'Begin'); $ok = $true }
  catch { Write-Host "STOP: could not open that disk. Confirm PowerShell is running as Administrator." -ForegroundColor Red }
}
if ($ok) {
  $sha = [System.Security.Cryptography.SHA256]::Create()
  $buf = New-Object byte[] 1048576
  $left = $Size
  while ($left -gt 0) { $n = $fs.Read($buf,0,[Math]::Min($buf.Length,$left)); if ($n -le 0) { break }; [void]$sha.TransformBlock($buf,0,$n,$null,0); $left -= $n }
  [void]$sha.TransformFinalBlock((New-Object byte[] 0),0,0)
  $fs.Close()
  if ($left -gt 0) { Write-Host "STOP: only read part of the stick. No fingerprint shown because it would not be valid." -ForegroundColor Red }
  else { -join ($sha.Hash | ForEach-Object { $_.ToString('x2') }) }
}

Honest note on that last one: the macOS and Linux commands are the exact commands we run on every stick before we seal it. The Windows script does the same work using only what already ships with Windows, and skips the same 32,768 bytes. If you see a red STOP message, it means the disk number was wrong or the stick wasn’t reachable — go back and re-check the list above; it is not a sign of a bad stick, and no fingerprint is shown in that case because it would not be valid. If it still gives you any trouble, email support@koini.io and we will check the stick with you.

What a match proves — and what it does not

A match proves the stick in your hand carries the exact image we published and an independent reviewer audited: byte for byte, nothing added, nothing swapped, by anyone anywhere between our bench and your desk.

It does not prove the computer you ran the check on is clean. A compromised computer can lie to you about anything, including this. Run the check on a computer you trust, and read it alongside the seal on the bag — the seal tells you nobody opened the package, the fingerprint tells you nobody altered what is inside it.

If the fingerprint does not match, stop. Do not boot the stick, and do not put funds on any address it produces. Email support@koini.io and we will replace it.

Advanced: check that this fingerprint came from us

The fingerprint above is only as trustworthy as the page you are reading it on. To close that gap, the release is signed with minisign. Download SHA256SUMS and SHA256SUMS.minisig, then check them against our public release key:

minisign -Vm SHA256SUMS -P RWTQq5m6CAPnRJgigdBkgm2FBwUiID14NPuW5yr8HaxlyXTcwH5cgBDu

A good signature means that fingerprint was produced by the holder of our release key — not by whoever served you this page.

Verifying the Mac edition

The Mac edition is an app, not a bootable image, so it proves itself a different way: it is signed by Koini Global LLC and notarized by Apple. When you open it and it launches with no warning, macOS has already confirmed it is genuinely ours and has not been altered. If macOS ever warns that the app is damaged, unverified, or from an unidentified developer, do not use it — email support@koini.io.

For belt-and-suspenders assurance, the Mac disk image carries its own published fingerprint:

KOINIkeystick-Mac.img  ·  SHA-256
2cbd64703f088e259d85edd9451be29e82e1b4b26cc0558213e67a4f484a7287

The Mac edition is a separate product with its own fingerprint; the bootable image’s fingerprint above is unaffected.

Why the code stays closed

KŌINIkeystick is a commercial product, not an open-source project. Keeping the operating system closed means no one can clone it, counterfeit it convincingly, or ship a tampered fork under our name. You don’t need the source to trust the stick — you need proof the stick is genuine and proof the generator is sound, and you have both: the published hash confirms authenticity, the independent audit confirms correctness, the seal confirms it reached you untouched. Guard your stick like the tool it is; if it’s ever lost or the seal is broken, replace it.

READ-ONLY EDITION NOTEThe write-protect switch on the read-only edition ships in the locked position, set after our verification. The switch means no computer can ever alter the stick’s contents — but verify the hash anyway. That’s the whole ethos: check, don’t trust.