Comment ajouter l'authentification à deux facteurs (2FA) en utilisant Java et Spark

Cet article a été mis à jour en avril 2025

Avec le nombre croissant de cybermenaces, il devient de plus en plus important de protéger vos applications et services web contre les inscriptions frauduleuses. Heureusement, l'authentification à deux facteurs (2FA) peut ajouter une couche de protection en exigeant un code de vérification envoyé sur le téléphone de l'utilisateur.

Dans ce tutoriel, nous vous guiderons à travers le processus de mise en œuvre de 2FA dans vos applications et services web. Nous commencerons par créer une page web conviviale qui demande aux utilisateurs de s'enregistrer avec leur numéro de téléphone portable. Pour envoyer un code de confirmation par SMS au numéro de l'utilisateur, nous utiliserons l'API Verify API.

Une fois que l'utilisateur a reçu le code, il lui suffit de le saisir dans notre application pour terminer le processus d'enregistrement.

Le 2FA est le type le plus basique et le plus courant d'authentification multi-facteurs (MFA). En ajoutant le MFA avec Java, vous pouvez réduire de manière significative les risques d'inscriptions frauduleuses et renforcer la sécurité globale des données de vos utilisateurs.

Commençons à construire une application plus sûre !

Conditions préalables

Pour créer notre application, nous utiliserons le logiciel Java 8 et le framework web Spark web framework. Nous créerons également quelques vues de base pour les éléments de l'interface utilisateur, en utilisant le moteur de modélisation moteur de modélisation Handlebars.

Avant d'entrer dans le vif du sujet, assurez-vous que vous disposez des éléments suivants :

• A Compte API Vonage

  Ouvrez votre Page des paramètres de l'API pour accéder à votre clé et à votre secret API de Vonage, qui sont tous deux affichés comme indiqué dans la capture d'écran ci-dessous. La clé API se trouve en haut de la page, et pour accéder à votre secret API, veuillez vous référer à la sous-section "Secret du compte".

  Remarque : si vous ne vous souvenez plus de votre secret API précédemment créé, cliquez sur "+ Créer un nouveau secret" et sauvegardez-le en toute sécurité.

  

• JDK ou son équivalent open-source OpenJDK

• Gradle (version 3.4 ou plus récente) pour gérer les dépendances et construire votre projet

Si vous avez besoin d'aide pour démarrer, ne vous inquiétez pas ! Nous avons tout prévu. Vous pouvez trouver le code source de Mark Lewin pour ce tutoriel sur GitHub.

Instructions

Vous trouverez ci-dessous des instructions pas à pas pour ajouter l'authentification multifactorielle avec Java, ainsi qu'un exemple de marche à suivre. Ce tutoriel utilise le SMS 2FA, qui envoie un message texte avec un code de vérification sur le téléphone de l'utilisateur. Le code de vérification est limité dans le temps, ce qui rend cette méthode similaire à l'authentification par mot de passe unique basé sur le temps (TOTP).

Voici les étapes à suivre pour mettre en œuvre le 2FA à l'aide de Java :

1. Créer votre produit

2. Créer une application Web Spark

3. Initialiser la bibliothèque du client Java

4. Créer les vues

5. Afficher la page d'enregistrement initial

6. Soumettre la demande de vérification

7. Vérifier le code de confirmation

8. Essayez-le !

Créez votre projet

Tout d'abord, créez un répertoire nommé "two-factor-auth"pour votre projet. Ensuite, naviguez vers ce répertoire et utilisez Gradle pour initialiser le projet. Acceptez tous les paramètres par défaut, puis ouvrez le projet généré dans votre IDE.

Localisez le fichier build.gradle et remplacez la section dependencies par ce qui suit :

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'
}

Nous n'écrirons pas de tests unitaires dans cet exemple, mais vous pouvez laisser JUnit pour l'instant. Cependant, pour éviter qu'il ne vous crie dessus parce qu'il manque une méthode d'accueil plus tard, commentez le test dans src/test/java/two/factor/auth/AppTest.java comme suit :

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

Créer une application Web Spark

Gradle a créé la classe App dans le dossier src/main/java/two/factor/auth/App.java dans le dossier

Ouvrez App.java dans votre IDE. Supprimez la méthode getGreeting() qui a été créée pour vous gradle a créée pour vous et ajoutez les déclarations import nécessaires pour le spark pour le paquetage.

Ensuite, appelez la méthode port pour indiquer que votre application écoute les requêtes sur le port 3000.

Votre App.java devrait ressembler à ceci :

package two.factor.auth;

import static spark.Spark.*;

public class App {

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

    // Your code goes here
  }
}

Initialiser la bibliothèque du client Java

Pour accéder à l'API Verify, vous devez utiliser la bibliothèque client Bibliothèque client API REST pour Java.

Instanciez-le comme indiqué ci-dessous, en remplaçant YOUR_API_KEY et YOUR_API_SECRET par votre clé d'API et votre secret provenant du tableau de bord du développeur. Assurez-vous d'inclure les déclarations import nécessaires pour travailler avec l'API Verify :

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();

  }
}

Créer les vues

Votre dossier de candidature comprendra trois pages :

• Une première page d'inscriptionoù vos utilisateurs s'inscriront à votre service en entrant leur numéro de téléphone mobile.

• A une page de confirmationoù il leur sera demandé de saisir le code de confirmation envoyé à leur appareil mobile par l'API Verify.

• A page de résultatsoù l'application indique soit que l'inscription a réussi (si le code de confirmation est correct), soit qu'elle a échoué (dans le cas contraire).

Spark prend en charge de nombreux moteurs de modélisationSpark supporte de nombreux moteurs de templates, qui vous permettent d'insérer dynamiquement du contenu dans vos pages HTML et de réutiliser des blocs de HTML. Dans ce tutoriel, nous utiliserons Barres de maintien.

Comme nous voulons nous concentrer sur l'utilisation de l'API Verify, nous ne décrirons pas leur fonctionnement dans cet article, mais nous vous demanderons de télécharger le contenu dont vous avez besoin à partir de notre dépôt GitHub.

Tout d'abord, incluez les importations suivantes dans votre fichier App.java qui vous permettront de travailler avec Handlebars :

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

Ensuite, créez les fichiers src/main/resources/public et src/main/resources/templates .

Copiez le contenu du fichier styles.css dans le fichier src/main/resources/public/styles.css.

Copiez ensuite les *.hbs dans le dossier ressources sur GitHub dans src/main/resources/templates.

Assurez-vous que votre application connaît le fichier styles.css en spécifiant l'emplacement de son dossier parent (public) dans la méthode main dans la méthode App.java:

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

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

Afficher la page d'enregistrement initial

Lorsque l'utilisateur visite votre site pour la première fois, vous souhaitez afficher la page d'inscription. Pour ce faire, définissez l'itinéraire par défaut (/) en utilisant spark et en rendant le modèle register.hbs comme indiqué :

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());

Testez votre application en exécutant gradle run puis en visitant http://localhost:3000 dans votre navigateur. Si vous avez tout configuré correctement, vous verrez la page suivante :

2FA Registration Page

Soumettre la demande de vérification

L'utilisateur doit saisir son numéro de téléphone portable dans la zone de texte de la page d'inscription, puis cliquer sur s'inscrire pour lancer la procédure de vérification.

L'API Verify s'attend à ce que ce numéro comprenne l'indicatif international, sans les zéros initiaux. Par exemple, le numéro britannique 07700 900001 doit être représenté par 447700900001.

Dans une application de production, vous pourriez vouloir déterminer la locale et le code pays corrects de manière programmatique et nous avons une API pour cela ! Consultez l Number Insight API. Pour l'instant, gardons les choses simples.

Lorsque l'utilisateur clique sur S'inscrire nous voulons capturer le numéro qu'il a saisi et soumettre la demande de vérification.

Chaque demande de vérification est associée à un identifiant de vérification. Nous devons également garder une trace de cet identifiant afin de pouvoir vérifier ultérieurement que l'utilisateur a saisi le bon code de confirmation.

Il faut donc ajouter deux variables au niveau de la classe pour stocker ces informations, sous les variables API_KEY et API_SECRET que vous avez renseignées plus tôt :

static String number, requestId;

Nous soumettrons la demande de vérification à partir de la route /register et définissons donc la route comme suit :

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());

Ce code déclenche la demande de vérification en récupérant d'abord une instance de VerifyClient puis en appelant sa méthode verify en lui transmettant le numéro à vérifier et une chaîne alphanumérique utilisée pour identifier l'expéditeur dans le corps du message SMS.

Il renvoie un objet VerifyResponse que nous pouvons utiliser pour vérifier si la demande a été émise avec succès. Si c'est le cas, nous récupérons l'identifiant de la demande de vérification et l'utilisons pour vérifier le code envoyé à l'utilisateur pour cette tentative de vérification spécifique à l'étape suivante.

Une fois la demande de vérification soumise, l'utilisateur recevra un code de vérification par SMS :

2FA Verification SMS Shown in iPhone

Nous rendons la vue verify.hbs pour leur permettre de saisir le code qu'ils ont reçu :

2FA Check Verification

Par défaut, après l'envoi du SMS, l'API Verify attend un code pendant 125 secondes. Si elle ne le reçoit pas dans ce délai, elle passe deux appels téléphoniques avec synthèse vocale avant d'abandonner et de faire échouer la tentative de vérification. Vous pouvez en savoir plus sur le flux de travail par défaut et sur la manière d'activer différents flux de travail en lisant la documentation.

Vérifier le code de confirmation

Nous devons maintenant fournir la logique nécessaire pour vérifier le code qu'ils ont saisi. Créez la /check pour cela :

  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());

Ce code utilise la méthode VerifyClient.check en lui transmettant l'identifiant de la demande que nous avons stocké lors de l'étape de vérification de la demande et le code que l'utilisateur a saisi dans la vue verify.hbs vue.

La méthode check renvoie un objet CheckResponse objet. Nous utilisons sa méthode getStatus pour déterminer si l'utilisateur a saisi le bon code et afficher la réponse appropriée dans la vue result.hbs la réponse appropriée. Si l'utilisateur a saisi le code correctement, nous recevons le message suivant :

Verification Success

Si l'utilisateur a introduit le code de manière incorrecte, nous recevons le message suivant.

Verification Failed

Essayez-le !

1. Exécutez gradle run dans votre terminal.

2. Visiter http://localhost:3000 dans votre navigateur.

3. Entrez votre numéro de téléphone portable et cliquez sur S'inscrire. Dans quelques instants, vous recevrez un SMS contenant un code de vérification.

4. Saisissez le code de vérification et cliquez sur Vérifier.

5. Si vous avez saisi le code avec succès, vous recevrez un message "Enregistrement réussi".

Conclusion

Voici les étapes fondamentales de la mise en œuvre de l'authentification à deux facteurs dans vos applications web Java à l'aide de l'API Verify. Pour plus d'informations, veuillez vous référer aux liens de documentation fournis ci-dessous.

Pour en savoir plus

• Informations générales sur l'API Verify

• Verify API Documentation

• Verify API reference (vérifier la référence de l'API)

• Number Insight API

• Comment ajouter l'authentification à deux facteurs avec Node.JS

• Comment ajouter l'authentification à deux facteurs dans Laravel

• Comment envoyer des SMS avec Java