Cómo añadir autenticación de dos factores (2FA) mediante Java y Spark

Este artículo se actualizó en abril de 2025

Con el creciente número de ciberamenazas, cada vez es más importante proteger sus aplicaciones y servicios web contra registros fraudulentos. Por suerte, la autenticación de dos factores (2FA) puede añadir una capa de protección al requerir un código de verificación enviado al teléfono del usuario.

En este tutorial, le guiaremos a través del proceso de implementación de 2FA en sus aplicaciones y servicios web. Empezaremos creando una página web fácil de usar que pida a los usuarios que se registren con su número de teléfono móvil. Para enviar un código de confirmación por SMS al número del usuario, utilizaremos la Verify API.

Una vez que el usuario recibe el código, sólo tiene que introducirlo en nuestra aplicación para completar el proceso de registro.

2FA es el tipo más básico y común de autenticación multifactor (MFA). Al añadir MFA con Java, puede disminuir significativamente las posibilidades de registros fraudulentos y aumentar la seguridad general de los datos de sus usuarios.

Empecemos a crear aplicaciones más seguras.

Requisitos previos

Para crear nuestra aplicación, utilizaremos el módulo Java 8 y el Spark web framework. También crearemos algunas vistas básicas para los elementos de la interfaz de usuario, utilizando el motor de plantillas motor de plantillas Handlebars.

Antes de empezar, asegúrate de que tienes lo siguiente:

• A Cuenta API de Vonage

  Abra su Página de configuración de API para acceder a tu clave y secreto de API de Vonage, que aparecen como se muestra en la captura de pantalla a continuación. La clave de API se encuentra en la parte superior de la página, y para acceder a tu secreto de API, consulta la subsección "Secreto de Account".

  Nota: En caso de que no recuerde su secreto de API creado anteriormente, haga clic en "+ Crear nuevo secreto" y guárdelo de forma segura.

  

• JDK o su equivalente de código abierto OpenJDK

• Gradle (versión 3.4 o posterior) para gestionar las dependencias y compilar el proyecto

Si necesita ayuda para empezar, no se preocupe. Nosotros te ayudamos. Puedes encontrar el código fuente de Mark Lewin para este tutorial en GitHub.

Instrucciones

A continuación, le ofrecemos instrucciones paso a paso para añadir la autenticación multifactor con Java, incluido un ejemplo. Este tutorial utiliza SMS 2FA, que envía un mensaje de texto con un código de verificación al teléfono del usuario. El código de verificación tendrá un límite de tiempo incorporado, lo que hace que este método sea similar a la autenticación de contraseña de un solo uso basada en tiempo (TOTP).

Estos son los pasos a seguir para implementar 2FA usando Java:

1. Cree su producto

2. Crear una aplicación web Spark

3. Inicializar la biblioteca cliente Java

4. Crear las vistas

5. Mostrar la página de registro inicial

6. Presentar la solicitud de verificación

7. Comprobar el código de confirmación

8. ¡Pruébelo!

Cree su proyecto

En primer lugar, cree un directorio llamado "two-factor-auth"para tu proyecto. Luego, navega a ese directorio y utiliza Gradle para inicializar el proyecto. Acepta todos los valores predeterminados y abre el proyecto generado en tu IDE.

Localice el archivo build.gradle y sustituya la sección dependencies por lo siguiente:

dependencies {
    // This dependency is used by the application.
    //implementation 'com.google.guava:guava:27.1-jre'

    // Use JUnit test framework
    testImplementation 'junit:junit:4.13.2'

    // Javalin framework
    //implementation 'io.javalin:javalin:5.4.2'

    // Spark framework
    implementation 'com.sparkjava:spark-core:2.9.4'

    // Vonage client library
    implementation 'com.vonage:client:7.2.0'

    // Templating engine
    implementation 'com.sparkjava:spark-template-handlebars:2.7.1'
}

No escribiremos ninguna prueba unitaria en este ejemplo, pero puedes dejar JUnit por ahora. Sin embargo, para evitar que más adelante te grite por omitir un método de saludo, comenta la prueba en src/test/java/two/factor/auth/AppTest.java como sigue:

public class AppTest {
  /*
   * @Test public void testAppHasAGreeting() { App classUnderTest = new App();
   * assertNotNull("app should have a greeting", classUnderTest.getGreeting()); }
   */
}

Crear una aplicación web Spark

Gradle creó la clase App clase en la carpeta src/main/java/two/factor/auth/App.java carpeta

Abra App.java en su IDE. Elimine el método getGreeting() método que gradle ha creado para usted y añada las import necesarias para el spark paquete.

Luego, llama al método port para indicar que tu aplicación está a la escucha de peticiones en el puerto 3000.

Su App.java debería tener este aspecto:

package two.factor.auth;

import static spark.Spark.*;

public class App {

  public static void main(String[] args) {
    port(3000);

    // Your code goes here
  }
}

Inicializar la biblioteca cliente Java

Para acceder a Verify API, deberá utilizar la REST API Client Library para Java.

Instálelo como se muestra a continuación, sustituyendo YOUR_API_KEY y YOUR_API_SECRET por su clave de API y el secreto del panel de desarrollador. Asegúrese de incluir las import necesarias para trabajar con Verify API:

package two.factor.auth;

import static spark.Spark.*;
// REST API Client Library for Java imports
import com.vonage.client.VonageClient;
import com.vonage.client.verify.*;

public class App {

  static String API_KEY = "YOUR_API_KEY";
  static String API_SECRET = "YOUR_API_SECRET";

  public static void main(String[] args) {
    port(3000);

    VonageClient client = VonageClient.builder().apiKey(API_KEY).apiSecret(API_SECRET).build();

  }
}

Crear las vistas

Su solicitud constará de tres páginas:

• Una primera inicialen la que sus usuarios se registrarán en su servicio introduciendo su número de móvil.

• A página de confirmacióndonde se les pedirá que introduzcan el código de confirmación enviado a su dispositivo móvil por la Verify API.

• A página de resultadosen la que la aplicación dirá que se ha registrado correctamente (si ha introducido el código de confirmación correcto) o que el registro ha fallado (si no lo ha hecho).

Spark admite muchos motores de plantillasque te permiten insertar contenido en tus páginas HTML de forma dinámica y también reutilizar bloques de HTML. En este tutorial, utilizaremos Handlebars.

Dado que queremos centrarnos en enseñarte a utilizar la Verify API, no describiremos su funcionamiento en este artículo, sino que te pediremos que descargues el contenido que necesites de nuestro repositorio de GitHub.

En primer lugar, incluya las siguientes importaciones en su archivo App.java que te permitirán trabajar con Handlebars:

import spark.template.handlebars.HandlebarsTemplateEngine;
import spark.ModelAndView;

A continuación, cree los archivos src/main/resources/public y src/main/resources/templates .

Copie el contenido del archivo styles.css en el archivo src/main/resources/public/styles.css.

A continuación, copie los *.hbs archivos de plantilla en la carpeta carpeta resources en GitHub en src/main/resources/templates.

Asegúrese de que su aplicación conoce el archivo styles.css especificando la ubicación de su carpeta principal (public) en el método main en el método App.java:

public static void main(String[] args) {
  port(3000);
  staticFiles.location("/public");

  VonageClient client = VonageClient.builder().apiKey(API_KEY).apiSecret(API_SECRET).build();

Mostrar la página de registro inicial

Cuando su usuario visita su sitio por primera vez, usted quiere mostrar la página de registro. Para ello, defina la ruta por defecto (/) utilizando spark y renderizando la plantilla register.hbs como se muestra:

public static void main(String[] args) {
  port(3000);
  staticFiles.location("/public");

  VonageClient client = VonageClient.builder().apiKey(API_KEY).apiSecret(API_SECRET).build();

  get("/", (request, response) -> {
    return new ModelAndView(null, "register.hbs");
  }, new HandlebarsTemplateEngine());

Pruebe su aplicación ejecutando gradle run y luego visitando http://localhost:3000 en su navegador. Si ha configurado todo correctamente, verá la siguiente página:

2FA Registration Page

Presentar la solicitud de verificación

El usuario debe introducir su número de teléfono móvil en la casilla de texto de la página de registro y, a continuación, hacer clic en Regístrese en para iniciar el proceso de verificación.

La Verify API espera que este número incluya el código de marcación internacional pero omita los ceros a la izquierda. Por ejemplo, el número del Reino Unido 07700 900001 debe representarse como 447700900001.

En una aplicación de producción, es posible que desee determinar la configuración regional y el código de país correctos mediante programación, y tenemos una API para ello. Consulte la API Number Insight. Por ahora, sin embargo, vamos a mantener las cosas simples.

Cuando el usuario hace clic en Registrar queremos capturar el número que ha introducido y enviar la solicitud de verificación.

Cada solicitud de verificación está asociada a un identificador de verificación. Tenemos que mantener un registro de esto también para que podamos utilizarlo para comprobar que el usuario introdujo el código de confirmación correcto más tarde.

Así pues, añada dos variables de nivel de clase para almacenar esta información, debajo de la variable API_KEY y API_SECRET que rellenaste anteriormente:

static String number, requestId;

Enviaremos la solicitud de verificación desde la ruta /register por lo que definiremos la ruta de la siguiente manera:

post("/register", (request, response) -> {
    number = request.queryParams("number");

    VerifyResponse verifyResponse = client.getVerifyClient().verify(number, "VONAGE");
    if (verifyResponse.getStatus() == VerifyStatus.OK) {
      requestId = verifyResponse.getRequestId();
      System.out.printf("RequestID: %s", requestId);
    }
    else {
      System.out.printf("ERROR! %s: %s", verifyResponse.getStatus(), verifyResponse.getErrorText());
    }

    return new ModelAndView(null, "verify.hbs");
  }, new HandlebarsTemplateEngine());

Este código activa la solicitud de verificación recuperando primero una instancia de VerifyClient y llamando a su método verify introduciendo el número que queremos verificar y una cadena alfanumérica que se utiliza para identificar al remitente en el cuerpo del mensaje SMS.

Devuelve un objeto VerifyResponse que podemos utilizar para examinar si la solicitud se emitió correctamente. En caso afirmativo, recuperamos el ID de la solicitud de verificación y lo utilizamos para comprobar el código enviado al usuario para ese intento de verificación específico en el siguiente paso.

Una vez enviada la solicitud de verificación, el usuario recibirá un código de verificación por SMS:

2FA Verification SMS Shown in iPhone

Renderizamos la verify.hbs para que puedan introducir el código que han recibido:

2FA Check Verification

Por defecto, tras enviar el SMS, Verify API espera un código durante 125 segundos. Si no lo recibe en ese periodo de tiempo, realiza dos llamadas telefónicas de texto a voz antes de darse por vencido y fallar el intento de verificación. Puede obtener más información sobre el flujo de trabajo predeterminado y sobre cómo activar diferentes flujos de trabajo leyendo la documentación.

Comprobar el código de confirmación

Ahora tenemos que proporcionar la lógica necesaria para verificar el código que han introducido. Cree la ruta /check ruta para ello:

  post("/check", (request, response) -> {
    String code = request.queryParams("code");
    CheckResponse checkResponse = client.getVerifyClient().check(requestId, code);
    return new ModelAndView(null, checkResponse.getStatus() == VerifyStatus.OK ? "success.hbs" : "failed.hbs");

  }, new HandlebarsTemplateEngine());

Este código utiliza el método VerifyClient.check pasándole el ID de solicitud que almacenamos en el paso de solicitud de verificación y el código que el usuario introdujo en la vista verify.hbs vista.

El método check devuelve un objeto CheckResponse objeto. Utilizamos su método getStatus método para determinar si el usuario ha introducido el código correcto y mostrar la respuesta adecuada en la result.hbs vista. Si el usuario introdujo el código correctamente, recibimos el siguiente mensaje:

Verification Success

Si el usuario ha introducido el código incorrectamente, recibiremos el siguiente mensaje.

Verification Failed

¡Pruébelo!

1. Ejecute gradle run en su terminal.

2. Visite http://localhost:3000 en su navegador.

3. Introduzca su número de teléfono móvil y haga clic en Regístrese en. En unos instantes recibirá un SMS con un código de verificación.

4. Introduzca el código de verificación y haga clic en Compruebe.

5. Si ha introducido correctamente el código, recibirá el mensaje "Registro efectuado".

Conclusión

Estos son los pasos fundamentales para implementar la autenticación de dos factores en sus aplicaciones web Java utilizando la Verify API. Para más información, consulte los enlaces de documentación que se proporcionan a continuación.

Lecturas complementarias

• Información general sobre Verify API

• Verify API Documentation (Documentación de la API)

• Verify API reference (Verificar referencia API)

• Number Insight API

• Cómo añadir autenticación de dos factores con Node.JS

• Cómo agregar autenticación de dos factores en Laravel

• Cómo enviar mensajes SMS con Java