Hinzufügen der Zwei-Faktoren-Authentifizierung (2FA) mit Java und Spark

Dieser Artikel wurde im April 2025 aktualisiert.

Angesichts der wachsenden Zahl von Cyberbedrohungen wird es immer wichtiger, Ihre Webanwendungen und -dienste vor betrügerischen Anmeldungen zu schützen. Glücklicherweise kann die Zwei-Faktor-Authentifizierung (2FA) einen zusätzlichen Schutz bieten, indem ein Verifizierungscode an das Telefon des Nutzers gesendet wird.

In diesem Lernprogramm führen wir Sie durch den Prozess der Implementierung von 2FA in Ihre Webanwendungen und -dienste. Wir beginnen mit der Erstellung einer benutzerfreundlichen Webseite, die den Benutzer auffordert, sich mit seiner Handynummer zu registrieren. Um einen Bestätigungscode per SMS an die Nummer des Benutzers zu senden, verwenden wir die Verify API.

Sobald der Nutzer den Code erhalten hat, muss er ihn nur noch in unsere Anwendung eingeben, um den Registrierungsprozess abzuschließen.

2FA ist die einfachste und gängigste Art der Multi-Faktor-Authentifizierung (MFA). Durch das Hinzufügen von MFA mit Java können Sie die Wahrscheinlichkeit von betrügerischen Anmeldungen erheblich verringern und die allgemeine Sicherheit der Daten Ihrer Benutzer erhöhen.

Lassen Sie uns mit dem Aufbau einer sichereren Anwendung beginnen!

Voraussetzungen

Um unsere Anwendung zu erstellen, verwenden wir die Java 8 und das Web-Framework Spark. Wir werden auch einige grundlegende Ansichten für die UI-Elemente erstellen, indem wir die Handlebars-Templating-Engine.

Bevor wir loslegen, sollten Sie sich vergewissern, dass Sie die folgenden Informationen haben:

• A Vonage API-Konto

  Öffnen Sie Ihre API-Einstellungen-Seite um auf Ihren Vonage API-Schlüssel und Ihr API-Geheimnis zuzugreifen, die beide wie im Screenshot unten dargestellt angezeigt werden. Der API-Schlüssel befindet sich oben auf der Seite, und um auf Ihr API-Geheimnis zuzugreifen, lesen Sie bitte den Unterabschnitt "Account secret".

  Hinweis: Falls Sie sich nicht an Ihr zuvor erstelltes API-Geheimnis erinnern können, klicken Sie auf "+ Neues Geheimnis erstellen" und speichern Sie es sicher.

  

• JDK oder sein Open-Source-Äquivalent OpenJDK

• Gradle (Version 3.4 oder neuer), um Abhängigkeiten zu verwalten und Ihr Projekt zu erstellen

Wenn Sie Hilfe bei den ersten Schritten brauchen, keine Sorge! Wir haben alles für Sie. Sie finden den Quellcode von Mark Lewin für dieses Tutorial auf GitHub.

Anweisungen

Nachfolgend finden Sie eine Schritt-für-Schritt-Anleitung für das Hinzufügen der Multi-Faktor-Authentifizierung mit Java, einschließlich eines Beispiels für die Vorgehensweise. In dieser Anleitung wird SMS 2FA verwendet, die eine Textnachricht mit einem Verifizierungscode an das Telefon des Benutzers sendet. Der Verifizierungscode hat ein eingebautes Zeitlimit, wodurch diese Methode der zeitbasierten Authentifizierung mit Einmalkennwort (TOTP) ähnelt.

Nachfolgend finden Sie die Schritte, die Sie zur Implementierung von 2FA mit Java durchführen müssen:

1. Ihr Produkt erstellen

2. Erstellen einer Spark-Webanwendung

3. Initialisieren der Java-Client-Bibliothek

4. Erstellen Sie die Ansichten

5. Anzeige der Seite für die Erstregistrierung

6. Antrag auf Verifizierung einreichen

7. Prüfen Sie den Bestätigungscode

8. Probieren Sie es aus!

Ihr Projekt erstellen

Legen Sie zunächst ein Verzeichnis mit dem Namen "two-factor-auth" für Ihr Projekt. Navigieren Sie dann zu diesem Verzeichnis und verwenden Sie Gradle, um das Projekt zu initialisieren. Akzeptieren Sie alle Standardeinstellungen und öffnen Sie dann das generierte Projekt in Ihrer IDE.

Suchen Sie die build.gradle Datei und ersetzen Sie den dependencies durch den folgenden Abschnitt:

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

In diesem Beispiel werden wir keine Unit-Tests schreiben, aber Sie können die JUnit vorerst drin lassen. Um jedoch zu verhindern, dass es Sie später anschreit, weil eine Begrüßungsmethode fehlt, kommentieren Sie den Test in src/test/java/two/factor/auth/AppTest.java wie folgt aus:

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

Erstellen einer Spark-Webanwendung

Gradle erstellt die App Klasse im Ordner src/main/java/two/factor/auth/App.java Ordner.

Öffnen Sie App.java in Ihrer IDE. Entfernen Sie die getGreeting() Methode, die gradle für Sie erstellt wurde und fügen Sie die notwendigen import Anweisungen für das spark Paket hinzu.

Rufen Sie dann die Spark port auf, um anzugeben, dass Ihre Anwendung auf Anfragen an Port 3000 wartet.

Ihre App.java sollte folgendermaßen aussehen:

package two.factor.auth;

import static spark.Spark.*;

public class App {

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

    // Your code goes here
  }
}

Initialisieren der Java-Client-Bibliothek

Um auf die Verify API zuzugreifen, müssen Sie die REST-API-Client-Bibliothek für Java.

Instanziieren Sie es wie unten gezeigt und ersetzen Sie YOUR_API_KEY und YOUR_API_SECRET durch Ihren API-Schlüssel und Ihr Geheimnis aus dem Entwickler-Dashboard. Stellen Sie sicher, dass Sie die notwendigen import Anweisungen enthalten, die für die Arbeit mit der Verify API erforderlich sind:

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

  }
}

Erstellen Sie die Ansichten

Ihre Bewerbung wird drei Seiten umfassen:

• Eine erste Registrierungsseiteauf der sich Ihre Nutzer für Ihren Dienst registrieren, indem sie ihre Handynummer eingeben.

• A Bestätigungsseiteauf der sie aufgefordert werden, den von der Verify API an ihr Mobilgerät gesendeten Bestätigungscode einzugeben.

• A Ergebnisseiteauf der die Anwendung entweder mitteilt, dass sie sich erfolgreich registriert haben (wenn sie den richtigen Bestätigungscode eingegeben haben) oder dass die Registrierung fehlgeschlagen ist (wenn sie das nicht getan haben).

Spark unterstützt viele verschiedene Schablonen-Enginesdie es Ihnen ermöglichen, Inhalte dynamisch in Ihre HTML-Seiten einzufügen und auch HTML-Blöcke wiederzuverwenden. In diesem Lernprogramm werden wir Folgendes verwenden Handlebars.

Da wir uns hier darauf konzentrieren wollen, Ihnen die Verwendung der Verify API beizubringen, werden wir in diesem Artikel nicht beschreiben, wie diese funktionieren, sondern Sie bitten, die benötigten Inhalte von unserem GitHub-Repositorium.

Nehmen Sie zunächst die folgenden Importe in Ihre App.java Datei ein, damit Sie mit Handlebars arbeiten können:

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

Erstellen Sie dann die src/main/resources/public und src/main/resources/templates Verzeichnisse an.

Kopieren Sie den Inhalt der Datei styles.css Datei nach src/main/resources/public/styles.css.

Kopieren Sie dann die *.hbs Vorlagendateien in den Ordner Ordner resources auf GitHub nach . src/main/resources/templates.

Stellen Sie sicher, dass Ihre Anwendung von der styles.css statische CSS-Datei kennt, indem Sie den Speicherort des übergeordneten Ordners (public) in der main Methode in App.java:

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

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

Anzeige der Seite für die Erstregistrierung

Wenn Ihr Benutzer Ihre Website zum ersten Mal besucht, möchten Sie die Registrierungsseite anzeigen. Dazu definieren Sie die Standardroute (/) mit spark definieren und die register.hbs Vorlage wie gezeigt:

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

Testen Sie Ihre Anwendung durch Ausführen von gradle run ausführen und dann http://localhost:3000 in Ihrem Browser aufrufen. Wenn Sie alles richtig eingerichtet haben, sehen Sie die folgende Seite:

2FA Registration Page

Antrag auf Verifizierung einreichen

Der Nutzer muss seine Handynummer in das Textfeld auf der Registrierungsseite eingeben und dann auf Registrieren um den Verifizierungsprozess zu starten.

Die Verify API erwartet, dass diese Nummer die internationale Vorwahl enthält, aber keine führenden Nullen enthält. Zum Beispiel sollte die britische Nummer 07700 900001 sollte wie folgt dargestellt werden 447700900001.

In einer Produktionsanwendung möchten Sie vielleicht das richtige Gebietsschema und den korrekten Ländercode programmatisch bestimmen, und wir haben eine API dafür! Sehen Sie sich die Number Insight API. Aber lassen Sie uns die Dinge erst einmal einfach halten.

Wenn der Benutzer auf Registrieren klickt, möchten wir die eingegebene Nummer erfassen und die Verifizierungsanfrage übermitteln.

Jede Verifizierungsanfrage ist mit einer Verifizierungs-ID verbunden. Auch diese müssen wir aufzeichnen, damit wir später überprüfen können, ob der Benutzer den richtigen Bestätigungscode eingegeben hat.

Fügen Sie also zwei Variablen auf Klassenebene hinzu, um diese Informationen zu speichern, unterhalb der API_KEY und API_SECRET Variablen, die Sie zuvor eingegeben haben:

static String number, requestId;

Wir übermitteln die Verifizierungsanfrage über die /register übermitteln, also definieren wir die Route wie folgt:

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

Dieser Code löst die Überprüfungsanfrage aus, indem er zunächst eine Instanz von VerifyClient abruft und dann seine verify aufruft und dabei die zu verifizierende Nummer und eine alphanumerische Zeichenfolge zur Identifizierung des Absenders im Textkörper der SMS-Nachricht angibt.

Sie gibt ein VerifyResponse Objekt zurück, mit dem wir prüfen können, ob die Anfrage erfolgreich gestellt wurde. Ist dies der Fall, wird die ID der Verifizierungsanforderung abgerufen und zur Überprüfung des Codes verwendet, der dem Benutzer für diesen speziellen Verifizierungsversuch im nächsten Schritt gesendet wird.

Sobald wir den Verifizierungsantrag eingereicht haben, erhält der Nutzer einen Verifizierungscode per SMS:

2FA Verification SMS Shown in iPhone

Wir rendern die verify.hbs Ansicht, damit sie den Code, den sie erhalten haben, eingeben können:

2FA Check Verification

Standardmäßig wartet die Verify API nach dem Senden der SMS 125 Sekunden lang auf einen Code. Wenn sie innerhalb dieses Zeitraums keinen Code erhält, folgen zwei Text-to-Speech-Telefonanrufe, bevor sie schließlich aufgibt und den Verifizierungsversuch abbricht. Weitere Informationen über den Standard-Workflow und die Aktivierung verschiedener Workflows finden Sie in die Dokumentation lesen.

Prüfen Sie den Bestätigungscode

Jetzt müssen wir die notwendige Logik bereitstellen, um den eingegebenen Code zu verifizieren. Erstellen Sie die /check Route für diesen Zweck:

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

Dieser Code verwendet die VerifyClient.check Methode und übergibt ihr die Anfrage-ID, die wir aus dem Schritt der Überprüfungsanfrage gespeichert haben, sowie den Code, den der Benutzer in der verify.hbs Ansicht eingegeben hat.

Die Methode check Methode gibt ein CheckResponse Objekt zurück. Wir verwenden ihre getStatus Methode, um festzustellen, ob der Benutzer den richtigen Code eingegeben hat, und zeigen die entsprechende Antwort in der result.hbs Ansicht. Wenn der Benutzer den Code richtig eingegeben hat, erhalten wir die folgende Meldung:

Verification Success

Wenn der Benutzer den Code falsch eingegeben hat, erhalten wir die folgende Meldung.

Verification Failed

Probieren Sie es aus!

1. Führen Sie aus. gradle run in Ihrem Terminal aus.

2. Besuchen Sie http://localhost:3000 in Ihrem Browser.

3. Geben Sie Ihre Mobiltelefonnummer ein und klicken Sie auf Registrieren. In ein oder zwei Augenblicken erhalten Sie eine SMS mit einem Bestätigungscode.

4. Geben Sie den Verifizierungscode ein und klicken Sie auf überprüfen..

5. Wenn Sie den Code erfolgreich eingegeben haben, erhalten Sie die Meldung "Registrierung erfolgreich".

Schlussfolgerung

Dies sind die grundlegenden Schritte zur Implementierung der Zwei-Faktor-Authentifizierung in Ihren Java-Webanwendungen unter Verwendung der Verify API. Weitere Informationen finden Sie unter den unten angegebenen Links zur Dokumentation.

Weitere Lektüre

• Allgemeine Informationen über die Verify API

• API-Dokumentation verifizieren

• API-Referenz verifizieren

• Number Insight API

• Hinzufügen der Zwei-Faktor-Authentifizierung mit Node.JS

• Hinzufügen der Zwei-Faktor-Authentifizierung in Laravel

• SMS-Nachrichten mit Java versenden