cipher-app/app.py at master · rayhanbss/cipher-app · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
from flask import Flask, render_template, request, jsonify
import base64
import sys
import os
sys.path.append(os.path.join(os.path.dirname(__file__), 'cipher'))
from cipher.shift_cipher import encrypt_shift_bytes
from cipher.shift_cipher import decrypt_shift_bytes
from cipher.shift_cipher import encrypt_shift_text
from cipher.shift_cipher import decrypt_shift_text

from cipher.subtitution_chipper import encrypt_substitution as encrypt_substitution_text
from cipher.subtitution_chipper import decrypt_substitution as decrypt_substitution_text
from cipher.subtitution_chipper import encrypt_bytes_file as encrypt_substitution_bytes
from cipher.subtitution_chipper import decrypt_bytes_file as decrypt_substitution_bytes

from cipher.affine_cipher import encrypt_affine_text
from cipher.affine_cipher import decrypt_affine_text
from cipher.affine_cipher import encrypt_affine_bytes
from cipher.affine_cipher import decrypt_affine_bytes

from cipher.permutation_chipper import encrypt_text as encrypt_permutation_text
from cipher.permutation_chipper import decrypt_text as decrypt_permutation_text
from cipher.permutation_chipper import encrypt_bytes as encrypt_permutation_bytes
from cipher.permutation_chipper import decrypt_bytes as decrypt_permutation_bytes

from cipher.vigenere_cipher import encrypt_vigenere_text, decrypt_vigenere_text, encrypt_vigenere_bytes, decrypt_vigenere_bytes
from cipher.hill_cipher import encrypt_hill_text, decrypt_hill_text, encrypt_hill_bytes, decrypt_hill_bytes


app = Flask(__name__)

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

def execute_cipher(function, data, key, is_bytes):
    mode = request.get_json(silent=True) and request.get_json().get('mode', 'encrypt')

    if function == "shift-cipher" or function == "substitution-cipher":
        try: key = int(key)
        except Exception: pass
    elif function == "permutation-cipher":
        if isinstance(key, str): key = [int(x) for x in key.split(',') if x.strip()]
    elif function == "affine-cipher":
        if isinstance(key, str):
            parts = key.split(',')
            if len(parts) == 2:
                try: key = (int(parts[0]), int(parts[1]))
                except Exception: pass

    try:
        match function:
            case "shift-cipher":
                if is_bytes: return decrypt_shift_bytes(data, key) if mode == 'decrypt' else encrypt_shift_bytes(data, key)
                else: return decrypt_shift_text(data, key) if mode == 'decrypt' else encrypt_shift_text(data, key)

            case "substitution-cipher":
                if is_bytes: return decrypt_substitution_bytes(data, key) if mode == 'decrypt' else encrypt_substitution_bytes(data, key)
                else: return decrypt_substitution_text(data, key) if mode == 'decrypt' else encrypt_substitution_text(data, key)

            case "permutation-cipher":
                if is_bytes: return decrypt_permutation_bytes(data, key) if mode == 'decrypt' else encrypt_permutation_bytes(data, key)
                else: return decrypt_permutation_text(data, key) if mode == 'decrypt' else encrypt_permutation_text(data, key)

            case "affine-cipher":
                if is_bytes: return decrypt_affine_bytes(data, key) if mode == 'decrypt' else encrypt_affine_bytes(data, key)
                else: return decrypt_affine_text(data, key) if mode == 'decrypt' else encrypt_affine_text(data, key)

            case "vigenere-cipher":
                if is_bytes: return decrypt_vigenere_bytes(data, key) if mode == 'decrypt' else encrypt_vigenere_bytes(data, key)
                else: return decrypt_vigenere_text(data, key) if mode == 'decrypt' else encrypt_vigenere_text(data, key)

            case "hill-cipher":
                if is_bytes: return decrypt_hill_bytes(data, key) if mode == 'decrypt' else encrypt_hill_bytes(data, key)
                else: return decrypt_hill_text(data, key) if mode == 'decrypt' else encrypt_hill_text(data, key)

            case _:
                return "Unknown cipher function"
    except Exception as e:
        return str(e)

@app.route("/execute", methods=["POST"])
def execute():
    data = request.get_json()
    cipher_function = data.get("cipher_function", "shift-cipher")
    key = data.get("key", "")


    if 'input_bytes_b64' in data:
        input_bytes = base64.b64decode(data['input_bytes_b64'])
        output_bytes = execute_cipher(cipher_function, input_bytes, key, is_bytes=True)

        if isinstance(output_bytes, str):
            output_bytes = output_bytes.encode('utf-8')

        output_bytes_b64 = base64.b64encode(output_bytes).decode('utf-8')
        return jsonify({"output_bytes_b64": output_bytes_b64})

    else:
        input_text = data.get("input_text", "")
        output = execute_cipher(cipher_function, input_text, key, is_bytes=False)
        return jsonify({"output_text": output})

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