Деобфускация кода Python

Написание деобфускатора для анализа кода, который обфусцирован, например, с использованием многослойного сжатия и кодирования, возможно, но важно помнить, что использование таких инструментов может нарушать законы или условия использования в зависимости от того, как и где вы их применяете. Убедитесь, что у вас есть разрешение для работы с таким кодом.

Ниже приведен пример скрипта на Python, который выполняет деобфускацию кода, обфусцированного с использованием представленной вами цепочки (zlib, lzma, gzip, base64). Этот скрипт позволяет выбрать файл для анализа.

python
import os
import base64
import zlib
import lzma
import gzip
from tkinter import Tk, filedialog


def deobfuscate(data):
    try:
        # Обратный порядок декодирования
        decoded = base64.b64decode(data[::-1])  # Base64 + реверс
        decompressed_zlib = zlib.decompress(decoded)  # Zlib
        decompressed_lzma = lzma.decompress(decompressed_zlib)  # LZMA
        decompressed_gzip = gzip.decompress(decompressed_lzma)  # Gzip
        return decompressed_gzip.decode("utf-8")  # Финальная строка
    except Exception as e:
        print(f"Ошибка при деобфускации: {e}")
        return None


def main():
    # Выбор файла через GUI
    Tk().withdraw()  # Скрыть главное окно Tkinter
    file_path = filedialog.askopenfilename(title="Выберите файл для деобфускации")
    
    if not file_path:
        print("Файл не выбран.")
        return

    if not os.path.exists(file_path):
        print("Файл не найден.")
        return

    # Чтение содержимого файла
    with open(file_path, "r") as f:
        obfuscated_code = f.read()

    # Деобфускация
    deobfuscated_code = deobfuscate(obfuscated_code)

    if deobfuscated_code:
        print("Деобфусцированный код:")
        print(deobfuscated_code)

        # Сохранение результата в новый файл
        output_path = os.path.splitext(file_path)[0] + "_deobfuscated.py"
        with open(output_path, "w") as out_file:
            out_file.write(deobfuscated_code)
        print(f"Результат сохранён в: {output_path}")
    else:
        print("Не удалось деобфусцировать код.")


if __name__ == "__main__":
    main()

Пояснение:

1. Выбор файла: Используется модуль Tkinter для предоставления графического интерфейса выбора файла.

2. Деобфускация:

   • Расшифровка идет в обратном порядке: base64, zlib, lzma, gzip.
   • Ошибки обрабатываются с использованием try...except.

3. Результат:

   • Деобфусцированный код выводится в консоль и сохраняется в файл с суффиксом _deobfuscated.py.

Предупреждение:

• Используйте этот инструмент только для легальных целей, таких как анализ собственного кода или кода, на который у вас есть разрешение.
• Если вы работаете с вредоносным кодом, убедитесь, что делаете это в изолированной среде (например, виртуальная машина).

Если потребуется дополнение или пояснение, дайте знать!

Спасибо за напоминание! Включим обработку модуля marshal в процесс деобфускации. Вот обновленный код с учетом декодирования данных из marshal:

python
import os
import base64
import zlib
import lzma
import gzip
import marshal
from tkinter import Tk, filedialog


def deobfuscate(data):
    try:
        # Обратный порядок декодирования
        decoded = base64.b64decode(data[::-1])  # Base64 + реверс
        decompressed_zlib = zlib.decompress(decoded)  # Zlib
        decompressed_lzma = lzma.decompress(decompressed_zlib)  # LZMA
        decompressed_gzip = gzip.decompress(decompressed_lzma)  # Gzip
        
        # Декодирование с помощью marshal
        unmarshaled_code = marshal.loads(decompressed_gzip)
        return unmarshaled_code
    except Exception as e:
        print(f"Ошибка при деобфускации: {e}")
        return None


def main():
    # Выбор файла через GUI
    Tk().withdraw()  # Скрыть главное окно Tkinter
    file_path = filedialog.askopenfilename(title="Выберите файл для деобфускации")
    
    if not file_path:
        print("Файл не выбран.")
        return

    if not os.path.exists(file_path):
        print("Файл не найден.")
        return

    # Чтение содержимого файла
    with open(file_path, "r") as f:
        obfuscated_code = f.read()

    # Деобфускация
    deobfuscated_code = deobfuscate(obfuscated_code)

    if deobfuscated_code:
        print("Деобфусцированный код:")
        print(deobfuscated_code)

        # Сохранение результата в новый файл
        output_path = os.path.splitext(file_path)[0] + "_deobfuscated.py"
        with open(output_path, "w") as out_file:
            out_file.write(deobfuscated_code)
        print(f"Результат сохранён в: {output_path}")
    else:
        print("Не удалось деобфусцировать код.")


if __name__ == "__main__":
    main()

Пояснения к изменению:

1. Обработка marshal: После завершения распаковки через gzip, lzma, и т.д., добавлен шаг декодирования с использованием marshal.loads.

2. Тип результата: Декодированный результат через marshal обычно является исполняемым Python-кодом, который можно сохранить и исполнить.

3. Сохранение результата: Декодированный код сохраняется в файл с суффиксом _deobfuscated.py.

Предупреждение:

Использование marshal.loads подразумевает, что распакованный объект является корректным Python-кодом. Будьте осторожны, чтобы не запускать код без анализа, если источник кода вам неизвестен.

Если у вас есть дополнительные пожелания или вопросы, напишите!

Ошибка говорит о том, что строка не является корректной Base64-строкой из-за неправильной длины — она должна быть кратна 4. Это может произойти из-за нескольких причин:

1. Данные были изменены или повреждены: Убедитесь, что строка полностью соответствует ожидаемой.
2. Не хватает padding (=): Base64-строка должна иметь длину кратную 4. Если она не кратна, необходимо добавить символы = в конец строки.

Исправленный код:

Добавим автоматическое исправление длины строки для Base64:

python
import os
import base64
import zlib
import lzma
import gzip
import marshal
from tkinter import Tk, filedialog


def fix_base64(data):
    """Добавляет недостающие символы '=' для корректной длины Base64-строки."""
    missing_padding = len(data) % 4
    if missing_padding:
        data += "=" * (4 - missing_padding)
    return data


def deobfuscate(data):
    try:
        # Исправляем длину Base64-строки
        fixed_data = fix_base64(data[::-1])  # Base64 + реверс с фиксом длины
        decoded = base64.b64decode(fixed_data)
        decompressed_zlib = zlib.decompress(decoded)  # Zlib
        decompressed_lzma = lzma.decompress(decompressed_zlib)  # LZMA
        decompressed_gzip = gzip.decompress(decompressed_lzma)  # Gzip
        
        # Декодирование с помощью marshal
        unmarshaled_code = marshal.loads(decompressed_gzip)
        return unmarshaled_code
    except Exception as e:
        print(f"Ошибка при деобфускации: {e}")
        return None


def main():
    # Выбор файла через GUI
    Tk().withdraw()  # Скрыть главное окно Tkinter
    file_path = filedialog.askopenfilename(title="Выберите файл для деобфускации")
    
    if not file_path:
        print("Файл не выбран.")
        return

    if not os.path.exists(file_path):
        print("Файл не найден.")
        return

    # Чтение содержимого файла
    with open(file_path, "r") as f:
        obfuscated_code = f.read()

    # Деобфускация
    deobfuscated_code = deobfuscate(obfuscated_code)

    if deobfuscated_code:
        print("Деобфусцированный код:")
        print(deobfuscated_code)

        # Сохранение результата в новый файл
        output_path = os.path.splitext(file_path)[0] + "_deobfuscated.py"
        with open(output_path, "w") as out_file:
            out_file.write(deobfuscated_code)
        print(f"Результат сохранён в: {output_path}")
    else:
        print("Не удалось деобфусцировать код.")


if __name__ == "__main__":
    main()

Изменения:

1. Функция fix_base64: Добавляет недостающие символы = в конец строки для корректной длины Base64.

2. Исправление перед декодированием: Применяется функция fix_base64 к строке перед декодированием.

Примечание:

Если проблема сохраняется, проверьте входные данные. Возможно, они не полностью соответствуют указанной структуре (например, отсутствует одна из стадий сжатия). Если сможете предоставить пример строки или дополнительных данных, я смогу адаптировать код.

Если в обфусцированном коде используются многократные итерации Base64 или других методов сжатия, потребуется применить декодирование рекурсивно или в цикле до тех пор, пока строка не будет полностью расшифрована. Вот как можно это реализовать:

Обновленный код:

python
import os
import base64
import zlib
import lzma
import gzip
import marshal
from tkinter import Tk, filedialog


def fix_base64(data):
    """Добавляет недостающие символы '=' для корректной длины Base64-строки."""
    missing_padding = len(data) % 4
    if missing_padding:
        data += "=" * (4 - missing_padding)
    return data


def deobfuscate(data):
    try:
        while True:
            # Попытка декодировать Base64
            try:
                fixed_data = fix_base64(data[::-1])  # Base64 + реверс с фиксом длины
                data = base64.b64decode(fixed_data).decode("utf-8")
            except Exception:
                break  # Если больше не Base64, выходим из цикла

        # Распаковка zlib
        data = zlib.decompress(data.encode())
        # Распаковка lzma
        data = lzma.decompress(data)
        # Распаковка gzip
        data = gzip.decompress(data)

        # Декодирование с помощью marshal
        unmarshaled_code = marshal.loads(data)
        return unmarshaled_code
    except Exception as e:
        print(f"Ошибка при деобфускации: {e}")
        return None


def main():
    # Выбор файла через GUI
    Tk().withdraw()  # Скрыть главное окно Tkinter
    file_path = filedialog.askopenfilename(title="Выберите файл для деобфускации")
    
    if not file_path:
        print("Файл не выбран.")
        return

    if not os.path.exists(file_path):
        print("Файл не найден.")
        return

    # Чтение содержимого файла
    with open(file_path, "r") as f:
        obfuscated_code = f.read()

    # Деобфускация
    deobfuscated_code = deobfuscate(obfuscated_code)

    if deobfuscated_code:
        print("Деобфусцированный код:")
        print(deobfuscated_code)

        # Сохранение результата в новый файл
        output_path = os.path.splitext(file_path)[0] + "_deobfuscated.py"
        with open(output_path, "w") as out_file:
            out_file.write(deobfuscated_code)
        print(f"Результат сохранён в: {output_path}")
    else:
        print("Не удалось деобфусцировать код.")


if __name__ == "__main__":
    main()

Изменения:

1. Цикл для многократного Base64-декодирования:

   • Декодирование выполняется в цикле while True до тех пор, пока строка можно декодировать через base64.b64decode.

2. Обработка всех уровней сжатия: После Base64-декодирования выполняются декомпрессии zlib, lzma, и gzip в правильном порядке.

3. Ошибки в процессе: Если одна из стадий декомпрессии завершится с ошибкой (например, формат данных неверен), декодирование будет прервано.

Предупреждение:

• Если код действительно содержит 400+ итераций Base64, обработка может занять значительное время. Если возможно, уточните, сколько уровней Base64 или других методов сжатия применяется.
• Если входная строка слишком большая, это также может привести к превышению лимитов памяти.

Если у вас есть пример кода или данных, дайте знать — это поможет адаптировать скрипт более точно.

Ошибка Error -3 while decompressing data: incorrect header check возникает, когда декомпрессор (например, zlib, lzma или gzip) пытается обработать данные, которые не соответствуют ожидаемому формату сжатия. Это может быть вызвано следующими причинами:

1. Неверный порядок распаковки: Форматы данных (gzip, lzma, zlib) могли быть применены в другом порядке.
2. Некорректные или поврежденные данные: Исходные данные могут быть повреждены или не полностью соответствуют описанным методам обфускации.
3. Дополнительные уровни обфускации: Возможно, обфусцированный код включает другие методы шифрования, которые не были учтены.

Исправленный подход:

Добавим автоматическое определение форматов сжатия и обработку данных в динамическом порядке:

python
import os
import base64
import zlib
import lzma
import gzip
import marshal
from tkinter import Tk, filedialog


def fix_base64(data):
    """Добавляет недостающие символы '=' для корректной длины Base64-строки."""
    missing_padding = len(data) % 4
    if missing_padding:
        data += "=" * (4 - missing_padding)
    return data


def try_decompress(data):
    """Пытается распаковать данные с использованием различных алгоритмов."""
    for decompress_func in [gzip.decompress, lzma.decompress, zlib.decompress]:
        try:
            return decompress_func(data)
        except Exception:
            continue
    raise ValueError("Не удалось определить формат сжатия")


def deobfuscate(data):
    try:
        # Многократное Base64-декодирование
        while True:
            try:
                fixed_data = fix_base64(data[::-1])  # Base64 + реверс с фиксом длины
                data = base64.b64decode(fixed_data)
            except Exception:
                break  # Если больше не Base64, выходим из цикла

        # Распаковка данных
        while True:
            try:
                data = try_decompress(data)
            except ValueError:
                break  # Если формат сжатия больше не определён, выходим из цикла

        # Декодирование с помощью marshal
        unmarshaled_code = marshal.loads(data)
        return unmarshaled_code
    except Exception as e:
        print(f"Ошибка при деобфускации: {e}")
        return None


def main():
    # Выбор файла через GUI
    Tk().withdraw()  # Скрыть главное окно Tkinter
    file_path = filedialog.askopenfilename(title="Выберите файл для деобфускации")
    
    if not file_path:
        print("Файл не выбран.")
        return

    if not os.path.exists(file_path):
        print("Файл не найден.")
        return

    # Чтение содержимого файла
    with open(file_path, "r") as f:
        obfuscated_code = f.read()

    # Деобфускация
    deobfuscated_code = deobfuscate(obfuscated_code)

    if deobfuscated_code:
        print("Деобфусцированный код:")
        print(deobfuscated_code)

        # Сохранение результата в новый файл
        output_path = os.path.splitext(file_path)[0] + "_deobfuscated.py"
        with open(output_path, "w") as out_file:
            out_file.write(deobfuscated_code)
        print(f"Результат сохранён в: {output_path}")
    else:
        print("Не удалось деобфусцировать код.")


if __name__ == "__main__":
    main()

Что изменено:

1. Функция try_decompress:

   • Поочередно пробует распаковать данные с помощью gzip, lzma, и zlib.
   • Если ни один формат не подходит, выбрасывает исключение.

2. Декодирование в цикле:

   • Многократное декодирование Base64 до тех пор, пока строка может быть расшифрована.
   • Аналогично, сжатые данные распаковываются поочередно до тех пор, пока это возможно.

3. Гибкость:

   • Добавлена возможность обработки данных, которые не следуют строгой последовательности форматов.

Предупреждение:

Если входные данные действительно повреждены или содержат дополнительные уровни шифрования (например, XOR, RC4 и т.д.), потребуется их дополнительный анализ. Если вы можете предоставить пример обфусцированного кода (с анонимизацией), это поможет более точно настроить скрипт.

Ошибка a bytes-like object is required, not 'str' указывает, что вы пытаетесь обработать строку (str), где ожидаются байты (bytes). Это может происходить, например, при передаче текстовых данных в функцию, которая работает с байтовыми объектами (например, gzip.decompress).

Вот исправленный код, который учитывает преобразование между строками и байтами:

python
import os
import base64
import zlib
import lzma
import gzip
import marshal
from tkinter import Tk, filedialog


def fix_base64(data):
    """Добавляет недостающие символы '=' для корректной длины Base64-строки."""
    missing_padding = len(data) % 4
    if missing_padding:
        data += "=" * (4 - missing_padding)
    return data


def try_decompress(data):
    """Пытается распаковать данные с использованием различных алгоритмов."""
    for decompress_func in [gzip.decompress, lzma.decompress, zlib.decompress]:
        try:
            return decompress_func(data)
        except Exception:
            continue
    raise ValueError("Не удалось определить формат сжатия")


def deobfuscate(data):
    try:
        # Если данные переданы как строка, преобразуем в байты
        if isinstance(data, str):
            data = data.encode("utf-8")

        # Многократное Base64-декодирование
        while True:
            try:
                fixed_data = fix_base64(data[::-1].decode("utf-8"))  # Base64 + реверс
                data = base64.b64decode(fixed_data)
            except Exception:
                break  # Если больше не Base64, выходим из цикла

        # Распаковка данных
        while True:
            try:
                data = try_decompress(data)
            except ValueError:
                break  # Если формат сжатия больше не определён, выходим из цикла

        # Декодирование с помощью marshal
        unmarshaled_code = marshal.loads(data)
        return unmarshaled_code
    except Exception as e:
        print(f"Ошибка при деобфускации: {e}")
        return None


def main():
    # Выбор файла через GUI
    Tk().withdraw()  # Скрыть главное окно Tkinter
    file_path = filedialog.askopenfilename(title="Выберите файл для деобфускации")
    
    if not file_path:
        print("Файл не выбран.")
        return

    if not os.path.exists(file_path):
        print("Файл не найден.")
        return

    # Чтение содержимого файла
    with open(file_path, "r") as f:
        obfuscated_code = f.read()

    # Деобфускация
    deobfuscated_code = deobfuscate(obfuscated_code)

    if deobfuscated_code:
        print("Деобфусцированный код:")
        print(deobfuscated_code)

        # Сохранение результата в новый файл
        output_path = os.path.splitext(file_path)[0] + "_deobfuscated.py"
        with open(output_path, "w") as out_file:
            out_file.write(deobfuscated_code)
        print(f"Результат сохранён в: {output_path}")
    else:
        print("Не удалось деобфусцировать код.")


if __name__ == "__main__":
    main()

Исправления:

1. Проверка типа входных данных:

   • Если входные данные являются строкой (str), они преобразуются в байты с помощью data.encode("utf-8").

2. Преобразование после Base64:

   • После декодирования Base64 строка автоматически становится байтами (bytes).

3. Работа с gzip, lzma, и zlib:

   • Все эти функции работают исключительно с байтовыми объектами, поэтому строковые данные всегда приводятся к нужному формату.

4. Обработка ошибок:

   • Если строка или данные не могут быть обработаны, декодирование прекращается.

Попробуйте этот код с вашим файлом. Если ошибка сохраняется, сообщите дополнительные детали об входных данных (например, их структуру или пример строки).

Ошибка bad marshal data (unknown type code) возникает, если данные, переданные в marshal.loads, не являются корректными маршализованными данными Python. Это может происходить из-за следующих причин:

1. Неверный порядок операций: Возможно, данные еще не полностью расшифрованы и содержат дополнительные уровни сжатия или шифрования.
2. Данные повреждены: Входные данные могут быть изменены или повреждены.
3. Маршализованные данные из другого интерпретатора: Иногда данные могут быть несовместимы с текущей версией Python.

Чтобы диагностировать проблему и обработать данные корректно, можно использовать следующие шаги:

Улучшенный код с диагностикой

python
import os
import base64
import zlib
import lzma
import gzip
import marshal
from tkinter import Tk, filedialog


def fix_base64(data):
    """Добавляет недостающие символы '=' для корректной длины Base64-строки."""
    missing_padding = len(data) % 4
    if missing_padding:
        data += "=" * (4 - missing_padding)
    return data


def try_decompress(data):
    """Пытается распаковать данные с использованием различных алгоритмов."""
    for decompress_func in [gzip.decompress, lzma.decompress, zlib.decompress]:
        try:
            return decompress_func(data)
        except Exception:
            continue
    raise ValueError("Не удалось определить формат сжатия")


def deobfuscate(data):
    try:
        # Если данные переданы как строка, преобразуем в байты
        if isinstance(data, str):
            data = data.encode("utf-8")

        # Многократное Base64-декодирование
        while True:
            try:
                fixed_data = fix_base64(data[::-1].decode("utf-8"))  # Base64 + реверс
                data = base64.b64decode(fixed_data)
            except Exception:
                break  # Если больше не Base64, выходим из цикла

        # Распаковка данных
        while True:
            try:
                data = try_decompress(data)
            except ValueError:
                break  # Если формат сжатия больше не определён, выходим из цикла

        # Диагностика: Сохранение промежуточных данных
        with open("intermediate_data.bin", "wb") as debug_file:
            debug_file.write(data)

        # Декодирование с помощью marshal
        unmarshaled_code = marshal.loads(data)
        return unmarshaled_code
    except Exception as e:
        print(f"Ошибка при деобфускации: {e}")
        return None


def main():
    # Выбор файла через GUI
    Tk().withdraw()  # Скрыть главное окно Tkinter
    file_path = filedialog.askopenfilename(title="Выберите файл для деобфускации")
    
    if not file_path:
        print("Файл не выбран.")
        return

    if not os.path.exists(file_path):
        print("Файл не найден.")
        return

    # Чтение содержимого файла
    with open(file_path, "r") as f:
        obfuscated_code = f.read()

    # Деобфускация
    deobfuscated_code = deobfuscate(obfuscated_code)

    if deobfuscated_code:
        print("Деобфусцированный код:")
        print(deobfuscated_code)

        # Сохранение результата в новый файл
        output_path = os.path.splitext(file_path)[0] + "_deobfuscated.py"
        with open(output_path, "w") as out_file:
            out_file.write(deobfuscated_code)
        print(f"Результат сохранён в: {output_path}")
    else:
        print("Не удалось деобфусцировать код.")


if __name__ == "__main__":
    main()

Новые изменения:

1. Диагностика промежуточных данных:

   • Добавлено сохранение содержимого данных после всех распаковок в файл intermediate_data.bin. Это позволит вручную проверить, что именно передается в marshal.loads.

2. Проверка структуры данных:

   • Промежуточные данные можно загрузить и посмотреть, являются ли они корректными маршализованными данными или содержат другие слои обфускации.

Рекомендации:

1. Проверьте содержимое intermediate_data.bin: Откройте файл с помощью текстового редактора или бинарного анализатора, чтобы понять, что это за данные. Возможно, потребуется дополнительная обработка.

2. Дополнительные уровни обфускации: Если данные не распознаются, попробуйте декодировать их вручную или предоставьте пример входного файла, чтобы я мог предложить конкретные шаги.

3. Совместимость версии Python: Если маршализованные данные были созданы в другой версии Python, это может быть причиной ошибки. Попробуйте использовать ту же версию Python, которая использовалась для обфускации.

Если у вас будут результаты или дополнительные вопросы, дайте знать!

Если marshal декодируется другим способом, это может указывать на измененный или кастомный процесс маршализации. Возможно, данные дополнительно зашифрованы, модифицированы, или сам marshal был заменен на нестандартный формат.

Для решения проблемы давайте добавим этап диагностики содержимого перед использованием marshal.loads, чтобы понять, с какими данными мы работаем, и предложим альтернативный метод декодирования.

Новый подход:

Мы будем выводить тип данных и некоторые их части для диагностики. Кроме того, попробуем обработать данные с учетом возможной модификации marshal.

Обновленный код:

python
import os
import base64
import zlib
import lzma
import gzip
import marshal
from tkinter import Tk, filedialog


def fix_base64(data):
    """Добавляет недостающие символы '=' для корректной длины Base64-строки."""
    missing_padding = len(data) % 4
    if missing_padding:
        data += "=" * (4 - missing_padding)
    return data


def try_decompress(data):
    """Пытается распаковать данные с использованием различных алгоритмов."""
    for decompress_func in [gzip.decompress, lzma.decompress, zlib.decompress]:
        try:
            return decompress_func(data)
        except Exception:
            continue
    raise ValueError("Не удалось определить формат сжатия")


def deobfuscate(data):
    try:
        # Если данные переданы как строка, преобразуем в байты
        if isinstance(data, str):
            data = data.encode("utf-8")

        # Многократное Base64-декодирование
        while True:
            try:
                fixed_data = fix_base64(data[::-1].decode("utf-8"))  # Base64 + реверс
                data = base64.b64decode(fixed_data)
            except Exception:
                break  # Если больше не Base64, выходим из цикла

        # Распаковка данных
        while True:
            try:
                data = try_decompress(data)
            except ValueError:
                break  # Если формат сжатия больше не определён, выходим из цикла

        # Диагностика: Проверяем данные перед marshal
        print("Тип данных перед marshal:", type(data))
        print("Размер данных:", len(data))
        print("Первые 100 байт данных:", data[:100])

        # Попробуем декодировать с marshal
        try:
            unmarshaled_code = marshal.loads(data)
            return unmarshaled_code
        except Exception as e:
            print("Ошибка при декодировании marshal:", e)
            print("Возможно, требуется другой метод обработки.")
            return None
    except Exception as e:
        print(f"Ошибка при деобфускации: {e}")
        return None


def main():
    # Выбор файла через GUI
    Tk().withdraw()  # Скрыть главное окно Tkinter
    file_path = filedialog.askopenfilename(title="Выберите файл для деобфускации")
    
    if not file_path:
        print("Файл не выбран.")
        return

    if not os.path.exists(file_path):
        print("Файл не найден.")
        return

    # Чтение содержимого файла
    with open(file_path, "r") as f:
        obfuscated_code = f.read()

    # Деобфускация
    deobfuscated_code = deobfuscate(obfuscated_code)

    if deobfuscated_code:
        print("Деобфусцированный код:")
        print(deobfuscated_code)

        # Сохранение результата в новый файл
        output_path = os.path.splitext(file_path)[0] + "_deobfuscated.py"
        with open(output_path, "w") as out_file:
            out_file.write(deobfuscated_code)
        print(f"Результат сохранён в: {output_path}")
    else:
        print("Не удалось деобфусцировать код.")


if __name__ == "__main__":
    main()

Новые изменения:

1. Диагностика содержимого:

   • Перед вызовом marshal.loads выводятся:
     • Тип данных.
     • Размер данных.
     • Первые 100 байт данных (для анализа структуры).

2. Обработка ошибок marshal:

   • Если marshal.loads не работает, выводится ошибка и предлагается дальнейшая обработка.

Как действовать дальше:

1. Проанализируйте вывод:

   • Если данные являются строкой (str), но не маршализованы, возможно, они содержат кастомное шифрование.
   • Если данные представляют бинарные данные (bytes), но формат отличается от стандартного marshal, потребуется понять, какой метод был использован для их создания.

2. Промежуточный результат:

   • Вы можете сохранить данные в файл intermediate_data.bin и проанализировать их с помощью сторонних инструментов, чтобы понять структуру.

3. Предоставьте пример:

   • Если это возможно, предоставьте пример (обезличенный) данных или структуры файла, чтобы уточнить метод декодирования.

Напишите, если увидите что-то интересное в диагностике, или если потребуется помощь в адаптации обработки.

Изменим ваш деобфускатор так, чтобы он поддерживал обработку данных, которые могут быть обфусцированы с использованием marshal, gzip, lzma, zlib, и base64. Прежде чем выполнять замену, добавим логику для многослойного декодирования.

Измененный код:

python
import os
import re
import base64
import zlib
import lzma
import gzip
import marshal

NOTE = "# DECODED BY HYPER X SQUAD >>> TOP 1 \n# @decoded_softs\n\n"

EXEC_PATTERN = r"exec$\(_$$b'(.+?)'$\)"
COMMENTS_PATTERN = r"#(.*?)\n"


def decode_layer(encoded_str: str) -> str:
    """Декодирование одного слоя с поддержкой base64, gzip, lzma, zlib и marshal"""
    try:
        # Попытка base64-декодирования
        encoded_str = base64.b64decode(encoded_str[::-1])  # Обратный порядок и Base64

        # Попытка декомпрессии с gzip, lzma, zlib
        for decompress_func in [gzip.decompress, lzma.decompress, zlib.decompress]:
            try:
                encoded_str = decompress_func(encoded_str)
            except Exception:
                continue

        # Попытка декодирования marshal
        try:
            decoded_code = marshal.loads(encoded_str)
            return decoded_code.decode()  # Возвращаем как строку
        except Exception:
            return encoded_str.decode()  # Если marshal не сработал, просто возвращаем как строку
    except Exception as e:
        print(f"Ошибка при декодировании: {e}")
        return encoded_str


def process_file(file_name: str, new_filename: str) -> bool:
    """Обработка файлов с поддержкой многослойной декодировки"""
    try:
        with open(file_name, 'r', encoding='utf-8') as f:
            code = f.read()

        pattern = r"_\s*=\s*lambda\s*__\s*:\s*.+?;exec$\(_$$b'(.*?)'$\)"

        match = re.search(pattern, code)

        if not match:
            print("Обфускация не обнаружена.")
            return False

        while re.search(EXEC_PATTERN, code):
            code = re.sub(EXEC_PATTERN, lambda m: decode_layer(m.group(1)), code)
            code = code.replace(f"_ = lambda __ : __import__('zlib').decompress(__[::-1]);", "")

        # Удаление комментариев
        while re.search(COMMENTS_PATTERN, code):
            code = re.sub(COMMENTS_PATTERN, "", code)

        # Сохранение результата
        with open(new_filename, 'w', encoding='utf-8') as f:
            f.write(NOTE + code.strip())

        return True

    except Exception as e:
        print(f"Ошибка! {e}")
        return False


def main() -> None:
    while True:
        file_name = input("Введите название файла: ").strip()

        if "." in file_name and not file_name.endswith(".py"):
            print("Файл должен иметь расширение .py ")
            continue

        file_name = f"{file_name}" if file_name.endswith(".py") else f"{file_name}.py"

        if not os.path.exists(file_name):
            print(f"Файл {file_name} не найден.\n")
        else:
            break

    new_filename = file_name[:-3] + '_DecodedByHXSRE.py'

    if process_file(file_name, new_filename):
        print(f"Успешно декодировано! Файл - {new_filename}")
    else:
        print("Деобфускация не удалась.")


if __name__ == "__main__":
    main()

Что изменено:

1. Поддержка нескольких алгоритмов декодирования:

   • Обрабатываются данные, закодированные с использованием base64, gzip, lzma, zlib, и marshal.

2. Рекурсивное декодирование:

   • Если данные содержат несколько слоев обфускации, каждый слой последовательно декодируется.

3. Удаление комментариев:

   • Удаляются комментарии, чтобы сохранить чистоту исходного кода.

4. Обработка ошибок:

   • Каждый этап декодирования проверяется, чтобы ошибки в одном методе не прерывали весь процесс.

5. Гибкость:

   • Код адаптирован для работы с любым сочетанием перечисленных методов обфускации.

Как использовать:

1. Сохраните скрипт как .py файл.
2. Запустите скрипт, указав путь к обфусцированному файлу Python.
3. Результат будет сохранен в новом файле с суффиксом _DecodedByHXSRE.py.

Попробуйте с вашим файлом и сообщите, если потребуется дополнительная настройка.