Skip to content
Python Central Hub

Blockchain-Based Voting System

View on GitHub

Abstract

Blockchain-Based Voting System is a Python project that uses blockchain technology for secure voting. The application features transaction management, cryptography, and a CLI interface, demonstrating best practices in security and distributed systems.

Prerequisites

  • Python 3.8 or above
  • A code editor or IDE
  • Basic understanding of blockchain and cryptography
  • Required libraries: hashlibhashlib, jsonjson, timetime

Before you Start

Install Python and the required libraries:

Install dependencies
# Standard libraries only
Install dependencies
# Standard libraries only

Getting Started

Create a Project

  1. Create a folder named blockchain-based-voting-systemblockchain-based-voting-system.
  2. Open the folder in your code editor or IDE.
  3. Create a file named blockchain_based_voting_system.pyblockchain_based_voting_system.py.
  4. Copy the code below into your file.

Write the Code

⚙️ Blockchain-Based Voting System
Blockchain-Based Voting System
"""
Blockchain-Based Voting System
 
Features:
- Secure voting using blockchain
- User authentication
- Result dashboard
- Modular design
- CLI interface
- Error handling
"""
import hashlib
import json
import sys
import time
from collections import defaultdict
 
class Block:
    def __init__(self, index, timestamp, data, prev_hash):
        self.index = index
        self.timestamp = timestamp
        self.data = data
        self.prev_hash = prev_hash
        self.hash = self.compute_hash()
 
    def compute_hash(self):
        block_string = json.dumps(self.__dict__, sort_keys=True)
        return hashlib.sha256(block_string.encode()).hexdigest()
 
class Blockchain:
    def __init__(self):
        self.chain = [self.create_genesis_block()]
 
    def create_genesis_block(self):
        return Block(0, time.time(), {"votes": {}}, "0")
 
    def add_block(self, data):
        prev = self.chain[-1]
        block = Block(len(self.chain), time.time(), data, prev.hash)
        self.chain.append(block)
 
    def is_valid(self):
        for i in range(1, len(self.chain)):
            if self.chain[i].prev_hash != self.chain[i-1].hash:
                return False
            if self.chain[i].hash != self.chain[i].compute_hash():
                return False
        return True
 
class VotingSystem:
    def __init__(self):
        self.blockchain = Blockchain()
        self.users = {"alice": "pass1", "bob": "pass2", "carol": "pass3"}
        self.votes = defaultdict(str)
        self.candidates = ["A", "B", "C"]
 
    def authenticate(self, user, pwd):
        return self.users.get(user) == pwd
 
    def vote(self, user, candidate):
        if candidate not in self.candidates:
            raise ValueError("Invalid candidate")
        self.votes[user] = candidate
        self.blockchain.add_block({"user": user, "vote": candidate})
 
    def results(self):
        tally = defaultdict(int)
        for v in self.votes.values():
            tally[v] += 1
        return dict(tally)
 
    def dashboard(self):
        print("Voting Results:")
        for c, v in self.results().items():
            print(f"{c}: {v}")
        print(f"Blockchain valid: {self.blockchain.is_valid()}")
 
class CLI:
    @staticmethod
    def run():
        system = VotingSystem()
        print("Candidates: A, B, C")
        while True:
            user = input("Username: ")
            pwd = input("Password: ")
            if not system.authenticate(user, pwd):
                print("Authentication failed.")
                continue
            print("Vote for (A/B/C): ")
            candidate = input().strip().upper()
            try:
                system.vote(user, candidate)
                print("Vote recorded.")
            except Exception as e:
                print(f"Error: {e}")
            if input("Show dashboard? (y/n): ").lower() == 'y':
                system.dashboard()
            if input("Exit? (y/n): ").lower() == 'y':
                break
 
if __name__ == "__main__":
    try:
        CLI.run()
    except Exception as e:
        print(f"Error: {e}")
        sys.exit(1)
Blockchain-Based Voting System
"""
Blockchain-Based Voting System
 
Features:
- Secure voting using blockchain
- User authentication
- Result dashboard
- Modular design
- CLI interface
- Error handling
"""
import hashlib
import json
import sys
import time
from collections import defaultdict
 
class Block:
    def __init__(self, index, timestamp, data, prev_hash):
        self.index = index
        self.timestamp = timestamp
        self.data = data
        self.prev_hash = prev_hash
        self.hash = self.compute_hash()
 
    def compute_hash(self):
        block_string = json.dumps(self.__dict__, sort_keys=True)
        return hashlib.sha256(block_string.encode()).hexdigest()
 
class Blockchain:
    def __init__(self):
        self.chain = [self.create_genesis_block()]
 
    def create_genesis_block(self):
        return Block(0, time.time(), {"votes": {}}, "0")
 
    def add_block(self, data):
        prev = self.chain[-1]
        block = Block(len(self.chain), time.time(), data, prev.hash)
        self.chain.append(block)
 
    def is_valid(self):
        for i in range(1, len(self.chain)):
            if self.chain[i].prev_hash != self.chain[i-1].hash:
                return False
            if self.chain[i].hash != self.chain[i].compute_hash():
                return False
        return True
 
class VotingSystem:
    def __init__(self):
        self.blockchain = Blockchain()
        self.users = {"alice": "pass1", "bob": "pass2", "carol": "pass3"}
        self.votes = defaultdict(str)
        self.candidates = ["A", "B", "C"]
 
    def authenticate(self, user, pwd):
        return self.users.get(user) == pwd
 
    def vote(self, user, candidate):
        if candidate not in self.candidates:
            raise ValueError("Invalid candidate")
        self.votes[user] = candidate
        self.blockchain.add_block({"user": user, "vote": candidate})
 
    def results(self):
        tally = defaultdict(int)
        for v in self.votes.values():
            tally[v] += 1
        return dict(tally)
 
    def dashboard(self):
        print("Voting Results:")
        for c, v in self.results().items():
            print(f"{c}: {v}")
        print(f"Blockchain valid: {self.blockchain.is_valid()}")
 
class CLI:
    @staticmethod
    def run():
        system = VotingSystem()
        print("Candidates: A, B, C")
        while True:
            user = input("Username: ")
            pwd = input("Password: ")
            if not system.authenticate(user, pwd):
                print("Authentication failed.")
                continue
            print("Vote for (A/B/C): ")
            candidate = input().strip().upper()
            try:
                system.vote(user, candidate)
                print("Vote recorded.")
            except Exception as e:
                print(f"Error: {e}")
            if input("Show dashboard? (y/n): ").lower() == 'y':
                system.dashboard()
            if input("Exit? (y/n): ").lower() == 'y':
                break
 
if __name__ == "__main__":
    try:
        CLI.run()
    except Exception as e:
        print(f"Error: {e}")
        sys.exit(1)

Example Usage

Run voting system
python blockchain_based_voting_system.py
Run voting system
python blockchain_based_voting_system.py

Explanation

Key Features

  • Blockchain Transactions: Manages votes as blockchain transactions.
  • Cryptography: Secures votes using hashing.
  • Error Handling: Validates inputs and manages exceptions.
  • CLI Interface: Interactive command-line usage.

Code Breakdown

  1. Import Libraries and Setup Blockchain
blockchain_based_voting_system.py
import hashlib
import json
import time
blockchain_based_voting_system.py
import hashlib
import json
import time
  1. Blockchain and Voting Functions
blockchain_based_voting_system.py
class Block:
    def __init__(self, index, timestamp, data, previous_hash):
        self.index = index
        self.timestamp = timestamp
        self.data = data
        self.previous_hash = previous_hash
        self.hash = self.hash_block()
 
    def hash_block(self):
        sha = hashlib.sha256()
        sha.update((str(self.index) + str(self.timestamp) + str(self.data) + str(self.previous_hash)).encode())
        return sha.hexdigest()
 
def create_genesis_block():
    return Block(0, time.time(), "Genesis Block", "0")
 
def next_block(last_block, data):
    index = last_block.index + 1
    timestamp = time.time()
    previous_hash = last_block.hash
    return Block(index, timestamp, data, previous_hash)
blockchain_based_voting_system.py
class Block:
    def __init__(self, index, timestamp, data, previous_hash):
        self.index = index
        self.timestamp = timestamp
        self.data = data
        self.previous_hash = previous_hash
        self.hash = self.hash_block()
 
    def hash_block(self):
        sha = hashlib.sha256()
        sha.update((str(self.index) + str(self.timestamp) + str(self.data) + str(self.previous_hash)).encode())
        return sha.hexdigest()
 
def create_genesis_block():
    return Block(0, time.time(), "Genesis Block", "0")
 
def next_block(last_block, data):
    index = last_block.index + 1
    timestamp = time.time()
    previous_hash = last_block.hash
    return Block(index, timestamp, data, previous_hash)
  1. CLI Interface and Error Handling
blockchain_based_voting_system.py
def main():
    print("Blockchain-Based Voting System")
    blockchain = [create_genesis_block()]
    while True:
        cmd = input('> ')
        if cmd == 'vote':
            vote_data = input("Enter your vote: ")
            block = next_block(blockchain[-1], vote_data)
            blockchain.append(block)
            print(f"Vote recorded in block {block.index}.")
        elif cmd == 'exit':
            break
        else:
            print("Unknown command. Type 'vote' or 'exit'.")
 
if __name__ == "__main__":
    main()
blockchain_based_voting_system.py
def main():
    print("Blockchain-Based Voting System")
    blockchain = [create_genesis_block()]
    while True:
        cmd = input('> ')
        if cmd == 'vote':
            vote_data = input("Enter your vote: ")
            block = next_block(blockchain[-1], vote_data)
            blockchain.append(block)
            print(f"Vote recorded in block {block.index}.")
        elif cmd == 'exit':
            break
        else:
            print("Unknown command. Type 'vote' or 'exit'.")
 
if __name__ == "__main__":
    main()

Features

  • Secure Voting: Blockchain transactions and cryptography
  • Modular Design: Separate classes and functions
  • Error Handling: Manages invalid inputs and exceptions
  • Production-Ready: Scalable and maintainable code

Next Steps

Enhance the project by:

  • Integrating with real-world voting datasets
  • Supporting distributed consensus
  • Creating a GUI for voting
  • Adding encryption for votes
  • Unit testing for reliability

Educational Value

This project teaches:

  • Security: Blockchain and cryptography
  • Software Design: Modular, maintainable code
  • Error Handling: Writing robust Python code

Real-World Applications

  • E-Voting Platforms
  • Secure Transactions
  • Distributed Systems

Conclusion

Blockchain-Based Voting System demonstrates how to build a scalable and secure voting tool using Python. With modular design and extensibility, this project can be adapted for real-world applications in security, governance, and more. For more advanced projects, visit Python Central Hub.

Was this page helpful?

Let us know how we did