forked from serafim/dos
448 lines
15 KiB
C++
448 lines
15 KiB
C++
#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;
|
||
}
|