Why this is on everyone's mind right now

In the US, voter ID has moved from a talking point to an active legal fight. In March 2025, an executive order requiring documentary proof of citizenship for voter registration was signed, then permanently blocked by a federal court in January 2026, on the grounds that the Constitution leaves election administration primarily to the states. In February 2026, with the SAVE America Act stalled in the Senate, the same push returned: a promise that there would be voter ID for the midterms "whether approved by Congress or not." A second executive order, Executive Order 14399, followed on March 31, 2026, and it too is now tied up in litigation, with a coalition of state attorneys general arguing that neither the president nor a federal election agency has the authority to force this on states.

Whatever side of that fight you're on, the back-and-forth exposes something worth pulling apart: identity verification for voting is fundamentally a technical infrastructure problem wearing a political costume. This post sets the politics aside and looks at the actual mechanics — and where a naming and identity protocol like Handshake can realistically help, and where it can't.

What matters to citizens

When ordinary people think about ID requirements for voting, their concerns usually cluster around a few things:

  • Access — will this make it harder for someone without a passport, a car, or a stable address to vote?
  • Privacy — what happens to my data once I hand over a document to prove who I am? Who stores it, who can see it, who can sell it or leak it?
  • Trust in the count — is my vote actually going to be recorded as mine, once, and not duplicated or discarded?
  • Protection from impersonation — can someone else claim to be me and vote in my name?

These four pull in different directions. Strong physical-document requirements can help with impersonation but hurt access. Centralized databases can help with deduplication but hurt privacy. Citizens are, in effect, asking for a system that verifies identity without creating a single point of failure that someone else controls.

What matters to governments

Governments and election administrators are optimizing for a different set of constraints:

  • Verifiable eligibility — confirming citizenship and residency against some authoritative record.
  • Deduplication — making sure one person can't be registered, or vote, twice across jurisdictions.
  • Auditability — being able to prove, after the fact, that the process was followed correctly.
  • Compliance and funding — federal and state rules, and the money attached to following them.

Notice the shape of the problem: citizens want proof without exposure, governments want proof without ambiguity. Both are really asking for the same primitive — a cryptographically verifiable credential — they just weight the trade-offs differently.

The technical core: why centralized ID systems keep running into trouble

Every version of this debate, in the US and elsewhere, keeps bumping into the same architectural issue. A centralized voter ID system needs:

  1. One authority everyone trusts to issue and store identity records.
  2. That authority to never be breached, never be politically captured, and never make an error.
  3. Every citizen to trust that authority equally, regardless of who currently runs it.

That's a lot to ask of any single institution, and it's exactly why courts, states, and citizens keep pushing back on top-down mandates — the objection is rarely "verification is bad," it's "I don't want to hand this much power and data to one party." This is a naming and public-key infrastructure problem before it's a legal one, and that's where Handshake becomes relevant.

How Handshake technically addresses this

Handshake replaces a centralized root — one party deciding what a name resolves to and who controls it — with a blockchain-anchored root zone where ownership of a name is proven with a private key, not granted by an authority you have to ask permission from. The same primitives that make this work for domain names map cleanly onto identity credentials, and are explored in depth in Your HNS Name Is Your Passport:

  • Cryptographic ownership instead of institutional custody. A Handshake name is controlled by whoever holds the private key. Applied to identity, a citizen's credential can be provably theirs — not because a database says so, but because they can produce a signature a database can't fake or revoke arbitrarily. This is the same self-sovereign identity model Handshake already enables for personal and organizational names.
  • DNSSEC and DANE-style binding. Handshake TLDs can anchor DANE/TLSA records that bind a cryptographic key directly to a name, without a certificate authority in the middle. The same binding pattern lets an election authority publish a signed attestation ("this key belongs to a verified citizen") that anyone can check, without that authority holding a central live database of every voter's personal documents.
  • No single point of capture. Because the root zone is decentralized across the Handshake network rather than sitting with one registrar or one government office, there's no single door to breach, subpoena, or politically pressure to change everyone's records at once.
  • Selective disclosure. A signed HNS-anchored credential can prove "this key belongs to an eligible voter" without disclosing the underlying document, address, or citizenship paperwork to every poll worker or database along the way. Combined with zero-knowledge proofs, this becomes the same privacy identity stack already emerging elsewhere in the HNS ecosystem — the proof is minimal, and the personal data stays with the citizen.

In short: Handshake doesn't replace the government's role in deciding who's eligible. It replaces the fragile part — the single, centralized, hackable, politically contestable database — with a verifiable, decentralized anchor that any state, any court, and any citizen can independently check. It's worth noting this is the same underlying primitive now being proposed for AI agent identity — proving "who or what this key belongs to" without a central registry is a general problem, not a voting-specific one.

How it actually runs, step by step

It helps to separate this into three phases: setup, issuance, and proof. Each one has a concrete technical mechanism behind it — nothing here is abstract.

1. Setup — establishing the root of trust

  • An election authority (or a citizen, for personal identity) owns a name on the Handshake root zone — for example utahvote/ or a personal name under an existing TLD. Ownership is recorded on-chain via Handshake's covenant system, and proven with an Urkel-tree commitment, so anyone running a full node can independently verify who owns that name without asking a central registrar.
  • That name's owner publishes a public key as a DNS record, secured with DNSSEC so the record itself can't be tampered with in transit, and optionally a DANE/TLSA record binding a TLS certificate to the same key — the same mechanism browsers already use to verify a website is who it claims to be.

2. Issuance — turning eligibility into a credential

  • The eligibility check itself still happens the traditional way: a citizen proves residency and citizenship once, in person or through an existing verified channel.
  • Once verified, the authority doesn't store a new copy of the citizen's documents in a fresh database. Instead it signs a short cryptographic credential with its private key — a statement that says "the holder of public key X is an eligible voter in jurisdiction Y" — and hands that signed credential to the citizen, who stores it in their own wallet.
  • The citizen generates their own key pair for this; the authority never needs to see or store their private key, only countersign their public key once.

3. Proof — verifying without re-exposing

  • To vote or register, the citizen presents the signed credential and proves control of the matching private key, typically by signing a one-time challenge (a nonce) issued at the point of use, exactly like signing a transaction.
  • The verifier — a poll worker's device, an online portal, or a smart contract — checks three things automatically: the credential's signature traces back to the authority's public key published under its Handshake name, the DNSSEC chain from the Handshake root down to that record hasn't been tampered with, and the citizen's own signature over the challenge matches their public key. If all three check out, the proof is accepted.
  • None of this requires querying a live central database at the moment of the vote. The proof is self-contained and can be verified offline against a locally synced Handshake root, which is exactly why it survives outages, censorship attempts, or a compromised central server.

Resolving these Handshake names day-to-day — for a citizen checking their own credential, or a poll worker verifying an authority's key — is as simple as typing the name into SkyInclude Browser, which resolves HNS names and their DNSSEC/DANE records natively.

Why this is necessary in a digital-first world

A physical ID card made sense when almost every interaction happened face to face. That assumption doesn't hold anymore:

  • Remote and online interactions are now routine. Registration, ballot requests, and increasingly voting itself happen over the internet, where nobody can visually check a plastic card. Digital transactions need a digital-native proof, not a scanned photo of a physical one.
  • Documents are trivially forgeable at scale, keys are not. A photo or scan of an ID can be copied, edited, or deepfaked. A private key signature can't be forged without the key itself — it's mathematically checkable, not visually judged.
  • Centralized databases are now the highest-value target there is. The more identity data one server holds, the more it's worth breaching. A cryptographic, distributed model means there's no single "voter database" honeypot to steal.
  • Cross-jurisdiction verification needs a shared, neutral root. States, counties, and federal systems don't naturally trust each other's databases. A decentralized naming layer like Handshake gives them a common, tamper-evident root to check against, without any one of them controlling it.

Put plainly: as identity checks move online, "prove it" has to mean something a machine can verify cryptographically — not something a human eyeballs on a laminated card. That's the actual necessity behind this shift, independent of whichever way the current legal fight over Executive Order 14399 and the SAVE America Act ultimately resolves.

Who this fits, and who it doesn't

Where a Handshake-anchored model fits well:

  • Citizens who want to prove eligibility without surrendering their underlying documents to a new central store.
  • Digital nomads and overseas voters who need portable, verifiable identity that isn't tied to a single physical address or jurisdictional database.
  • Jurisdictions that want auditability without concentrating everyone's data in one breachable system.
  • Anyone skeptical of handing more power to whichever party currently controls the federal database.

Where it doesn't fit, or isn't sufficient on its own:

  • The initial eligibility decision itself — someone still has to determine citizenship and residency once, using real-world documents. Handshake anchors and protects that proof; it doesn't originate it.
  • Populations without any device or key-management literacy, where a lost private key becomes a lost credential. This needs a real recovery and onboarding design, not just cryptography.
  • Legal frameworks that require a single accountable custodian of record for court challenges — decentralization has to be paired with a clear legal chain of custody, or it creates new disputes instead of resolving old ones.
  • As a drop-in replacement for the political debate. This is infrastructure, not a policy position — it makes whichever verification standard is chosen more secure and less exploitable, but it doesn't decide what that standard should be.

The takeaway

Strip away the headlines, the executive orders, and the lawsuits, and voter ID comes down to a question every identity system eventually faces: who do you trust to say "this is really you," and what happens if that party is wrong, breached, or captured? Centralized answers keep failing that test in court and in public trust. A naming layer like Handshake — cryptographic ownership, DNSSEC/DANE-style binding, no single root to capture — is one concrete way to answer it without asking millions of people to trust one office with everything.

For everyday resolution of Handshake-anchored names and records, SkyInclude Browser remains the most accessible way to interact with this layer directly.

NIHON — Handshake Infrastructure & Web3 Identity