Password Encryption & Storage

# Encryption can be DECRYPTED back to original
from cryptography.fernet import Fernet

key = Fernet.generate_key()
cipher = Fernet(key)

# Encrypt
encrypted = cipher.encrypt(b"MyPassword123")
print(f"Encrypted: {encrypted}")

# Decrypt (THIS IS THE PROBLEM!)
decrypted = cipher.decrypt(encrypted)
print(f"Decrypted: {decrypted}")  # Gets original password back

# ❌ Don't use encryption for passwords!
# If the key is compromised, all passwords can be decrypted

import sqlite3 as sql
import bcrypt

def insertUser(username, password, DoB):
    """
    Secure user registration with password hashing
    """
    con = sql.connect("database_files/database.db")
    cur = con.cursor()
    
    # Generate a salt and hash the password
    salt = bcrypt.gensalt(rounds=12)  # 12 rounds is a good balance
    hashed_password = bcrypt.hashpw(password.encode('utf-8'), salt)
    
    # Store the hashed password, not plaintext!
    cur.execute(
        "INSERT INTO users (username, password, dateOfBirth) VALUES (?, ?, ?)",
        (username, hashed_password, DoB)
    )
    
    con.commit()
    con.close()
    
    print(f"User {username} created with hashed password")

import sqlite3 as sql
import bcrypt

def retrieveUsers(username, password):
    """
    Secure authentication with password hashing verification
    """
    con = sql.connect("database_files/database.db")
    cur = con.cursor()
    
    # Use parameterized query to prevent SQL injection
    cur.execute("SELECT * FROM users WHERE username = ?", (username,))
    user = cur.fetchone()
    
    if user is None:
        con.close()
        return False
    
    # Get the stored hashed password
    stored_hash = user[1]  # Assuming password is in column index 1
    
    # Verify the password using bcrypt
    try:
        # bcrypt.checkpw handles the comparison securely
        if bcrypt.checkpw(password.encode('utf-8'), stored_hash):
            con.close()
            return True
        else:
            con.close()
            return False
    except Exception as e:
        print(f"Password verification error: {e}")
        con.close()
        return False

import sqlite3 as sql
import bcrypt
import logging
from datetime import datetime

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def insertUser(username, password, DoB):
    """
    Securely create a new user with hashed password
    
    Args:
        username: Unique username
        password: Plaintext password (will be hashed)
        DoB: Date of birth
        
    Returns:
        bool: True if successful, False otherwise
    """
    try:
        con = sql.connect("database_files/database.db")
        cur = con.cursor()
        
        # Check if username already exists
        cur.execute("SELECT username FROM users WHERE username = ?", (username,))
        if cur.fetchone():
            logger.warning(f"Username {username} already exists")
            con.close()
            return False
        
        # Generate salt and hash password
        salt = bcrypt.gensalt(rounds=12)
        hashed_password = bcrypt.hashpw(password.encode('utf-8'), salt)
        
        # Insert user with hashed password
        cur.execute(
            "INSERT INTO users (username, password, dateOfBirth, created_at) VALUES (?, ?, ?, ?)",
            (username, hashed_password, DoB, datetime.now())
        )
        
        con.commit()
        con.close()
        
        logger.info(f"User {username} created successfully")
        return True
        
    except sql.Error as e:
        logger.error(f"Database error during user creation: {e}")
        return False
    except Exception as e:
        logger.error(f"Unexpected error during user creation: {e}")
        return False

def retrieveUsers(username, password):
    """
    Securely authenticate a user
    
    Args:
        username: Username to authenticate
        password: Plaintext password to verify
        
    Returns:
        bool: True if authenticated, False otherwise
    """
    try:
        con = sql.connect("database_files/database.db")
        cur = con.cursor()
        
        # Retrieve user with parameterized query
        cur.execute("SELECT password FROM users WHERE username = ?", (username,))
        user = cur.fetchone()
        
        if user is None:
            logger.warning(f"Login attempt for non-existent user: {username}")
            con.close()
            # Use same timing as password check to prevent username enumeration
            bcrypt.checkpw(b"dummy", bcrypt.hashpw(b"dummy", bcrypt.gensalt()))
            return False
        
        stored_hash = user[0]
        
        # Verify password
        if bcrypt.checkpw(password.encode('utf-8'), stored_hash):
            logger.info(f"Successful login for user: {username}")
            con.close()
            return True
        else:
            logger.warning(f"Failed login attempt for user: {username}")
            con.close()
            return False
            
    except sql.Error as e:
        logger.error(f"Database error during authentication: {e}")
        return False
    except Exception as e:
        logger.error(f"Unexpected error during authentication: {e}")
        return False

def updatePassword(username, old_password, new_password):
    """
    Securely update a user's password
    
    Args:
        username: Username
        old_password: Current password (for verification)
        new_password: New password to set
        
    Returns:
        bool: True if successful, False otherwise
    """
    # First verify old password
    if not retrieveUsers(username, old_password):
        return False
    
    try:
        con = sql.connect("database_files/database.db")
        cur = con.cursor()
        
        # Hash new password
        salt = bcrypt.gensalt(rounds=12)
        hashed_password = bcrypt.hashpw(new_password.encode('utf-8'), salt)
        
        # Update password
        cur.execute(
            "UPDATE users SET password = ? WHERE username = ?",
            (hashed_password, username)
        )
        
        con.commit()
        con.close()
        
        logger.info(f"Password updated for user: {username}")
        return True
        
    except sql.Error as e:
        logger.error(f"Database error during password update: {e}")
        return False