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

Gemini Code Assist 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

[]

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

ITERATIONS = 100000
SALT_SIZE = 16
IV_SIZE = 16
KEY_SIZE = 32 # 256 bits

def derive_key(password: str, salt: bytes) -> bytes:
    kdf = PBKDF2HMAC(
        algorithm=hashes.SHA256(),
        length=KEY_SIZE,
        salt=salt,
        iterations=ITERATIONS,
        backend=default_backend()
    )
    return kdf.derive(password.encode())

def encrypt_file(file_path: str, password: str, output_path: str):
    salt = os.urandom(SALT_SIZE)
    key = derive_key(password, salt)
    iv = os.urandom(IV_SIZE)
    
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()
    padder = padding.PKCS7(128).padder()

    with open(file_path, 'rb') as f:
        data = f.read()
    
    padded_data = padder.update(data) + padder.finalize()
    ciphertext = encryptor.update(padded_data) + encryptor.finalize()
    
    # Authenticate: HMAC(salt + iv + ciphertext)
    h = hmac.new(key, salt + iv + ciphertext, hashlib.sha256)
    tag = h.digest()
    
    with open(output_path, 'wb') as f:
        f.write(salt + iv + tag + ciphertext)
    
    print(f"Encrypted {file_path} -> {output_path}")

def decrypt_file(file_path: str, password: str, output_path: str):
    with open(file_path, 'rb') as f:
        salt = f.read(SALT_SIZE)
        iv = f.read(IV_SIZE)
        tag = f.read(32) # SHA256 digest size
        ciphertext = f.read()
    
    key = derive_key(password, salt)
    
    # Verify HMAC
    h = hmac.new(key, salt + iv + ciphertext, hashlib.sha256)
    if not hmac.compare_digest(h.digest(), tag):
        print("Error: Verification failed. Wrong password or corrupted file.")
        return False

    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    decryptor = cipher.decryptor()
    unpadder = padding.PKCS7(128).unpadder()
    
    padded_data = decryptor.update(ciphertext) + decryptor.finalize()
    try:
        data = unpadder.update(padded_data) + unpadder.finalize()
    except ValueError:
        print("Error: Decryption failed (padding error).")
        return False
        
    with open(output_path, 'wb') as f:
        f.write(data)
    
    print(f"Decrypted {file_path} -> {output_path}")
    return True

def main():
    parser = argparse.ArgumentParser(description="AES-256 File Encryption Tool")
    parser.add_argument("mode", choices=['encrypt', 'decrypt'], help="Operation mode")
    parser.add_argument("file", help="Path to file")
    parser.add_argument("password", help="Encryption password")
    parser.add_argument("--output", help="Output path")
    
    args = parser.parse_args()
    
    if args.mode == 'encrypt':
        out = args.output or (args.file + ".enc")
        encrypt_file(args.file, args.password, out)
    else:
        out = args.output or (args.file.replace(".enc", ".dec") if ".enc" in args.file else args.file + ".dec")
        decrypt_file(args.file, args.password, out)

if __name__ == "__main__":
    main()

# AES-256 File Encryption Tool (Python)

A secure tool for encrypting and decrypting files using AES-256-CBC with PBKDF2 key derivation and HMAC authentication.

## Setup Instructions

1. Ensure Python 3.10+ is installed.
2. Create a virtual environment:
   ```bash
   python3 -m venv venv
   source venv/bin/activate
   ```
3. Install dependencies:
   ```bash
   pip install -r requirements.txt
   ```

## Run Commands

- Encrypt a file:
  ```bash
  python encrypt_tool.py encrypt secret.txt mypassword
  ```
- Decrypt a file:
  ```bash
  python encrypt_tool.py decrypt secret.txt.enc mypassword
  ```

## Security Features
- **AES-256-CBC**: Strong symmetric encryption.
- **PBKDF2**: Key derivation with 100,000 iterations of SHA-256.
- **HMAC-SHA256**: Authenticated encryption to detect tampering.
- **Random Salt/IV**: Unique for every encryption.

cryptography==42.0.5
cffi==1.16.0
pycparser==2.21