Anonymous Voting System

Cryptographic Pseudonyms

Pseudonyms are the core technology that enables anonymous yet verifiable voting. Here's how they work:

What is a Pseudonym?

A pseudonym is a cryptographic identifier that:

• Is unique for each voter in an election
• Cannot be linked to the voter's identity
• Cannot be linked to pseudonyms from other elections
• Can be verified as belonging to an eligible voter
• Can be used to sign data like a digital signature, like your choice in an election

The Magic of Pseudonyms

Pseudonym Creation (Technical Details)

Each pseudonym is created using the voter's credential and contains:

• Election ID (relying_party_id): Unique identifier for the election
• Pseudonym ID (y): Unique identifier for this voter in this election
• Zero-Knowledge Proof: Cryptographic proof that the pseudonym was derived from a valid credential without revealing which credential

// A simplified representation of how pseudonyms are created
let pseudonym = credential.pseudonym_for(
    params,         // System parameters shared by all participants
    election_id,     // Unique identifier for this election
    "vote data",     // Additional data to bind to this pseudonym
    rng    // Source of randomness
);

// The pseudonym ID is deterministic for a given (credential, election) pair
// But pseudonyms from different elections cannot be linked
                    

Key Properties

• Deterministic per Election: The same credential will always generate the same pseudonym for a specific election, preventing double voting.
• Unlinkable Across Elections: Pseudonyms from the same voter but different elections cannot be linked, preserving voter privacy.
• Zero-Knowledge Verification: Anyone can verify a pseudonym belongs to an eligible voter without learning which voter.

The Voting Process

Let's walk through the entire voting process from credential issuance to vote verification:

Setup

Issuer generates key pair and publishes public key. System parameters are established.

Credential Request

Voter generates private key and sends a credential request to the issuer.

Credential Issuance

Issuer verifies the request and issues a credential without learning the voter's private key.

Election Setup

Vote collector creates a new election with a unique ID and enables it in the database.

Create Pseudonym

Voter derives a pseudonym specific to the election using their credential.

Cast Vote

Voter creates a vote with their choice and pseudonym as proof of eligibility.

Vote Verification

Vote collector verifies the vote's authenticity using the issuer's public key.

Recording & Results

Vote is recorded and counted in the final results.

Code Example: Creating and Casting a Vote

// Example of how a vote is created and cast
let election_id = ElectionID { bytes: /* unique ID for this election */ };
let choice = "Candidate A".to_string();

// Create a vote using the voter's credential
let vote = credential.vote(election_id, choice).unwrap();

// Add vote to the database (this is done by the vote collector)
let result = vote_database.add_vote(vote, &issuer_public_key);

match result {
    Ok(()) => println!("Vote recorded successfully!"),
    Err(VotingError::DoubleVote { .. }) => println!("Double voting detected!"),
    Err(VotingError::Unauthenticated) => println!("Invalid vote!"),
    Err(VotingError::NonexistentElection(_)) => println!("Election not found!"),
}
                    

Verification & Security

The system provides strong security guarantees through various cryptographic mechanisms:

Double-Voting Prevention

When a voter attempts to vote twice in the same election:

1. Both votes will have the same pseudonym ID (derived deterministically from their credential)
2. The system detects the duplicate pseudonym ID
3. The second vote is rejected and recorded as a "liar" for auditing

Database Verification

The integrity of the entire vote database can be verified by anyone with access to the database and the issuer's public key, without compromising voter anonymity:

// Verify the entire database
let database_valid = vote_database.verify(&issuer_public_key);

if database_valid {
    println!("All votes in the database are valid.");
} else {
    println!("Database verification failed!");
}
                    

Security Guarantees

• Anonymity: Votes cannot be linked back to voters' identities, even if election authorities collude.
• Non-transferability: Credentials are bound to the voter's private key and cannot be used by anyone else.
• Double-voting Prevention: The system detects and prevents voting multiple times in the same election.
• Distributed Trust: Multiple vote collectors can operate independently and later combine their results.

Limitations

Interactive Demonstration

This interactive demo simulates the core components of the anonymous voting system.