app.py

"""
SecureText: A Web-Based Text Encryption and Decryption App
CS166 - Information Security, Fall 2025
Team 8: Jaspreet Aujla, Akanksha Raghapur, Ryan Shim
"""

from flask import Flask, render_template, request, jsonify
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from Crypto.Random import get_random_bytes
import base64
import time

app = Flask(__name__)


# ============== CAESAR CIPHER ==============
def caesar_encrypt(plaintext, shift):
    """Encrypt using Caesar cipher with given shift value."""
    result = []
    shift = int(shift) % 26
    for char in plaintext:
        if char.isalpha():
            base = ord('A') if char.isupper() else ord('a')
            result.append(chr((ord(char) - base + shift) % 26 + base))
        else:
            result.append(char)
    return ''.join(result)


def caesar_decrypt(ciphertext, shift):
    """Decrypt Caesar cipher by shifting in opposite direction."""
    return caesar_encrypt(ciphertext, -int(shift))


# ============== VIGENÈRE CIPHER ==============
def vigenere_encrypt(plaintext, key):
    """Encrypt using Vigenère cipher with given keyword."""
    if not key:
        return plaintext
    result = []
    key = key.upper()
    key_index = 0
    for char in plaintext:
        if char.isalpha():
            shift = ord(key[key_index % len(key)]) - ord('A')
            base = ord('A') if char.isupper() else ord('a')
            result.append(chr((ord(char) - base + shift) % 26 + base))
            key_index += 1
        else:
            result.append(char)
    return ''.join(result)


def vigenere_decrypt(ciphertext, key):
    """Decrypt Vigenère cipher."""
    if not key:
        return ciphertext
    result = []
    key = key.upper()
    key_index = 0
    for char in ciphertext:
        if char.isalpha():
            shift = ord(key[key_index % len(key)]) - ord('A')
            base = ord('A') if char.isupper() else ord('a')
            result.append(chr((ord(char) - base - shift) % 26 + base))
            key_index += 1
        else:
            result.append(char)
    return ''.join(result)


# ============== AES CIPHER ==============
def aes_encrypt(plaintext, key):
    """Encrypt using AES-256 in CBC mode."""
    # Ensure key is 32 bytes (256 bits) by padding or hashing
    key_bytes = key.encode('utf-8')
    key_bytes = key_bytes.ljust(32, b'\0')[:32]
    
    iv = get_random_bytes(16)
    cipher = AES.new(key_bytes, AES.MODE_CBC, iv)
    
    plaintext_bytes = plaintext.encode('utf-8')
    padded_data = pad(plaintext_bytes, AES.block_size)
    ciphertext = cipher.encrypt(padded_data)
    
    # Return IV + ciphertext as base64
    return base64.b64encode(iv + ciphertext).decode('utf-8')


def aes_decrypt(ciphertext, key):
    """Decrypt AES-256 in CBC mode."""
    try:
        key_bytes = key.encode('utf-8')
        key_bytes = key_bytes.ljust(32, b'\0')[:32]
        
        encrypted_data = base64.b64decode(ciphertext)
        iv = encrypted_data[:16]
        actual_ciphertext = encrypted_data[16:]
        
        cipher = AES.new(key_bytes, AES.MODE_CBC, iv)
        decrypted_padded = cipher.decrypt(actual_ciphertext)
        decrypted = unpad(decrypted_padded, AES.block_size)
        
        return decrypted.decode('utf-8')
    except Exception as e:
        return f"Decryption Error: {str(e)}"


# ============== ROUTES ==============
@app.route('/')
def index():
    return render_template('index.html')


@app.route('/encrypt', methods=['POST'])
def encrypt():
    data = request.json
    plaintext = data.get('plaintext', '')
    algorithm = data.get('algorithm', 'caesar')
    key = data.get('key', '')
    
    start_time = time.perf_counter()
    
    if algorithm == 'caesar':
        try:
            shift = int(key) if key else 3
        except ValueError:
            shift = 3
        ciphertext = caesar_encrypt(plaintext, shift)
        key_info = f"Shift: {shift}"
        security_level = "Very Low"
        key_space = "26 possible keys"
    
    elif algorithm == 'vigenere':
        if not key:
            key = "KEY"
        ciphertext = vigenere_encrypt(plaintext, key)
        key_info = f"Keyword: {key}"
        security_level = "Low"
        key_space = f"26^{len(key)} = {26**len(key):,} possible keys"
    
    elif algorithm == 'aes':
        if not key:
            key = "defaultkey123456"
        ciphertext = aes_encrypt(plaintext, key)
        key_info = f"Key length: {len(key)} chars (padded to 256 bits)"
        security_level = "High"
        key_space = "2^256 possible keys"
    
    else:
        return jsonify({'error': 'Unknown algorithm'}), 400
    
    end_time = time.perf_counter()
    execution_time = (end_time - start_time) * 1000  # Convert to milliseconds
    
    return jsonify({
        'ciphertext': ciphertext,
        'algorithm': algorithm,
        'key_info': key_info,
        'security_level': security_level,
        'key_space': key_space,
        'execution_time': f"{execution_time:.4f} ms"
    })


@app.route('/decrypt', methods=['POST'])
def decrypt():
    data = request.json
    ciphertext = data.get('ciphertext', '')
    algorithm = data.get('algorithm', 'caesar')
    key = data.get('key', '')
    
    start_time = time.perf_counter()
    
    if algorithm == 'caesar':
        try:
            shift = int(key) if key else 3
        except ValueError:
            shift = 3
        plaintext = caesar_decrypt(ciphertext, shift)
    
    elif algorithm == 'vigenere':
        if not key:
            key = "KEY"
        plaintext = vigenere_decrypt(ciphertext, key)
    
    elif algorithm == 'aes':
        if not key:
            key = "defaultkey123456"
        plaintext = aes_decrypt(ciphertext, key)
    
    else:
        return jsonify({'error': 'Unknown algorithm'}), 400
    
    end_time = time.perf_counter()
    execution_time = (end_time - start_time) * 1000
    
    return jsonify({
        'plaintext': plaintext,
        'algorithm': algorithm,
        'execution_time': f"{execution_time:.4f} ms"
    })


@app.route('/compare', methods=['POST'])
def compare():
    """Compare all algorithms side by side."""
    data = request.json
    plaintext = data.get('plaintext', '')
    
    results = []
    
    # Caesar (shift 3)
    start = time.perf_counter()
    caesar_ct = caesar_encrypt(plaintext, 3)
    caesar_time = (time.perf_counter() - start) * 1000
    results.append({
        'algorithm': 'Caesar Cipher',
        'ciphertext': caesar_ct,
        'time': f"{caesar_time:.4f} ms",
        'key_size': '5 bits (26 keys)',
        'security': 'Very Low',
        'vulnerability': 'Easily broken by frequency analysis or brute force'
    })
    
    # Vigenère (key "SECRET")
    start = time.perf_counter()
    vigenere_ct = vigenere_encrypt(plaintext, "SECRET")
    vigenere_time = (time.perf_counter() - start) * 1000
    results.append({
        'algorithm': 'Vigenère Cipher',
        'ciphertext': vigenere_ct,
        'time': f"{vigenere_time:.4f} ms",
        'key_size': 'Variable (depends on keyword)',
        'security': 'Low',
        'vulnerability': 'Vulnerable to Kasiski examination and frequency analysis'
    })
    
    # AES-256
    start = time.perf_counter()
    aes_ct = aes_encrypt(plaintext, "comparekey123456")
    aes_time = (time.perf_counter() - start) * 1000
    results.append({
        'algorithm': 'AES-256',
        'ciphertext': aes_ct,
        'time': f"{aes_time:.4f} ms",
        'key_size': '256 bits',
        'security': 'High',
        'vulnerability': 'No practical attacks known; considered secure'
    })
    
    return jsonify({'results': results})


if __name__ == '__main__':
    import os
    debug = os.environ.get('FLASK_DEBUG', 'False').lower() == 'true'
    port = int(os.environ.get('PORT', 5001))
    app.run(debug=debug, host='0.0.0.0', port=port)