serafim
/
dos
1
0
Fork 2
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Комментарии, status вынесен в глобалбную переменную (#6) 

Co-authored-by: AleksanovED <AleksanovED@loodsen.ru>
Co-authored-by: dr-wh0 <79003667309@yandex.ru>
Reviewed-on: https://gitea.serafimdev.com/serafim/dos/pulls/6
Reviewed-by: serafim <simasuh@gmail.com>
Co-authored-by: EgorALX <alexanoffegor@yandex.ru>
Co-committed-by: EgorALX <alexanoffegor@yandex.ru>
This commit is contained in:
EgorALX 2025-03-26 13:58:24 +03:00 committed by serafim
parent 556af1f1a7
commit 4c173756a0
1 changed files with 246 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

380
src/DosAtk.cpp
View File

@ -1,15 +1,14 @@
#include <iostream> #include <iostream> // Для работы с вводом-выводом (cout, cin и др.)
#include <stdlib.h> #include <stdlib.h> // Стандартная библиотека C (функции работы с памятью, преобразования типов и др.)
#include <string> #include <string> // Для работы со строками string
#include <chrono> #include <chrono> // Для работы с временем и таймерами
#include <ctime> #include <ctime> // Функции работы со временем C (time_t, localtime и др.)
#include <iomanip> #include <iomanip> // Для форматированного вывода (setw, setprecision и др.)
#include <getopt.h> #include <getopt.h> // Для разбора аргументов командной строки
#include <cctype> #include <cctype> // Функции для работы с символами (isdigit, isalpha и др.)
#include <curl/curl.h> #include <curl/curl.h> // Библиотека libcurl для HTTP-запросов (отправка в Telegram)
#include <iostream>
#include <string>
// Глобальные переменные
std::string attack_type; // Тип атаки: scan или syn std::string attack_type; // Тип атаки: scan или syn
std::string domain; // Доменное Имя std::string domain; // Доменное Имя
std::string ip; // Ip жертвы std::string ip; // Ip жертвы
@ -23,9 +22,12 @@ std::chrono::system_clock::time_point start_timestamp; // Начальное в
std::string log_msg; // Сообщение, которое будет записано в лог-файл std::string log_msg; // Сообщение, которое будет записано в лог-файл
std::string fin_msg; // Сообщение, которое будет выведено в консоль пользователю std::string fin_msg; // Сообщение, которое будет выведено в консоль пользователю
std::string msg; // Сообщение, которое будет отправлено в телеграм std::string msg; // Сообщение, которое будет отправлено в телеграм
int status; // Статус работы программы
// ====== end of DCL ====== // // ====== end of DCL ====== //
int my_check_params(int argc, char **argv)
{
// Данная процедура записывает в глобальные переменные параметры // Данная процедура записывает в глобальные переменные параметры
// (attack_type, domain, ip, port, log_file, telegram_id, telegram_token) проводимой атаки, поступившие при вызове программы // (attack_type, domain, ip, port, log_file, telegram_id, telegram_token) проводимой атаки, поступившие при вызове программы
// На вход получает int argc, char **argv, возвращает код выполнения // На вход получает int argc, char **argv, возвращает код выполнения
@ -38,8 +40,7 @@ std::string msg; // Сообщение, которое будет отправл
// -20 - Пользователь выбрал тип атаки флуд, но не ввел нужные параметры // -20 - Пользователь выбрал тип атаки флуд, но не ввел нужные параметры
// -101 - неизвестная опция или потерян аргумент, следует предложить вызвать флаг помощи // -101 - неизвестная опция или потерян аргумент, следует предложить вызвать флаг помощи
// -600 - пользователь ввел токен, но не id или наоборот // -600 - пользователь ввел токен, но не id или наоборот
int my_check_params(int argc, char **argv)
{
int status; int status;
int opt; int opt;
const char* short_options; const char* short_options;
@ -63,74 +64,87 @@ int my_check_params(int argc, char **argv)
debug_msg += argv[i]; debug_msg += argv[i];
debug_msg += " "; debug_msg += " ";
} }
printf("begin my_check_params (argc: %i, argv: %s)\n", argc, debug_msg.c_str()); printf("begin my_check_params (argc: %i, argv: %s)\n", argc, debug_msg.c_str()); // debug
// Обрабатываем аргументы командной строки с помощью 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': case 'a': // Обработка опции -a (--attack)
attack_type = optarg; attack_type = optarg; // Сохраняем тип атаки (scan/flood)
break; break;
case 'd': case 'd': // Обработка опции -d (--domain)
domain = optarg; domain = optarg; // Сохраняем доменное имя цели
break; break;
case 'i': case 'i': // Обработка опции -i (--ip)
ip = optarg; ip = optarg; // Сохраняем IP-адрес цели
break; break;
case 'p': case 'p': // Обработка опции -p (--port)
port = optarg; port = optarg; // Сохраняем номер порта
break; break;
case 'l': case 'l': // Обработка опции -l (--log)
log_file = optarg; log_file = optarg; // Сохраняем путь к лог-файлу
break; break;
case 't': case 't': // Обработка опции -t (--telegram)
telegram_id = optarg; telegram_id = optarg; // Сохраняем Telegram ID
break; break;
case 'b': case 'b': // Обработка опции -b (--token)
telegram_token = optarg; telegram_token = optarg; // Сохраняем токен бота Telegram
break; break;
case 'h': case 'h': // Обработка опции -h (--help)
status = 0; status = 0; // Устанавливаем статус "показать справку"
break; break;
case '?': case '?': // Обработка неизвестной опции
status = -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") {
status = -1; status = -1; // Некорректный тип атаки
} }
// Для сканирования портов должна быть указана цель (домен или IP)
else if (attack_type == "scan" && domain.empty() && ip.empty()) { else if (attack_type == "scan" && domain.empty() && ip.empty()) {
status = -10; status = -10; // Не указана цель для сканирования
} }
// Для флуд-атаки должна быть указана цель (домен или IP)
else if (attack_type == "flood" && domain.empty() && ip.empty()) { else if (attack_type == "flood" && domain.empty() && ip.empty()) {
status = -20; status = -20; // Не указана цель для флуда
} }
else if ((!telegram_id.empty() && telegram_token.empty()) || (telegram_id.empty() && !telegram_token.empty())) { // Проверяем, что если указан Telegram ID или токен, то должны быть указаны оба
status = -600; else if ((!telegram_id.empty() && telegram_token.empty()) ||
(telegram_id.empty() && !telegram_token.empty())) {
status = -600; // Неполные данные для Telegram
} }
// Если все проверки пройдены и тип атаки - сканирование
else if (attack_type == "scan") { else if (attack_type == "scan") {
status = 1; status = 1; // Валидные параметры для сканирования
} }
// Если все проверки пройдены и тип атаки - флуд
else if (attack_type == "flood") { else if (attack_type == "flood") {
status = 2; status = 2; // Валидные параметры для флуда
} }
} }
printf("end my_check_params status: %i\n", status); printf("end my_check_params status: %i\n", status); // debug
return status; return status;
} }
void my_diag()
{
// Данная функция вызывается в случае ошибки на каком-то этапе и на основании поступившего кода, // Данная функция вызывается в случае ошибки на каком-то этапе и на основании поступившего кода,
// формирует сообщение с описанием произошедшей ошибки // формирует сообщение с описанием произошедшей ошибки
void my_diag(int status)
{ // Отладочный вывод - начало работы функции (можно отключить в релизной версии)
printf("begin my_diag (status: %i)\n", status); printf("begin my_diag, status: %i\n", status); // debug
// Выбор сообщения в зависимости от кода ошибки
switch (status) 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"
@ -142,256 +156,302 @@ void my_diag(int status)
" -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: case -20: // Отсутствуют обязательные параметры для SYN flood атаки
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: case -600: // Неполные данные для Telegram-уведомлений
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 // Функция для экранирования специальных символов в строке перед использованием в JSON
// Принимает: const std::string& s - исходная строка для обработки
// Возвращает: std::string - строка с экранированными спецсимволами
std::string escape_json(const std::string& s) { std::string escape_json(const std::string& s) {
std::string result; std::string result; // Результирующая строка с экранированными символами
// Проходим по каждому символу входной строки
for (char c : s) { for (char c : s) {
// Обрабатываем специальные символы JSON
switch (c) { switch (c) {
case '"': result += "\\\""; break; case '"': result += "\\\""; break; // Экранирование двойных кавычек
case '\\': result += "\\\\"; break; case '\\': result += "\\\\"; break; // Экранирование обратного слеша
case '\b': result += "\\b"; break; case '\b': result += "\\b"; break; // Экранирование backspace
case '\f': result += "\\f"; break; case '\f': result += "\\f"; break; // Экранирование formfeed
case '\n': result += "\\n"; break; case '\n': result += "\\n"; break; // Экранирование новой строки
case '\r': result += "\\r"; break; case '\r': result += "\\r"; break; // Экранирование возврата каретки
case '\t': result += "\\t"; break; case '\t': result += "\\t"; break; // Экранирование табуляции
default: result += c; break; default: result += c; break; // Все остальные символы добавляем как есть
} }
} }
return result; return result; // Возвращаем обработанную строку
} }
// Проверка, является ли строка числом (включая отрицательные)
bool is_numeric(const std::string& s) { bool is_numeric(const std::string& s) {
size_t start; // Проверка, является ли строка числом (включая отрицательные)
if (s.empty()) return false;
size_t start; // Индекс, с которого начинать проверку цифр
if (s.empty()) return false; // Пустая строка не может быть числом
// Проверяем наличие знака минус в начале
start = 0; start = 0;
if (s[0] == '-') { if (s[0] == '-') {
// Строка из одного минуса не является числом
if (s.size() == 1) return false; if (s.size() == 1) return false;
// Если минус есть, начинаем проверку с следующего символа
start = 1; start = 1;
} }
// Проверяем все оставшиеся символы на цифры
for (size_t i = start; i < s.size(); ++i) { for (size_t i = start; i < s.size(); ++i) {
// Найден нецифровой символ - строка не число
if (!isdigit(s[i])) return false; if (!isdigit(s[i])) return false;
} }
// Все проверки пройдены - строка является числом
return true; return true;
} }
int my_msg() { int my_msg() {
CURL* curl; // Инициализация локальных переменных для работы с CURL
std::string escaped_msg;
std::cout << msg << std::endl;
std::string chat_id_field;
std::string json_data;
struct curl_slist* headers;
headers = nullptr;
long http_code;
CURLcode res;
CURL* curl; // Указатель на CURL-объект
std::string escaped_msg; // Экранированное сообщение для JSON
std::cout << msg << std::endl; // Вывод сообщения в консоль (для отладки)
std::string chat_id_field; // Поле chat_id для JSON
std::string json_data; // Итоговый JSON для отправки
struct curl_slist* headers; // Заголовки HTTP-запроса
headers = nullptr; // Инициализация заголовков
long http_code; // HTTP-код ответа
CURLcode res; // Код результата CURL-операции
// Проверка наличия обязательных параметров Telegram
if (telegram_token.empty() || telegram_id.empty()) { if (telegram_token.empty() || telegram_id.empty()) {
return 0; // Интеграция не настроена return 0; // Интеграция с Telegram не настроена (отсутствует токен или ID)
} }
// Инициализация CURL
curl = curl_easy_init(); curl = curl_easy_init();
if (!curl) return 6; // Ошибка инициализации CURL if (!curl) return 6; // Ошибка инициализации CURL
// Экранируем сообщение // Экранирование спецсимволов в сообщении для JSON
escaped_msg = escape_json(msg); escaped_msg = escape_json(msg);
// Формируем поле chat_id // Формирование поля chat_id в зависимости от типа ID (число или строка)
if (is_numeric(telegram_id)) { if (is_numeric(telegram_id)) {
chat_id_field = "\"chat_id\": " + telegram_id; chat_id_field = "\"chat_id\": " + telegram_id; // Числовой ID
} else { } else {
chat_id_field = "\"chat_id\": \"" + telegram_id + "\""; chat_id_field = "\"chat_id\": \"" + telegram_id + "\""; // Строковый ID
} }
// Формируем JSON // Сборка JSON-запроса
json_data = "{" + chat_id_field + ", \"text\": \"" + escaped_msg + "\"}"; json_data = "{" + chat_id_field + ", \"text\": \"" + escaped_msg + "\"}";
// Настраиваем заголовоки // Установка заголовка Content-Type
headers = curl_slist_append(headers, "Content-Type: application/json"); headers = curl_slist_append(headers, "Content-Type: application/json");
// Настраиваем параметры CURL // Настройка параметров CURL-запроса
curl_easy_setopt(curl, CURLOPT_URL, ("https://api.telegram.org/bot" + telegram_token + "/sendMessage").c_str()); 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); curl_easy_setopt(curl, CURLOPT_POST, 1L); // Использовать POST-метод
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_data.c_str()); curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_data.c_str()); // Тело запроса (JSON)
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers); curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers); // Заголовки запроса
curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl/7.68.0"); 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 { curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, [](void*, size_t size, size_t nmemb, void*) -> size_t {
return size * nmemb; return size * nmemb;
}); });
// Выполняем запрос // Выполнение HTTP-запроса
res = curl_easy_perform(curl); res = curl_easy_perform(curl);
// Получение HTTP-кода ответа
http_code = 0; http_code = 0;
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code); curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
// Освобождаем ресурсы // Освобождение ресурсов
curl_slist_free_all(headers); curl_slist_free_all(headers); // Очистка заголовков
curl_easy_cleanup(curl); curl_easy_cleanup(curl); // Завершение работы CURL
if (res != CURLE_OK) return 5; // Обработка ошибок CURL
if (res != CURLE_OK) return 5; // Ошибка выполнения запроса
// Обработка HTTP-кодов ответа
switch (http_code) { switch (http_code) {
case 200: return 0; case 200: return 0; // Успешный запрос
case 401: return 1; case 401: return 1; // Ошибка авторизации (неверный токен)
case 400: return 2; case 400: return 2; // Неверный запрос
case 404: return 3; case 404: return 3; // Ресурс не найден
default: default:
if (http_code >= 500) return 4; if (http_code >= 500) return 4; // Ошибка сервера
return 4; return 4; // Прочие ошибки
} }
} }
// Данная функция записывает в файл лога сообщение
int my_log() int my_log()
{ {
// Данная функция записывает в файл лога сообщение
return 0; return 0;
} }
// Данная функция завершает программу и рассчитывает итоговое время выполнения программы
void my_fin() void my_fin()
{ {
// Данная функция завершает программу и рассчитывает итоговое время выполнения программы
// Фиксируем время окончания работы программы
auto end_timestamp = std::chrono::system_clock::now(); auto end_timestamp = std::chrono::system_clock::now();
// Преобразуем время окончания в time_t и миллисекунды
auto end_time_t = std::chrono::system_clock::to_time_t(end_timestamp); 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; auto end_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_timestamp.time_since_epoch()) % 1000;
// Вычисляем продолжительность работы программы
auto duration = end_timestamp - start_timestamp; auto duration = end_timestamp - start_timestamp;
// Разбиваем продолжительность на компоненты
auto hours = std::chrono::duration_cast<std::chrono::hours>(duration); auto hours = std::chrono::duration_cast<std::chrono::hours>(duration);
auto minutes = std::chrono::duration_cast<std::chrono::minutes>(duration % std::chrono::hours(1)); auto minutes = std::chrono::duration_cast<std::chrono::minutes>(duration % std::chrono::hours(1));
auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration % std::chrono::minutes(1)); auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration % std::chrono::minutes(1));
auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(duration % std::chrono::seconds(1)); auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(duration % std::chrono::seconds(1));
// Выводим информацию о времени работы
std::cout << "Worked for "; std::cout << "Worked for ";
// Для коротких периодов (<2 минут) выводим в секундах с дробной частью
if (duration < std::chrono::minutes(2)) { if (duration < std::chrono::minutes(2)) {
double total_seconds = std::chrono::duration<double>(duration).count(); double 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 { } else {
// Для длительных периодов выводим в формате ЧЧ:ММ:СС.мс
if (hours.count() > 0) std::cout << hours.count() << "h "; if (hours.count() > 0) std::cout << hours.count() << "h ";
if (minutes.count() > 0) std::cout << minutes.count() << "m "; if (minutes.count() > 0) std::cout << minutes.count() << "m ";
std::cout << seconds.count() << "s " << milliseconds.count() << "ms"; std::cout << seconds.count() << "s " << milliseconds.count() << "ms";
} }
std::cout << std::endl; 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) << end_ms.count() << std::endl; << "." << std::setfill('0') << std::setw(3) << end_ms.count() << std::endl;
// Завершаем программу с кодом 0 (успешное завершение)
std::exit(0); std::exit(0);
} }
// Данная процедура сопостовляет доменное имя с IP
int my_dns() int my_dns()
{ {
// Данная процедура сопостовляет доменное имя с IP
return 0; return 0;
} }
// Данная процедура выполняет TCP SYN Flood атаку
int my_tcp_syn() int my_tcp_syn()
{ {
// Данная процедура выполняет TCP SYN Flood атаку
return 2; return 2;
} }
// Данная процедура выполняет UDP Flood (port scanning) атаку
int my_udp() int my_udp()
{ {
// Данная процедура выполняет UDP Flood (port scanning) атаку
return 2; return 2;
} }
// Тело программы
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
int check_params_status; // Главная функция программы - точка входа
int log_status;
int dns_status;
int udp_status;
int tcp_syn_status;
// ====== Тело программы ====== // // Объявление переменных для хранения статусов операций
n_ok_requests = 0; int log_status; // Статус записи в лог
n_fail_requests = 0; int dns_status; // Статус DNS-разрешения
start_timestamp = std::chrono::system_clock::now(); int udp_status; // Статус UDP-атаки
int tcp_syn_status; // Статус TCP SYN-атаки
time_t now_time_t; // ====== Инициализация программы ====== //
now_time_t = std::chrono::system_clock::to_time_t(start_timestamp); n_ok_requests = 0; // Счетчик успешных запросов
n_fail_requests = 0; // Счетчик неудачных запросов
start_timestamp = std::chrono::system_clock::now(); // Засекаем время начала
status = 0; // Статус программы
std::chrono::milliseconds ms; // Получаем текущее время в различных форматах
ms = std::chrono::duration_cast<std::chrono::milliseconds>(start_timestamp.time_since_epoch()) % 1000; time_t now_time_t = std::chrono::system_clock::to_time_t(start_timestamp);
auto 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", 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_year + 1900, // Год (с 1900)
std::localtime(&now_time_t)->tm_mon + 1, std::localtime(&now_time_t)->tm_mon + 1, // Месяц (0-11)
std::localtime(&now_time_t)->tm_mday, std::localtime(&now_time_t)->tm_mday, // День месяца
std::localtime(&now_time_t)->tm_hour, std::localtime(&now_time_t)->tm_hour, // Часы
std::localtime(&now_time_t)->tm_min, std::localtime(&now_time_t)->tm_min, // Минуты
std::localtime(&now_time_t)->tm_sec, std::localtime(&now_time_t)->tm_sec, // Секунды
ms.count()); ms.count()); // Миллисекунды
check_params_status = my_check_params(argc, argv); // ====== Основная логика программы ====== //
switch (check_params_status) // 1. Проверяем параметры командной строки
status = my_check_params(argc, argv);
// Обрабатываем результат проверки параметров
switch (status)
{ {
case 1: case 1: // Режим сканирования портов (UDP)
// Пытаемся разрешить DNS (если указано доменное имя)
dns_status = my_dns(); dns_status = my_dns();
if (dns_status == 0)
if (dns_status == 0) // Если DNS разрешен успешно
{ {
// Запускаем цикл UDP-атаки
while (udp_status = my_udp()) while (udp_status = my_udp())
{ {
if (udp_status == 2) if (udp_status == 2) // Код завершения атаки
{ {
break; break;
} }
else if (udp_status < 0) else if (udp_status < 0) // Обработка ошибок
{ {
my_diag(udp_status); status = udp_status;
log_status = my_log(); my_diag(); // Выводим диагностику
if (log_status == 1) log_status = my_log(); // Пытаемся записать в лог
if (log_status == 1) // Если требуется уведомление
{ {
my_msg(); my_msg(); // Отправляем сообщение
} }
} }
} }
log_status = my_log(); // Завершающие действия после атаки
my_msg(); log_status = my_log(); // Логируем завершение
my_fin(); my_msg(); // Отправляем финальное сообщение
my_fin(); // Корректно завершаем программу
} }
else if (dns_status == 1) else if (dns_status == 1) // Ошибка DNS-разрешения
{ {
my_diag(check_params_status); my_diag(); // Выводим ошибку
log_status = my_log(); log_status = my_log(); // Логируем ошибку
if (log_status == 0){
my_fin(); if (log_status == 0) { // Если не требуется уведомление
my_fin(); // Просто завершаем программу
} }
else if (log_status == 1) else if (log_status == 1) // Если требуется уведомление
{ {
my_msg(); my_msg(); // Отправляем сообщение
my_fin(); my_fin(); // Завершаем программу
} }
} }
break; break;
case 2:
case 2: // Режим SYN-флуда (TCP)
// Аналогичная логика как для UDP-режима
dns_status = my_dns(); dns_status = my_dns();
if (dns_status == 0) if (dns_status == 0)
{ {
while (tcp_syn_status = my_tcp_syn()) while (tcp_syn_status = my_tcp_syn())
@ -402,7 +462,8 @@ int main(int argc, char **argv)
} }
else if (tcp_syn_status < 0) else if (tcp_syn_status < 0)
{ {
my_diag(tcp_syn_status); status = tcp_syn_status;
my_diag();
log_status = my_log(); log_status = my_log();
if (log_status == 1) if (log_status == 1)
{ {
@ -416,7 +477,7 @@ int main(int argc, char **argv)
} }
else if (dns_status == 1) else if (dns_status == 1)
{ {
my_diag(check_params_status); my_diag();
log_status = my_log(); log_status = my_log();
if (log_status == 0) if (log_status == 0)
{ {
@ -429,19 +490,22 @@ int main(int argc, char **argv)
} }
} }
break; break;
default:
my_diag(check_params_status); default: // Некорректные параметры или запрос справки
log_status = my_log(); my_diag(); // Выводим диагностику
if (log_status == 0) log_status = my_log(); // Логируем событие
if (log_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;
} }
return 0;
return 0; // Возвращаем код успешного завершения
} }