AES-256 File Encryption Tool (python, written by Claude Code)

Claude Code wrote this python project from the task below. It installed and ran on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: AES-256 File Encryption Tool

Write a program that encrypts and decrypts files using AES-256 encryption in CBC mode with proper key derivation, initialization vectors, and authenticated encryption to prevent tampering.

FUNCTIONAL REQUIREMENTS:
- Accept a file path, a password, and a mode (encrypt or decrypt) as command-line arguments
- Derive the encryption key from the password using PBKDF2 with SHA-256, a random 16-byte salt, and at least 100,000 iterations
- Encrypt using AES-256-CBC with a random 16-byte initialization vector (IV) for each encryption
- Prepend the salt and IV to the encrypted output file so they are available for decryption
- Add HMAC-SHA256 authentication tag to the encrypted file to detect tampering during decryption
- During decryption, verify the HMAC before attempting to decrypt and report a clear error if the file has been modified
- Support encrypting entire directories recursively via --recursive flag, preserving directory structure in the output
- Support a --output flag to specify the output file or directory (default: append .enc for encryption, strip .enc for decryption)
- Display progress information for large files: file size, percentage complete, and throughput
- If no input file is given, generate a sample text file with random content, encrypt it, then decrypt it back and verify the output matches the original
- Handle errors gracefully: wrong password (HMAC mismatch), corrupted file, file not found, permission denied

Create a complete Python project for a clean Ubuntu 22.04 machine with only Python 3.10+ installed. Include:
- Source code
- requirements.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

#!/usr/bin/env python3
"""
AES-256 File Encryption Tool - Trial 1 (Python)
Uses the 'cryptography' library with Fernet and AES-CBC under the hood.
Provides CLI encrypt/decrypt subcommands with PBKDF2 key derivation.
"""

import argparse
import os
import sys
import struct
import hashlib
import getpass
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding, hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.backends import default_backend

# Constants
SALT_SIZE = 32
IV_SIZE = 16
KEY_SIZE = 32  # AES-256
PBKDF2_ITERATIONS = 600000
MAGIC_HEADER = b"ENC1"  # 4 bytes magic to identify our encrypted files
HMAC_SIZE = 32  # SHA-256 HMAC for integrity


def derive_key(password: str, salt: bytes) -> bytes:
    """Derive a 256-bit key from password using PBKDF2-HMAC-SHA256."""
    kdf = PBKDF2HMAC(
        algorithm=hashes.SHA256(),
        length=KEY_SIZE,
        salt=salt,
        iterations=PBKDF2_ITERATIONS,
        backend=default_backend(),
    )
    return kdf.derive(password.encode("utf-8"))


def compute_hmac(key: bytes, data: bytes) -> bytes:
    """Compute HMAC-SHA256 for integrity verification."""
    import hmac as hmac_mod
    return hmac_mod.new(key, data, hashlib.sha256).digest()


def encrypt_file(input_path: str, output_path: str, password: str) -> None:
    """Encrypt a file using AES-256-CBC with PBKDF2 key derivation."""
    # Read the input file
    with open(input_path, "rb") as f:
        plaintext = f.read()

    # Generate random salt and IV
    salt = os.urandom(SALT_SIZE)
    iv = os.urandom(IV_SIZE)

    # Derive key from password
    key = derive_key(password, salt)

    # Pad plaintext to AES block size (PKCS7)
    padder = padding.PKCS7(algorithms.AES.block_size).padder()
    padded_data = padder.update(plaintext) + padder.finalize()

    # Encrypt with AES-256-CBC
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()
    ciphertext = encryptor.update(padded_data) + encryptor.finalize()

    # Compute HMAC over salt + iv + ciphertext for integrity
    hmac_data = salt + iv + ciphertext
    hmac_value = compute_hmac(key, hmac_data)

    # Write output: MAGIC + salt + iv + ciphertext + hmac
    with open(output_path, "wb") as f:
        f.write(MAGIC_HEADER)
        f.write(salt)
        f.write(iv)
        f.write(struct.pack(">Q", len(ciphertext)))
        f.write(ciphertext)
        f.write(hmac_value)

    print(f"Encrypted: {input_path} -> {output_path}")
    print(f"  Salt: {salt.hex()[:16]}...")
    print(f"  IV:   {iv.hex()[:16]}...")
    print(f"  Size: {len(plaintext)} bytes -> {len(ciphertext)} bytes")


def decrypt_file(input_path: str, output_path: str, password: str) -> None:
    """Decrypt a file encrypted with this tool."""
    with open(input_path, "rb") as f:
        data = f.read()

    # Verify magic header
    if len(data) < 4 or data[:4] != MAGIC_HEADER:
        print("Error: Not a valid encrypted file (bad magic header).")
        sys.exit(1)

    offset = 4
    salt = data[offset : offset + SALT_SIZE]
    offset += SALT_SIZE
    iv = data[offset : offset + IV_SIZE]
    offset += IV_SIZE
    ciphertext_len = struct.unpack(">Q", data[offset : offset + 8])[0]
    offset += 8
    ciphertext = data[offset : offset + ciphertext_len]
    offset += ciphertext_len
    stored_hmac = data[offset : offset + HMAC_SIZE]

    # Derive key from password
    key = derive_key(password, salt)

    # Verify HMAC integrity
    hmac_data = salt + iv + ciphertext
    computed_hmac = compute_hmac(key, hmac_data)

    if not hmac_mod_compare(stored_hmac, computed_hmac):
        print("Error: Integrity check failed. Wrong password or corrupted file.")
        sys.exit(1)

    # Decrypt with AES-256-CBC
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    decryptor = cipher.decryptor()
    padded_plaintext = decryptor.update(ciphertext) + decryptor.finalize()

    # Remove PKCS7 padding
    try:
        unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
        plaintext = unpadder.update(padded_plaintext) + unpadder.finalize()
    except ValueError:
        print("Error: Decryption failed. Wrong password or corrupted file.")
        sys.exit(1)

    with open(output_path, "wb") as f:
        f.write(plaintext)

    print(f"Decrypted: {input_path} -> {output_path}")
    print(f"  Size: {len(ciphertext)} bytes -> {len(plaintext)} bytes")


def hmac_mod_compare(a: bytes, b: bytes) -> bool:
    """Constant-time comparison of two HMAC values."""
    import hmac as hmac_mod
    return hmac_mod.compare_digest(a, b)


def generate_sample_and_demo(password: str) -> None:
    """Generate a sample file and demonstrate encrypt/decrypt."""
    sample_file = "sample_input.txt"
    encrypted_file = "sample_encrypted.enc"
    decrypted_file = "sample_decrypted.txt"

    # Create sample file
    sample_content = (
        "This is a sample file for AES-256-CBC encryption demo.\n"
        "It contains multiple lines of text.\n"
        "Line 3: The quick brown fox jumps over the lazy dog.\n"
        "Line 4: 0123456789 ABCDEF !@#$%^&*()\n"
        "Line 5: Unicode test - cafe\u0301, nai\u0308ve, re\u0301sume\u0301\n"
    )
    with open(sample_file, "w", encoding="utf-8") as f:
        f.write(sample_content)
    print(f"Created sample file: {sample_file} ({len(sample_content)} bytes)")

    # Encrypt
    print("\n--- Encrypting ---")
    encrypt_file(sample_file, encrypted_file, password)

    # Decrypt
    print("\n--- Decrypting ---")
    decrypt_file(encrypted_file, decrypted_file, password)

    # Verify
    with open(sample_file, "rb") as f:
        original = f.read()
    with open(decrypted_file, "rb") as f:
        restored = f.read()

    if original == restored:
        print("\nVerification: SUCCESS - Decrypted file matches original.")
    else:
        print("\nVerification: FAILED - Files do not match!")

    # Test wrong password
    print("\n--- Testing wrong password ---")
    try:
        decrypt_file(encrypted_file, "should_not_exist.txt", "wrong_password")
    except SystemExit:
        print("(Wrong password correctly rejected)")

    # Cleanup
    for f in [sample_file, encrypted_file, decrypted_file]:
        if os.path.exists(f):
            os.remove(f)
    print("\nDemo complete. Temporary files cleaned up.")


def main():
    parser = argparse.ArgumentParser(
        description="AES-256-CBC File Encryption Tool (cryptography library)"
    )
    subparsers = parser.add_subparsers(dest="command", help="Available commands")

    # Encrypt subcommand
    enc_parser = subparsers.add_parser("encrypt", help="Encrypt a file")
    enc_parser.add_argument("input", help="Input file path")
    enc_parser.add_argument(
        "-o", "--output", help="Output file path (default: input.enc)"
    )
    enc_parser.add_argument(
        "-p", "--password", help="Password (prompted if not provided)"
    )

    # Decrypt subcommand
    dec_parser = subparsers.add_parser("decrypt", help="Decrypt a file")
    dec_parser.add_argument("input", help="Encrypted file path")
    dec_parser.add_argument(
        "-o", "--output", help="Output file path (default: input without .enc)"
    )
    dec_parser.add_argument(
        "-p", "--password", help="Password (prompted if not provided)"
    )

    # Demo subcommand
    subparsers.add_parser("demo", help="Run demo with sample file")

    args = parser.parse_args()

    if args.command is None:
        print("No command specified. Running demo mode...")
        demo_password = "demo_password_123"
        generate_sample_and_demo(demo_password)
        return

    if args.command == "demo":
        demo_password = "demo_password_123"
        generate_sample_and_demo(demo_password)
        return

    # Get password
    password = getattr(args, "password", None)
    if not password:
        password = getpass.getpass("Enter password: ")
        if args.command == "encrypt":
            confirm = getpass.getpass("Confirm password: ")
            if password != confirm:
                print("Error: Passwords do not match.")
                sys.exit(1)

    if args.command == "encrypt":
        input_path = args.input
        output_path = args.output or (input_path + ".enc")
        if not os.path.isfile(input_path):
            print(f"Error: Input file not found: {input_path}")
            sys.exit(1)
        encrypt_file(input_path, output_path, password)

    elif args.command == "decrypt":
        input_path = args.input
        if args.output:
            output_path = args.output
        elif input_path.endswith(".enc"):
            output_path = input_path[:-4]
        else:
            output_path = input_path + ".dec"
        if not os.path.isfile(input_path):
            print(f"Error: Input file not found: {input_path}")
            sys.exit(1)
        decrypt_file(input_path, output_path, password)


if __name__ == "__main__":
    main()

# AES-256 File Encryption Tool - Python Trial 1

## Dependencies
- **cryptography** (v42.0.8): Provides AES-256-CBC encryption, PKCS7 padding, and PBKDF2 key derivation.

## Setup
```bash
pip install -r requirements.txt
```

## Usage

### Encrypt a file
```bash
python encryptor.py encrypt <input_file> -o <output_file> -p <password>
```

### Decrypt a file
```bash
python encryptor.py decrypt <input_file> -o <output_file> -p <password>
```

### Demo mode (no input required)
```bash
python encryptor.py demo
# or simply:
python encryptor.py
```

## Design
- **Algorithm**: AES-256-CBC with PKCS7 padding
- **Key Derivation**: PBKDF2-HMAC-SHA256 with 600,000 iterations
- **Integrity**: HMAC-SHA256 over salt + IV + ciphertext
- **File Format**: MAGIC(4) + SALT(32) + IV(16) + CIPHERTEXT_LEN(8) + CIPHERTEXT(N) + HMAC(32)
- Random 32-byte salt and 16-byte IV generated per encryption

cryptography==42.0.8