---

import os
from Crypto.Util.strxor import strxor

def read_file(filepath):
    with open(filepath, 'rb') as f:
        return f.read()

def write_file(filepath, content):
    with open(filepath, 'wb') as f:
        f.write(content)

def decrypt(hex_string, key_size):
    # 1. Превращаем hex-строку обратно в байты
    encrypted_data = bytes.fromhex(hex_string)
    
    # 2. Вспоминаем логику шифрования:
    # Исходные данные были раздуты в key_size раз.
    # Значит, размер оригинального файла = len(encrypted_data) // key_size
    original_length = len(encrypted_data) // key_size
    
    # 3. Берем только первый блок зашифрованных данных длиной original_length.
    # Так как данные повторялись, этого блока достаточно для восстановления.
    # (Ключ при шифровании тоже повторялся, поэтому для первого блока он уникален и достаточен)
    first_block = encrypted_data[:original_length]
    
    # 4. Нам нужен ключ. Мы не знаем его, но знаем, что он повторялся.
    # Ключ — это первые key_size байт от расширенного ключа.
    # Но чтобы расшифровать XOR, нам нужно просто повторить ключ до длины блока.
    # Проблема в том, что мы не знаем сам ключ. 
    # НО! Мы можем восстановить его, если знаем хотя бы часть исходного текста 
    # (атака "known plaintext"). 
    # Если же мы не знаем текст, нам придется перебирать key_size от 12 до 44 
    # и смотреть на результат. 
    
    # Для данного скрипта мы предполагаем, что вы знаете key_size.
    # Если нет — нужно перебирать.
    
    # Чтобы расшифровать, нам нужно применить XOR с ключом.
    # Но так как мы не знаем ключ, этот скрипт не сработает "в лоб" без перебора.
    # Однако, если мы знаем, что это был текст (например, английский или русский),
    # мы можем перебирать key_size и смотреть на читаемость.
    
    print(f"Длина зашифрованных данных: {len(encrypted_data)} байт")
    print(f"Предполагаемая длина ключа: {key_size}")
    print(f"Предполагаемая длина исходного файла: {original_length} байт")
    
    # ВАЖНО: Без знания ключа мы не можем расшифровать XOR.
    # Но мы можем попробовать перебрать key_size и вывести результат.
    # Если вы знаете, что в исходном файле был, например, текст "Hello", 
    # то можно вычислить ключ: key = encrypted[:5] XOR "Hello".
    
    return first_block # Это просто зашифрованный блок

if __name__ == "__main__":
    # Читаем зашифрованный файл (он в hex)
    hex_content = read_file('output.txt').decode('utf-8')
    
    # ВАМ НУЖНО ЗНАТЬ ИЛИ ПОДОБРАТЬ ЭТО ЧИСЛО
    # Попробуйте разные значения от 12 до 44.
    # Например, если исходный файл был маленьким, ключ мог быть любым.
    # Если файл был большим, ключ, скорее всего, 12-20.
    KEY_SIZE = 12  # <--- ИЗМЕНИТЕ ЭТО ЗНАЧЕНИЕ
    
    # Пытаемся расшифровать
    # (На самом деле, для полной расшифровки нужен сам ключ, 
    # но мы можем попробовать восстановить его, если знаем начало текста)
    
    encrypted_bytes = bytes.fromhex(hex_content)
    original_length = len(encrypted_bytes) // KEY_SIZE
    
    # Берем первый блок
    first_block = encrypted_bytes[:original_length]
    
    print(f"Первый блок (hex): {first_block.hex()}")
    print("Чтобы расшифровать, нужно знать ключ. Попробуйте перебрать KEY_SIZE.")
    
    # Если вы знаете, что в начале файла был, например, текст "flag{", 
    # вы можете вычислить ключ:
    # known_text = b"flag{"
    # key_part = strxor(first_block[:len(known_text)], known_text)
    # print(f"Восстановленный ключ: {key_part.hex()}")