Кейлоггер под MS-DOS (11030-1)

Посмотреть архив целиком

Кейлоггер под MS-DOS

ЧАСТЬ 1. Что такое кейлоггер и с чем его едят?

Кейлоггер (key stroke programm, keylogger) - программа, которая запоминает список нажимаемых пользователем клавиш. Обычно, кейлоггеры работают без ведома пользователей (иначе зачем они нужны, вед юзер итак знает, что нажимает =) ). Обычно, такие программы используются для того, что бы узнать набираемый логин и пароль, причём, не обязательно при входе в систему (например на почтовом сервере). В данном конкретном случае, я буду говорить про написание кейлоггера только под MS-DOS. Почему? Всё очень просто: во многих учебных заведениях (в т.ч. и в ВУЗах) для обучения программированию используют компиляторы под ДОС (например, Borland C, Borland Pascal, etc.) Более того, в некоторых таких заведениях всё ещё пашет какой-нибудь старый Novell Netware, опять таки, под ДОС. Ну а самая главная причина, почему я выбрал ДОС - я собираюсь только продемонстрировать принципы работы таких программ. Если вам нужен кейлоггер под вынь, в яндексе найдёте туеву хучу таких... С мотивацией разобрались. Теперь, когда половина читателей стала набирать http://ya.ru/, я смело могу продолжать :)

ЧАСТЬ 2. Приступим

Итак, ещё раз... Наша цель - написать рабочий кейлоггер под DOS. Он должен отлавливать нажимаемые клавиши, а затем сохранять их в заданный файл. Для осуществления задуманного нам (не "нам" а "вам") нужно знать основы системного программирования под MS-DOS, и язык C (лучше всего Borland C++ v3.1). Под системным программированием я понимаю, прежде всего, знания из области: системные прерывания, порты ввода-вывода, работа с файлами и т.д. Если вы не знаете, что это такое, вам будет труднее понять написанное ниже.

Ладно. Хватит разговоров, пора начинать. Берём бутылку пива. Думаем... Что же происходит при нажатии клавиши? Любой системный программист скажет - аппаратное прерывание (и будет прав). Операционка ловит его и обрабатывает нажатую клавишу. Для того, что бы понять, какая клавиша нажата, используются порты ввода-вывода. А что должен сделать наш кейлоггер? Правильно! Он должен сам перехватить наше аппаратное прерывание от клавы, и прочитать клавишу из портов. А потом уже и операционка подгребёт, и тоже прочитает... Сразу оговорюсь, что такой способ не универсален. Например, какая-нить другая прога, которой надо считать клавиши, просто не даст нам обработать прерывание (установит свой обработчик, а наш не вызовет). Некоторые сверхсекьюрные проги это делают. Но об этом потом. А сейчас вспоминаем про функции getvect() и setvect(). Они позволяют определить используемый обработчик прерывания и установить свой соответственно. Обработчик - это наша с вами (или чужая) функция, которая обрабатывает прерывание. Как всё это работает?

1) Клава генерирует прерывание.

2) Вызывается обработчик. Его адрес хранится не далеко от начала памяти (зависит от прерывания), и система просто делает джамп по тому адресу, которое там видит. То есть что бы процессор сейчас не делал (кроме тех случаев, когда прерывания заблокированы вообще - RTFM Asm: cli/sti), система прердаст ему команду прыжка (джамп, jmp) по этому адресу, и он начнёт выполнять нашу функцию-обработчик.

3) Затем, процессор продолжит то, что делал раньше.

Об обработчиках по подробнее. Изначально, обработчик - это наша функция в операционной системе. То есть операционная система (далее ОС) сама обрабатывает нажатые клавиши (помещает их в буфер, выводит на экран и т.д.) Если мы ставим свой обработчик, то ОС в пролёте. Мы сами обрабатываем клавиши. Но! Если ОС не обработает прерывание (т.е. не вызывается её собственный обработчик) - будет хреново. В этом случае все другие программы не смогут узнать о нажатии клавиши, как и сама ОС. Мы не сможем даже набрать команду в консоли. Не сможем передвинуть маркер на другой файл в Norton Commander. В общем, остальным запущенным программам не будет известно, что пользователь нажал на клавишу. Как же быть? Элементарно, Ватсон! Из своего обработчика мы сделаем джамп на старый обработчик. А старый сделает джамп на тот, который был перед ним. И так далее. Последним обработчиком будет ОС (т.н. каскадное включение). Таким образом, сколько бы обработчиков не было, они выполнятся все по очереди. На радостях вспоминаем про не допитое пиво =) Таким образом поступают все системные программисты (я уже не про пиво... хотя... и это тоже). Перед тем как установить свой обработчик, узнаём адрес в памяти старого обработчика. После того, как сделали своё чёрное дело, вызываем следующий обработчик. (Вот приелись эти обработчики!).

Код на C++ (если не в Borland C++ V3.1, возможно, предётся что-нить поменять):

#include < dos.h > //Подключаем библиотеку dos.h для функций getvect() и setvect()

void interrupt far (*oldhdl)(...); //Здесь будет адрес старого обработчика (указатель на функцию)

void interrupt far newhdl(...) //А это наш обработчик

{

// ...

oldhdl(); //Не забудем передать управление старому обработчику

}

int main()

{

oldhdl=getvect(0x09); //Запоминаем старый обработчик прерывания нумбер 0x09 (т.е. от клавы)

setvect(0x09, newhdl); //Ставим новый обработчик (на то же прерывание)

return 0;

}

Так, ничего не забыли? Прокрутим в башке ещё раз. Функция main() определяет старый обработчик прерывания 0x09 (клава) и пишет в переменную oldhdl (которая является указателем на функцию). Затем ставит свой обработчик на то же (0x09) прерывание. Выходит из проги (return 0). Теперь, если происходит девятое прерывание, процессор делает джамп по адресу нашей функции newhdl(). Функция выполнит то, что будет вместо строки "//..." и вызовет старый обработчик. Дальше не наша проблема. Правильно? Нет! Ещё раз. Наша функция main() завершает работу. Значит, прога выгружается из памяти. Когда процессор сделает джамп на адрес функции newhdl(), то там её уже не будет! Нам нужно, что бы наш обработчик висел в памяти даже после завершения функции main(). Как это сделать? Думаем... Вспоминаем про библиотечную функцию keep(). Как это они в мануале хорошо подметили: Exits and remains resident. По русски: Выходит и остаётся резидентом. Помните, что такое резидент и TSR? TSR - Terminate and Stay Resident, завершиться и остаться резидентом в памяти. То есть не выгружать прогу из памяти даже после завершения функции main(). Если выполнить эту функцию перед завершением main(), то прога перестанет выполняться, но не умрёт. То, что доктор прописал. Сказано-сделано.

#include < dos.h > //Подключаем библиотеку dos.h для функций getvect() и setvect()

extern unsigned _heaplen = 1024;

extern unsigned _stklen = 1024;

void interrupt far (*oldhdl)(...); //Здесь будет адрес старого обработчика (указатель на функцию)

void interrupt far newhdl(...) //А это наш обработчик

{

// ...

oldhdl(); //Не забудем передать управление старому обработчику

}

int main()

{

oldhdl=getvect(0x09); //Запоминаем старый обработчик прерывания нумбер 0x09 (т.е. от клавы)

setvect(0x09, newhdl); //Ставим новый обработчик (на то же прерывание)

keep(0, _SS+(_SP/16)-_psp);

return 0;

}

Как видишь, изменились 3 строки: я добавил глобальное объявление двух очень важных переменных, ну и саму функцию keep(). Переменные эти определяют, сколько памяти резервировать для проги (куча и стек соответственно). Необходимо ставить как можно меньше, но так, что бы прога не глючила и работала. Дело в том, что резиденты лежат в памяти всегда, и если они сожрут её слишком много, ничего будет не запустить (возможно, что и command.com). Я поставил 1024. Далее мы видим функцию keep(). Первый её параметр - код разв... возврата. У меня, как и у вас, это - ноль. Затем идут strange letters, которые всего-лишь говорят, сколько памяти должно быть зарезервировано: _psp (Program Sement Prefix) - адрес начала нашей программы, _SS (Stack Segment) - сегмент стека, _SP (Stack Pointer) - указатель вершины стека. Конец нашей программы - это адрес вершины стека. На самом деле такое вычисление может оказаться не точным. Можно попробовать такой вариант: _SS + (_SP + запас_памяти) / 16 - _psp. Вот теперь половина готова. В общем-то прога уже будет работать, а для проверки можно вместо "//..." написать что-нибудь вроде sound(2600); delay(50); nosound();. Надеюсь, все поняли, что я имею в виду. При каждом срабатывании прерывания 0x09 будет короткий сигнал в спикере компа. Кстати, девятое прерывание срабатывает не только тогда, когда клавишу нажимают, но и когда её отпускают.

Пишим. Компилируем. Выходим из Borland C. Запускаем прогу. Если ничего не получилось, попробуйте ещё раз. Если опять не получилось, возможны варианты: 1) вы допустили ошибку, и 2) настройки компилятора не позволяют откомпилить прогу. В любом случае, читайте мануалы. И ещё одна вещь - не пытайтесь запускать подобные проги прямо из компилятора (Ctrl+F9), он всё равно вернёт все изменения в системе назад (в т.ч. и обработчики прерываний).

ЧАСТЬ 3. Мутим кейлоггер

Хорошо. Большую часть сделали. Теперь превратим это в нормальный кейлоггер. Для начала нам необходимо определить, какая именно клавиша была нажата. Результаты будут соответствовать не обычным кодам в соответствии с кодовой страницей (т.е. 'A'=65, 'B'=66...) а специальным, которые возвращает нам система, и которые уже потом переводятся в обычные. Например, код нажатой клавиши Esc будет равен единице. Почему я сказал именно "нажатой"? Потому, что если клавиша не нажата, то мы определяем последнюю нажатую. Код Esc в отпущенном состоянии равен 128 (если ничего не перепутал). Коды эти мы узнаём ассемблерской инструкцией in. В стандартных библиотеках С можно найти функции inport() и inportb(), которые реализуют эту инструкцию. Выглядит это так:


Случайные файлы

Файл
CBRR2123.DOC
System.doc
92368.rtf
145377.rtf
90947.rtf




Чтобы не видеть здесь видео-рекламу достаточно стать зарегистрированным пользователем.
Чтобы не видеть никакую рекламу на сайте, нужно стать VIP-пользователем.
Это можно сделать совершенно бесплатно. Читайте подробности тут.