my_msg

Co-authored-by: tieshagr <tieshagr@student.21>
Co-authored-by: root <root@simasuh.fvds.ru>
Reviewed-on: https://gitea.serafimdev.com/serafim/dos/pulls/4

.gitignore

@@ -1,38 +1 @@
-# Игнорировать бинарные файлы
+.vscode
-*.exe
-*.out
-*.app
-*.o
-*.a
-*.so
-*.dll
-*.dylib
-
-# Игнорировать папку .vscode
-.vscode/
-
-# Игнорировать сгенерированные файлы
-build/
-bin/
-obj/
-
-# Игнорировать системные файлы
-.DS_Store
-Thumbs.db
-
-# Игнорировать файлы проекта IDE
-*.sln
-*.vcxproj
-*.vcxproj.filters
-*.vcxproj.user
-
-# Игнорировать временные файлы
-*.swp
-*.swo
-*~
-*.bak
-
-# Игнорировать логи и результаты тестов
-*.log
-*.tmp
-test-results/

.vscode/settings.json

@@ -1,67 +0,0 @@
-{
-    "files.associations": {
-        "algorithm": "cpp",
-        "atomic": "cpp",
-        "bit": "cpp",
-        "cctype": "cpp",
-        "charconv": "cpp",
-        "chrono": "cpp",
-        "clocale": "cpp",
-        "cmath": "cpp",
-        "compare": "cpp",
-        "concepts": "cpp",
-        "cstddef": "cpp",
-        "cstdint": "cpp",
-        "cstdio": "cpp",
-        "cstdlib": "cpp",
-        "cstring": "cpp",
-        "ctime": "cpp",
-        "cwchar": "cpp",
-        "exception": "cpp",
-        "format": "cpp",
-        "forward_list": "cpp",
-        "initializer_list": "cpp",
-        "iomanip": "cpp",
-        "ios": "cpp",
-        "iosfwd": "cpp",
-        "iostream": "cpp",
-        "istream": "cpp",
-        "iterator": "cpp",
-        "limits": "cpp",
-        "locale": "cpp",
-        "map": "cpp",
-        "memory": "cpp",
-        "mutex": "cpp",
-        "new": "cpp",
-        "optional": "cpp",
-        "ostream": "cpp",
-        "ratio": "cpp",
-        "sstream": "cpp",
-        "stdexcept": "cpp",
-        "stop_token": "cpp",
-        "streambuf": "cpp",
-        "string": "cpp",
-        "system_error": "cpp",
-        "thread": "cpp",
-        "tuple": "cpp",
-        "type_traits": "cpp",
-        "typeinfo": "cpp",
-        "utility": "cpp",
-        "vector": "cpp",
-        "xfacet": "cpp",
-        "xiosbase": "cpp",
-        "xlocale": "cpp",
-        "xlocbuf": "cpp",
-        "xlocinfo": "cpp",
-        "xlocmes": "cpp",
-        "xlocmon": "cpp",
-        "xlocnum": "cpp",
-        "xloctime": "cpp",
-        "xmemory": "cpp",
-        "xstddef": "cpp",
-        "xstring": "cpp",
-        "xtr1common": "cpp",
-        "xtree": "cpp",
-        "xutility": "cpp"
-    }
-}

README.md

@@ -7,4 +7,8 @@ git add * # Добавляем написанный код в комит
 git commit -m 'Написал код' # Комитим в локальную ветку
 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

@@ -0,0 +1,2 @@
+g++ src/DosAtk.cpp -o DosAtk -lcurl
+./DosAtk "$@"

src/DosAtk.cpp

@@ -0,0 +1,447 @@
+#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>
+
+std::string attack_type; // Тип атаки: scan или syn
+std::string domain; // Доменное Имя
+std::string ip; // Ip жертвы
+std::string port; // Порт
+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; // Сообщение, которое будет отправлено в телеграм 
+
+// ====== end of DCL ====== //
+
+// Данная процедура записывает в глобальные переменные параметры 
+// (attack_type, domain, ip, port, log_file, telegram_id, telegram_token) проводимой атаки, поступившие при вызове программы
+// На вход получает int argc, char **argv, возвращает код выполнения
+// Коды возврата:
+// 2 - Атака флуд, все нужные опции есть
+// 1 - Атака порт скан, все нужные опции есть
+// 0 - нужна помощь
+// -1 - пользователь не ввел тип атаки или ввел неверный тип атаки
+// -10 - Пользователь выбрал тип атаки порт сканнинг, но не ввел нужные параметры
+// -20 - Пользователь выбрал тип атаки флуд, но не ввел нужные параметры
+// -101 - неизвестная опция или потерян аргумент, следует предложить вызвать флаг помощи
+// -600 -  пользователь ввел токен, но не id или наоборот
+int my_check_params(int argc, char **argv)
+{
+    int status;
+    int opt;
+    const char* short_options;
+    short_options = "a:d:i:p:l:t:b:h";
+    const struct option long_options[] = 
+    {
+        {"attack",    required_argument, NULL, 'a'},
+        {"domain",    required_argument, NULL, 'd'},
+        {"ip",        required_argument, NULL, 'i'},
+        {"port",      required_argument, NULL, 'p'},
+        {"log",       required_argument, NULL, 'l'},
+        {"telegram",  required_argument, NULL, 't'},
+        {"token",     required_argument, NULL, 'b'},
+        {"help",      no_argument,       NULL, 'h'},
+        {NULL,     0,                 NULL,  0}
+    };
+
+    std::string debug_msg;
+    debug_msg = "";
+    for (int i = 0; i < argc; i++) {
+        debug_msg += argv[i];
+        debug_msg += " ";
+    }
+    printf("begin my_check_params (argc: %i, argv: %s)\n", argc, debug_msg.c_str());
+
+    while ((opt = getopt_long(argc, argv, short_options, long_options, NULL)) != -1) {
+        switch (opt) {
+        case 'a':
+            attack_type = optarg;
+            break;
+        case 'd':
+            domain = optarg;
+            break;
+        case 'i':
+            ip = optarg;
+            break;
+        case 'p':
+            port = optarg;
+            break;
+        case 'l':
+            log_file = optarg;
+            break;
+        case 't':
+            telegram_id = optarg;
+            break;
+        case 'b':
+            telegram_token = optarg;
+            break;
+        case 'h':
+            status = 0;
+            break;
+        case '?':
+            status = -101;
+            break;
+        }
+    }
+
+    if (status != 0 && status != -101)
+    {
+        if (attack_type != "flood" && attack_type != "scan") {
+            status = -1;
+        }
+        else if (attack_type == "scan" && domain.empty() && ip.empty()) {
+            status = -10;
+        }
+        else if (attack_type == "flood" && domain.empty() && ip.empty()) {
+            status = -20;
+        }
+        else if ((!telegram_id.empty() && telegram_token.empty()) || (telegram_id.empty() && !telegram_token.empty())) {
+            status = -600;
+        }
+        else if (attack_type == "scan") {
+            status = 1;
+        }
+        else if (attack_type == "flood") {
+            status = 2;
+        }
+    }
+
+    printf("end my_check_params status: %i\n", status);
+    return status;
+}
+
+// Данная функция вызывается в случае ошибки на каком-то этапе и на основании поступившего кода, 
+// формирует сообщение с описанием произошедшей ошибки
+void my_diag(int status)
+{
+    printf("begin my_diag (status: %i)\n", status);
+    switch (status)
+    {
+    case 0:
+        printf("Usage: ./DosAtk [options]\n"
+            "Required:\n"
+            "  -a, --attack TYPE    Type of attack (scan|flood)\n"
+            "  -d, --domain DOMAIN  Target domain\n"
+            "  -i, --ip IP          Target IP\n"
+            "  -p, --port PORT      Port. Required only for flood type!\n"
+            "Optional:\n"
+            "  -l, --log FILE       Log file\n"
+            "  -t, --telegram ID    Telegram ID\n"
+            "  -b, --token TOKEN    Telegram bot token\n");
+        break;
+    case -1:
+        printf("Error: Invalid attack type!\n--help for more info\n");
+        break;
+    case -10:
+        printf("Error: Missing required parameters for port scanning!\n--help for more info\n");
+        break;
+    case -20:
+        printf("Error: Missing required parameters for tcp syn dos attack!\n--help for more info\n");
+        break;
+    case -101:
+        printf("Error: Unknown option!\n.--help for info\n");
+        break;
+    case -600:
+        printf("Error: To use telegram integration both telegram_id and telegram_token have to be provided!\n.--help for info\n");
+        break;
+    }
+    printf("end my_diag\n");
+}
+
+// Функция для экранирования спецсимволов в JSON
+std::string escape_json(const std::string& s) {
+    std::string result;
+    for (char c : s) {
+        switch (c) {
+            case '"':  result += "\\\""; break;
+            case '\\': result += "\\\\"; break;
+            case '\b': result += "\\b";  break;
+            case '\f': result += "\\f";  break;
+            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;
+    if (s.empty()) return false;
+    
+    start = 0;
+    if (s[0] == '-') {
+        if (s.size() == 1) return false;
+        start = 1;
+    }
+    
+    for (size_t i = start; i < s.size(); ++i) {
+        if (!isdigit(s[i])) return false;
+    }
+    return true;
+}
+
+int my_msg() {
+    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;
+
+    if (telegram_token.empty() || telegram_id.empty()) {
+        return 0; // Интеграция не настроена
+    }
+
+    curl = curl_easy_init();
+    if (!curl) return 6; // Ошибка инициализации CURL
+
+    // Экранируем сообщение
+    escaped_msg = escape_json(msg);
+    
+    // Формируем поле chat_id
+    if (is_numeric(telegram_id)) {
+        chat_id_field = "\"chat_id\": " + telegram_id;
+    } else {
+        chat_id_field = "\"chat_id\": \"" + telegram_id + "\"";
+    }
+    
+    // Формируем JSON
+    json_data = "{" + chat_id_field + ", \"text\": \"" + escaped_msg + "\"}";
+    // Настраиваем заголовоки
+    headers = curl_slist_append(headers, "Content-Type: application/json");
+
+    // Настраиваем параметры CURL
+    curl_easy_setopt(curl, CURLOPT_URL, ("https://api.telegram.org/bot" + telegram_token + "/sendMessage").c_str());
+    curl_easy_setopt(curl, CURLOPT_POST, 1L);
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_data.c_str());
+    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+    curl_easy_setopt(curl, CURLOPT_USERAGENT, "libcurl/7.68.0");
+    
+    // Игнорируем вывод ответа
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, [](void*, size_t size, size_t nmemb, void*) -> size_t {
+        return size * nmemb;
+    });
+
+    // Выполняем запрос
+    res = curl_easy_perform(curl);
+
+    http_code = 0;
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
+
+    // Освобождаем ресурсы
+    curl_slist_free_all(headers);
+    curl_easy_cleanup(curl);
+
+    if (res != CURLE_OK) return 5;
+    
+    switch (http_code) {
+        case 200: return 0;
+        case 401: return 1;
+        case 400: return 2;
+        case 404: return 3;
+        default:  
+            if (http_code >= 500) return 4;
+            return 4;
+    }
+}
+// Данная функция записывает в файл лога сообщение
+int my_log()
+{
+    return 0;
+}
+
+// Данная функция завершает программу и рассчитывает итоговое время выполнения программы 
+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;
+
+    auto duration = end_timestamp - start_timestamp;
+    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 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));
+
+    std::cout << "Worked for ";
+    if (duration < std::chrono::minutes(2)) {
+        double total_seconds = std::chrono::duration<double>(duration).count();
+        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";
+    }
+    std::cout << std::endl;
+
+    std::cout << "Sent " << (n_ok_requests + n_fail_requests) << " requests (" 
+              << 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::setfill('0') << std::setw(3) << end_ms.count() << std::endl;
+
+    std::exit(0);
+}
+
+// Данная процедура сопостовляет доменное имя с IP 
+int my_dns()
+{
+    return 0;
+}
+
+// Данная процедура выполняет TCP SYN Flood атаку
+int my_tcp_syn()
+{
+    return 2;
+}
+
+// Данная процедура выполняет UDP Flood (port scanning) атаку
+int my_udp()
+{
+    return 2;
+}
+
+// Тело программы
+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;
+    n_fail_requests = 0;
+    start_timestamp = std::chrono::system_clock::now();
+
+    time_t now_time_t;
+    now_time_t = std::chrono::system_clock::to_time_t(start_timestamp);
+
+    std::chrono::milliseconds ms;
+    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:
+        dns_status = my_dns();
+        if (dns_status == 0)
+        {
+            while (udp_status = my_udp())
+            {
+                if (udp_status == 2)
+                {
+                    break;
+                }
+                else if (udp_status < 0)
+                {
+                    my_diag(udp_status);
+                    log_status = my_log();
+                    if (log_status == 1)
+                    {
+                        my_msg();
+                    }
+                }
+            }
+            log_status = my_log();
+            my_msg();
+            my_fin();
+        }
+        else if (dns_status == 1)
+        {
+            my_diag(check_params_status);
+            log_status = my_log();
+            if (log_status == 0){
+                my_fin();
+            }
+            else if (log_status == 1)
+            {
+                my_msg();
+                my_fin();
+            }
+        }
+        break;
+    case 2:
+        dns_status = my_dns();
+        if (dns_status == 0)
+        {
+            while (tcp_syn_status = my_tcp_syn())
+            {
+                if (tcp_syn_status == 2)
+                {
+                    break;
+                }
+                else if (tcp_syn_status < 0)
+                {
+                    my_diag(tcp_syn_status);
+                    log_status = my_log();
+                    if (log_status == 1)
+                    {
+                        my_msg();
+                    }
+                }
+            }
+            log_status = my_log();
+            my_msg();
+            my_fin();
+        }
+        else if (dns_status == 1)
+        {
+            my_diag(check_params_status);
+            log_status = my_log();
+            if (log_status == 0)
+            {
+                my_fin();
+            }
+            else if (log_status == 1)
+            {
+                my_msg();
+                my_fin();
+            }
+        }
+        break;
+    default:
+        my_diag(check_params_status);
+        log_status = my_log();
+        if (log_status == 0)
+        {
+            my_fin();
+        }
+        else if (log_status == 1)
+        {
+            my_msg();
+            my_fin();
+        }
+        break;
+    }
+    return 0;
+}

src/Makefile

@@ -1,13 +0,0 @@
-CXX = g++
-CXXFLAGS = -Iinclude/
-
-all: my_app
-
-my_app:
-	$(CXX) $(CXXFLAGS) ./my_start.cpp ./my_fin.cpp ./main.cpp -o my_app
-
-rebuild:
-	rm -f my_app && make my_app
-
-clean:
-	rm -f my_app

src/main.cpp

@@ -1,22 +0,0 @@
-#include <iostream>
-#include <thread>
-#include <chrono>
-#include "my_start.hpp"
-
-int main() {
-
-    my_start();
-
-    for (int i = 0; i < 5; ++i) {
-        std::this_thread::sleep_for(std::chrono::seconds(25));
-        if (i % 2 == 0) {
-            n_ok_requests++;
-        } else {
-            n_fail_requests++;
-        }
-    }
-
-    my_fin();
-
-    return 0;
-}

src/my_fin.cpp

@@ -1,34 +0,0 @@
-#include "my_start.hpp"
-#include <cstdlib>
-
-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;
-
-    auto duration = end_timestamp - start_timestamp;
-    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 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));
-
-    std::cout << "Worked for ";
-    if (duration < std::chrono::minutes(2)) {
-        double total_seconds = std::chrono::duration<double>(duration).count();
-        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";
-    }
-    std::cout << std::endl;
-
-    std::cout << "Sent " << (n_ok_requests + n_fail_requests) << " requests (" 
-              << 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::setfill('0') << std::setw(3) << end_ms.count() << std::endl;
-
-    std::exit(0);
-}

src/my_start.cpp

@@ -1,18 +0,0 @@
-#include "my_start.hpp"
-
-int n_ok_requests = 0;
-int n_fail_requests = 0;
-std::chrono::system_clock::time_point start_timestamp;
-
-void my_start() {
-    n_ok_requests = 0;
-    n_fail_requests = 0;
-    start_timestamp = std::chrono::system_clock::now();
-
-    auto now = std::chrono::system_clock::now();
-    auto now_time_t = std::chrono::system_clock::to_time_t(now);
-    auto now_ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) % 1000;
-
-    std::cout << "Starting DosAtk at " << std::put_time(std::localtime(&now_time_t), "%Y-%m-%d %H:%M:%S")
-    << "." << std::setfill('0') << std::setw(3) << now_ms.count() << std::endl;
-}

src/my_start.hpp

@@ -1,11 +0,0 @@
-#include <iostream>
-#include <chrono>
-#include <iomanip>
-#include <ctime>
-
-void my_start();
-void my_fin();
-
-extern int n_ok_requests;
-extern int n_fail_requests;
-extern std::chrono::system_clock::time_point start_timestamp;