Servidor de autenticación de socket?

Question

Actualmente estoy jugando con Java para crear un servidor de autenticación para una aplicación de escritorio y hasta ahora he podido hacer que tanto el cliente como el servidor se comuniquen como un servidor de chat/cliente para empezar.

Me doy cuenta de que solo conseguí una pequeña parte de él trabajando y hay muchas cosas por venir y aprender, pero ahora mismo en esta etapa me pregunto cómo se realiza la autenticación.

Por ejemplo, este es el código del servidor:

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

public class LoginServer 
{ 
    public static void main(String[] args) throws Exception { 
     int port = 7000; 
     int id = 1; 

     ServerSocket loginserver = null; 
     try 
     { 
      loginserver = new ServerSocket(port); 
      System.out.println("LoginServer started..."); 
     } 
     catch (IOException e) { 
      System.out.println("Could not listen on port: " + port); 
      System.exit(-1); 
     } 

     while (true) 
     { 
      Socket clientSocket = loginserver.accept(); 
      ClientServiceThread cliThread = new ClientServiceThread(clientSocket, id++); 
      cliThread.start(); 
     } 
    } 
} 

class ClientServiceThread extends Thread 
{ 
    Socket clientSocket; 
    int clientID = -1; 
    boolean running = true; 

    ClientServiceThread(Socket s, int i) 
    { 
     clientSocket = s; 
     clientID = i; 
    } 

    public void run() 
    { 
     System.out.println("Accepted Client : ID - " + clientID + " : Address - " + clientSocket.getInetAddress().getHostName()); 
     try 
     { 
      BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); 
      PrintWriter out = new PrintWriter(new OutputStreamWriter(clientSocket.getOutputStream())); 
      while (running) 
      { 
       String clientCommand = in.readLine(); 
       System.out.println("Client Says :" + clientCommand); 
       if (clientCommand.equalsIgnoreCase("quit")) 
       { 
        running = false; 
        System.out.print("Stopping client thread for client : " + clientID); 
       } 
       else 
       { 
        out.println(clientCommand); 
        out.flush(); 
       } 
      } 
     } 
     catch (Exception e) 
     { 
      e.printStackTrace(); 
     } 
    } 
} 

Como se puede ver, yo leo lo envía al cliente y la salida a la consola, así como la comprobación de si el cliente ha enviado un dejar de fumar o no comando

• Lo que me pregunto es cómo haría yo para que el cliente sólo puede conectarse a que si el usuario y la contraseña se envían ?

• O debería recibir siempre la conexión inicial y desde allí recibir la información de autenticación y si el cliente no ha enviado en digamos 3 segundos desconectarlos?

• ¿Cuál es la forma correcta de recibir las nuevas conexiones y autenticar a los usuarios con él?

Answer 1

Tiene la idea correcta, pero debe considerarla más como una máquina de estados.

Un cliente se conecta, luego tendría que pasar al estado de inicio de sesión, donde espera que envíe información de autenticación. Si es incorrecto o expira, desconecte.

Si es correcto, pase al estado Procesamiento de comandos. Si recibe un comando de abandono, pase a un estado de Limpieza o simplemente desconéctese.

Aquí es un esquema general:

String line; 
while ((line = in.readLine()) != null) { 
    switch (state) { 
     case login: 
      processLogin(line); 
      break; 
     case command: 
      processCommand(line); 
      break; 
    } 
} 

Su processLogin función podría tener este aspecto:

void processLogin(String line) { 
    if (user == null) { 
     user = line; 
    } 
    else if (password == null) { 
     password = line; 
    } 
    else { 
     if (validUser(user, password)) { 
      state = command; 
     } 
     else { 
      socket.close(); 
     } 
    } 
} 

Y su función processCommand:

void processCommand(String line) { 
    if (line.equals(...)) { 
     // Process each command like this 
    } 
    else if (line.equals("quit")) { 
     socket.close(); 
    } 
    else { 
     System.err.println("Unrecognized command: " + line); 
    } 
} 

La variable state ejemplo, probablemente sería una enum. Puedes ver que usar este modelo te dará una extensibilidad bastante simple. Por ejemplo, un comando podría llevarte a un estado diferente para procesar subcomandos específicos.