app.py

from flask import Flask, request, jsonify, render_template
import re

app = Flask(__name__, template_folder="templates", static_folder="static")

# ---------------- Encryption / Decryption Logic ---------------- #

alphabet = {chr(ord('a')+i): i for i in range(26)}
reverse_map = {i: chr(ord('a')+i) for i in range(26)}
salt = [3,0,0,7,2,0,0,4]

def validate_input(key, text):
    if not key or len(key) < 8:
        return "Key must be at least 8 characters long"
    if not re.fullmatch(r"[a-z]+", key):
        return "Key must contain only lowercase letters (a-z)"
    if not re.fullmatch(r"[a-z]+", text):
        return "Text must contain only lowercase letters (a-z)"
    return None

def encrypt_text(key, plain_text):
    key_numbers = [alphabet[c] for c in key]
    plain_numbers = [alphabet[c] for c in plain_text]

    key_len = len(key_numbers)
    pt_len = len(plain_numbers)

    # Autokey extension
    for i in range(key_len, pt_len):
        key_numbers.append(plain_numbers[i - key_len])

    # Apply salt to first 8 letters
    for i in range(min(8, len(key_numbers))):
        key_numbers[i] = (key_numbers[i] + salt[i]) % 26

    # Encrypt
    cipher_text = ""
    for i in range(pt_len):
        ci = (plain_numbers[i] + key_numbers[i]) % 26
        cipher_text += reverse_map[ci]

    return cipher_text

def decrypt_text(key, cipher_text):
    cipher_numbers = [alphabet[c] for c in cipher_text]
    full_key = [alphabet[c] for c in key]

    ct_len = len(cipher_numbers)
    key_len = len(full_key)

    plain_text = ""

    # Extend fullKey with 0 placeholders
    while len(full_key) < ct_len:
        full_key.append(0)

    for i in range(ct_len):
        ki = full_key[i]

        # Apply salt to first 8 letters
        if i < 8:
            ki = (ki + salt[i]) % 26

        # Decrypt
        pi = (cipher_numbers[i] - ki + 26) % 26
        plain_text += reverse_map[pi]

        # Autokey: append decrypted plaintext number into full_key
        if i + key_len < ct_len:
            full_key[i + key_len] = pi

    return plain_text


# ---------------- Flask Routes ---------------- #

@app.route("/")
def home():
    return render_template("index.html")

@app.route("/encrypt", methods=["POST"])
def encrypt():
    data = request.json
    key = data.get("key")
    text = data.get("text")

    # Validate
    error = validate_input(key, text)
    if error:
        return jsonify({"error": error}), 400

    try:
        cipher = encrypt_text(key, text)
        return jsonify({"ciphertext": cipher})
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route("/decrypt", methods=["POST"])
def decrypt():
    data = request.json
    key = data.get("key")
    text = data.get("text")

    # Validate
    error = validate_input(key, text)
    if error:
        return jsonify({"error": error}), 400

    try:
        plain = decrypt_text(key, text)
        return jsonify({"plaintext": plain})
    except Exception as e:
        return jsonify({"error": str(e)}), 500


if __name__ == "__main__":
    app.run(debug=True)