Hinzufügen von 2FA zu Ihrer Applikation mit der Verify API und dem Golang SDK

Wenn Sie hart am Aufbau einer Webanwendung gearbeitet haben, die Ihren Nutzern einen echten Mehrwert bietet, kann es sehr enttäuschend sein, wenn sie missbraucht wird. Durchgesickerte Anmeldedaten, gefälschte Anmeldungen ... es gibt immer eine kleine Minderheit, die versucht, Ihre Plattform für ihre eigenen ruchlosen Zwecke zu nutzen.

Auch wenn es nahezu unmöglich ist, dies in irgendeiner Form zu verhindern, können Sie durch die Implementierung der Zwei-Faktor-Authentifizierung (2FA) alle bis auf die engagiertesten Missbraucher abschrecken.

Was ist 2FA?

2FA ist eine zusätzliche Schutzebene, bei der Ihr Nutzer mehr als nur einen Benutzernamen und ein Passwort angeben muss, um Ihren Dienst nutzen zu können. In der Regel handelt es sich dabei um den Zugang zu einem mobilen Gerät, das einen Sicherheitscode empfangen kann, den der Nutzer dann im Rahmen des Registrierungs- oder Anmeldeprozesses in Ihre Anwendung eingibt. Da Ihre Telefonnummer nur Ihnen gehört, ist es für Betrüger viel schwieriger, sich als bestehende Benutzer auszugeben oder mehrere falsche Konten einzurichten.

Ein weiterer guter Anwendungsfall für 2FA ist die "Step-up-Authentifizierung". Dies ist ideal für Situationen, in denen ein Benutzer versucht, etwas in Ihrer Anwendung zu tun, was schlimme Folgen haben könnte, wenn der Benutzer nicht der ist, der er vorgibt zu sein. Zum Beispiel, wenn Sie eine Bankanwendung haben und Ihr Benutzer versucht, einen neuen Zahlungsempfänger hinzuzufügen. In solchen Fällen bietet die 2FA eine gewisse Sicherheit, dass der Benutzer legitim ist.

Die Vonage Verify API

Die Vonage Verify API macht es wirklich einfach, 2FA in Ihre Applications zu implementieren, und genau das wollen wir in unserem heutigen Beitrag demonstrieren. Wir werden eine einfache Website für ein fiktives Unternehmen namens Acme Inc. erstellen, bei der sich die Benutzer mit ihrem Mobilgerät registrieren müssen, um einen gewissen Schutz vor betrügerischer Nutzung zu gewährleisten.

Und, um die Sache noch spannender zu machen, werden wir dies in unserem brandneuen (Beta-)Go-SDK. Das sollte alle hartgesottenen Gophers da draußen erfreuen und vielleicht sogar andere ermutigen, ihre ersten Erfahrungen mit der Go-Entwicklung zu machen? (Spoiler-Alarm: Ich denke, Sie werden lieben Go!)

Legen wir los! (Wenn Sie keine Zeit haben, mitzucoden, finden Sie den den Quellcode auf GitHub).

Vonage API-Konto

Um dieses Tutorial durchzuführen, benötigen Sie ein Vonage API-Konto. Wenn Sie noch keines haben, können Sie sich noch heute anmelden und mit einem kostenlosen Guthaben beginnen. Sobald Sie ein Konto haben, finden Sie Ihren API-Schlüssel und Ihr API-Geheimnis oben auf dem Vonage-API-Dashboard.

Sind Sie bereit, mit dem Bau zu beginnen?

Erleben Sie nahtlose Konnektivität, Echtzeit-Messaging und kristallklare Sprach- und Videoanrufe - alles auf Knopfdruck.

Erstellen Sie Ihr Projekt

Legen Sie ein Verzeichnis für Ihr Projekt an und führen Sie darin go mod init. Dies erzeugt eine go.mod Datei zur Verwaltung der Abhängigkeiten.

Erstellen Sie dann eine main.go Datei. Darin schreiben Sie Ihren Anwendungscode:

Wir werden Folgendes verwenden Go-Vorlagen um unsere Website zu erstellen. Legen wir ein Verzeichnis für sie an (tmpl) und auch für das CSS, das wir zur Gestaltung unserer Seiten verwenden werden (static):

Konfigurieren Sie das Vonage Go SDK

Wir werden die Verify API verwenden, um von den Nutzern den Nachweis zu verlangen, dass sie das Gerät besitzen, mit dem sie sich für unseren Dienst registrieren wollen. Die Verify API macht den gesamten Prozess der Zwei-Faktor-Authentifizierung sehr einfach.

Vor nicht allzu langer Zeit hätten wir Go-Entwickler alle erforderlichen API-Aufrufe manuell durchführen müssen, aber in diesen aufgeklärten Zeiten haben wir unser glänzendes neues Vonage Go SDK um das Leben einfacher zu machen, also lasst uns das alles einrichten und konfigurieren.

Um das Go SDK zu verwenden, müssen wir unseren API-Schlüssel und unser Geheimnis angeben, die im Entwickler Dashboard. Wir wollen diese Anmeldedaten nicht einfach direkt in unseren Code einfügen, denn jeder, der Zugang zu unserem Schlüssel und Geheimnis hat, kann API-Aufrufe auf unsere Kosten tätigen. Also konfigurieren wir diese Details in einer .env Datei und verwenden das github.com/joho/godotenv Paket, um diese Werte in Umgebungsvariablen zu lesen.

Erstellen Sie zunächst die Datei .env Datei in Ihrem Projektverzeichnis:

VONAGE_API_KEY=<YOUR_API_KEY>
VONAGE_API_SECRET=<YOUR_API_SECRET>

Ersetzen Sie <YOUR_API_KEY> und <YOUR_API_SECRET> durch Ihren eigenen API-Schlüssel und Ihr Geheimnis.

Führen Sie dann go get zur Installation von dotenv und das Vonage Go SDK:

In main.go schreiben Sie Code, um Ihre Vonage API-Anmeldeinformationen aus der .env Datei zu lesen und sie zu verwenden, um eine Instanz des Vonage Go SDK zu instanziieren VerifyClient:

package main

import (
	"log"
	"os"

	"github.com/joho/godotenv"
	"github.com/vonage/vonage-go-sdk"
)

var verifyClient *vonage.VerifyClient

func main() {
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error loading .env file")
		os.Exit(1)
	}

	apiKey := os.Getenv("VONAGE_API_KEY")
	apiSecret := os.Getenv("VONAGE_API_SECRET")

	auth := vonage.CreateAuthFromKeySecret(apiKey, apiSecret)
	verifyClient = vonage.NewVerifyClient(auth)

}

Erstellen der UI

Um zu verstehen, welche Seiten unsere Webanwendung den Benutzern präsentieren muss, betrachten wir den Arbeitsablauf, den wir implementieren werden:

The verification process

Daraus können Sie ersehen, dass wir die folgenden Seiten benötigen:

• Die Hauptseite (/): Wenn der Benutzer registriert ist, werden hier sein registrierter Name und seine Telefonnummer angezeigt.

• Die Registrierungsseite (/register): Hier kann der Nutzer seinen Namen und seine Telefonnummer eingeben, um sich für unseren Dienst zu registrieren.

• Der Verifizierungscode Eingabeseite (/enter-code): Hier gibt der Benutzer den PIN-Code ein, der von der Verify API an sein Telefon gesendet wurde.

Wir erstellen diese Seiten mit Go-Vorlagen. Diese erleichtern die Übergabe von Variablen aus dem Code in die Seite und ermöglichen es auch, dass eine Vorlage andere als "Teilvorlagen" einschließt, so dass Sie gemeinsame Inhalte wie Kopfzeilen, Menüs usw. nicht duplizieren müssen.

Fügen Sie zunächst das html/template Modul in die Liste der Importe in main.go. Erstellen Sie dann die folgenden Vorlagen im Verzeichnis tmpl Verzeichnis:

Die Basisseitenvorlage

Dies ist das Basislayout, das alle unsere Vorlagen verwenden werden. Die {{template "main" .}} lässt uns den Seitenkörper mit Inhalten aus den anderen Vorlagen auffüllen:

<!-- base.layout.gohtml-->
{{define "base"}}
<!DOCTYPE html>
<html>

<head>
  <meta charset="utf-8">
  <title>Go Verify Demo</title>
  <link rel="stylesheet" href="/static/style.css">
  <link rel="preconnect" href="https://fonts.gstatic.com">
  <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@300&family=Seymour+One&display=swap" rel="stylesheet">
</head>

<body>
  {{template "main" .}}
</body>

</html>
{{end}}

Die Vorlage für die Startseite

Wenn sich der Benutzer erfolgreich für den Dienst registriert hat, werden auf dieser Seite sein Name und seine Telefonnummer angezeigt:

<!-- home.page.gohtml -->
{{template "base" .}}

{{define "main"}}
  <h1>Welcome to Acme Inc {{.Name}}!</h1>
  <p>Your registered phone number is: {{.Phone}}</p>
{{end}}

Die Vorlage für die Registrierungsseite

Diese Vorlage enthält ein Formular, in das der Benutzer seinen Namen und seine Telefonnummer eingeben kann, um sich für den Dienst zu registrieren:

<!-- register.page.gohtml -->
{{template "base" .}}

{{define "main"}}
  <h1>Acme inc.</h1>
  <p>Please register using your mobile/cell phone number for the exciting benefits our service provides!</p>
  <form action="/verify">
    <fieldset>
      <label for="name">Your name:</label>
      <input type="text" class="ghost-input" id="name" name="name" placeholder="Jane Smith" required/>   
      <label for="phone_number">Your mobile number:</label>
      <input type="text" class="ghost-input" id="phone_number" name="phone_number" placeholder="447700900001"required/>
      <button type="submit" class="ghost-button">Register</button>
    </fieldset>
  </form>
{{end}} 

Die Vorlage für die Seite "Code eingeben

Auf dieser Seite wird ein Formular angezeigt, in das der Benutzer den Code eingibt, den er von der Verify API erhalten hat:

<!-- entercode.page.gohtml -->
{{template "base" .}}

{{define "main"}}
  <h1>Acme inc.</h1>
  <p>Please enter the code you received by SMS:</p>
  <form action="/check-code">
    <fieldset>
      <label for="pin_code">Enter PIN:</label>
      <input type="text" class="ghost-input" id="pin_code" name="pin_code" placeholder="123456" required><br><br>
    <button type="submit" class="ghost-button">Let's Go!</button>
    </fieldset>
  </form>
  
{{end}} 

Hübsch(er) aussehen lassen

Zum Schluss fügen wir noch etwas CSS hinzu, damit diese Seiten so aussehen, als hätten wir in einige Mühe in ihre Erstellung investiert haben. (Ich bin leider kein Frontend-Spezialist, daher sind PRs sind sehr willkommen!)

Schnappen Sie sich die style.css Datei aus dem Github-Repositorium und fügen Sie sie in Ihr static Verzeichnis ein.

Go muss in der Lage sein, diese statischen CSS-Inhalte aus dem lokalen Dateisystem bereitzustellen, also müssen Sie Ihrer Anwendung mitteilen, wie sie das tun soll.

Unter main.goimportieren Sie zunächst das net/http Modul und ändern Sie dann Ihre main() Funktion wie folgt:

func main() {
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error loading .env file")
		os.Exit(1)
	}

	apiKey := os.Getenv("VONAGE_API_KEY")
	apiSecret := os.Getenv("VONAGE_API_SECRET")

	auth := vonage.CreateAuthFromKeySecret(apiKey, apiSecret)
	verifyClient = vonage.NewVerifyClient(auth)

	mux := http.NewServeMux()
	mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))

}

Verwalten Sie die Sitzung des Benutzers

Wir müssen uns überlegen, wie wir feststellen können, ob sich ein Benutzer für unseren Dienst registriert hat, damit wir ihn entweder anmelden oder zur Registrierungsseite weiterleiten können.

Um das zu tun, werden wir uns auf Session-Cookies verlassen. Es gibt ein großartiges Modul, mit dem wir Cookie- und Dateisystem-Sessions in Go verwalten können: das Gorilla-Sitzungsmodul.

Zum Installieren führen Sie es aus:

Fügen Sie es zu Ihrer Liste der Importe in main.go und erstellen Sie das Sitzungscookie. Wenn Sie schon dabei sind, deklarieren Sie auch eine struct namens UserData der den Namen und die Telefonnummer eines registrierten Benutzers speichern wird. Wir übergeben dies struct an unsere Homepage-Vorlage weiter, damit wir diese Details anzeigen können, sobald sich der Benutzer erfolgreich registriert hat:

package main

import (
	"html/template"
	"log"
	"net/http"
	"os"

	"github.com/gorilla/sessions"
	"github.com/joho/godotenv"
	"github.com/vonage/vonage-go-sdk"
)

var (
	// Key must be 16, 24 or 32 bytes long (AES-128, AES-192 or AES-256)
	key   = []byte("super-secret-key")
	store = sessions.NewCookieStore(key)
)

// UserData - Info from session that we'll use in the UI
type UserData struct {
	Name  string
	Phone string
}

...

Definieren Sie die Routen

Nun müssen wir überlegen, welche Routen wir für die Verwaltung unseres Arbeitsablaufs definieren müssen. Wir werden die folgenden Routen erstellen:

• Die Website Einstiegspunkt zu unserer Anwendung (/). Hier wird die Startseite angezeigt (wenn der Benutzer registriert ist), oder er wird zur /register Route (wenn er nicht registriert ist).

• Die Anmeldung Route (/register). Sie zeigt das Registrierungsformular an, das, wenn es abgeschickt wird, den Verifizierungsprozess einleitet, indem es die /verify Route.

• Die Website Überprüfung Route (/verify). Sie stellt eine Verify-Anfrage an die Verify API, um einen Code an das mobile Gerät des Benutzers zu senden. Anschließend wird sie an die /enter-code Route.

• Die Code eingeben Route (/enter-code) präsentiert dem Benutzer ein Formular mit einem Textfeld, in das er den erhaltenen PIN-Code eingeben kann. Wenn er das Formular abschickt, leiten wir ihn zur /check-code Route.

• Der Prüfcode Route (check-code). Dabei wird der eingegebene Code mit dem von der Verify API gesendeten Code verglichen. Bei einer Übereinstimmung werden die Daten des Benutzers in der Sitzung gespeichert und zur Startseite weitergeleitet (/). Wenn es keine Übereinstimmung gibt, wird eine Fehlermeldung auf der Konsole ausgegeben. (Wir könnten dies eleganter handhaben, aber das überlasse ich dem Leser als Übung).

• Die löschen Weg (/clear). Damit wird das Session-Cookie gelöscht, so dass Sie einen registrierten Benutzer "abmelden" können. Nützlich zum Testen!

Puh! Das ist ganz schön viel Code, den man schreiben muss. Zum Glück ist das alles ziemlich einfach.

Definieren Sie zunächst einige Handler für die Routen in Ihrer main Funktion und starten Sie Ihren Server, der auf eingehende Anfragen wartet:

func main() {
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error loading .env file")
		os.Exit(1)
	}

	apiKey := os.Getenv("VONAGE_API_KEY")
	apiSecret := os.Getenv("VONAGE_API_SECRET")

	auth := vonage.CreateAuthFromKeySecret(apiKey, apiSecret)
	verifyClient = vonage.NewVerifyClient(auth)

	mux := http.NewServeMux()
	mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
	mux.HandleFunc("/", home)
	mux.HandleFunc("/register", register)
	mux.HandleFunc("/verify", verify)
	mux.HandleFunc("/enter-code", enterCode)
	mux.HandleFunc("/check-code", checkCode)
	mux.HandleFunc("/clear", unregister)

	log.Println("Starting server on :5000")
	err = http.ListenAndServe(":5000", mux)
	log.Fatal(err)
}

Der Heimweg-Handler

Erstellen Sie den home Handler oberhalb Ihrer main Funktion. Dieser Handler wird immer dann ausgelöst, wenn ein Benutzer das Stammverzeichnis Ihrer Webanwendung unter /.

Er lädt das Sitzungs-Cookie und prüft, ob der registered Sitzungswert gesetzt ist. Ist dies der Fall, speichert es die Cookie-Informationen in einer Instanz von UserData und verwendet diese, um die Startseite mit dem Namen und der Telefonnummer des Benutzers anzuzeigen.

Ist dies nicht der Fall, erfolgt eine Umleitung auf die /register Route:

func home(w http.ResponseWriter, r *http.Request) {

	session, _ := store.Get(r, "acmeinc-cookie")

	// Check if user is authenticated
	if auth, ok := session.Values["registered"].(bool); !ok || !auth {
		// Not authenticated, so user must register
		http.Redirect(w, r, "/register", 302)
	}

	userData := UserData{
		Name:  fmt.Sprintf("%v", session.Values["name"]),
		Phone: fmt.Sprintf("%v", session.Values["phoneNumber"]),
	}

	files := []string{
		"./tmpl/home.page.gohtml",
		"./tmpl/base.layout.gohtml",
	}

	/* Use the template.ParseFiles() function to read the files and store the
	templates in a template set.*/
	ts, err := template.ParseFiles(files...)
	if err != nil {
		log.Println(err.Error())
		http.Error(w, "Internal Server Error", 500)
		return
	}

	err = ts.Execute(w, userData)
	if err != nil {
		log.Println(err.Error())
		http.Error(w, "Internal Server Error", 500)
	}
}

Das Register Route Handler

Die Registrierungsroute zeigt ein Formular an, in das der Benutzer seinen Namen und seine Telefonnummer eingeben muss, um sich für den Dienst zu registrieren.

Fügen Sie zunächst fmt zu Ihrer Liste der Importe hinzu. Dann erstellen Sie den register Handler oberhalb Ihrer main Funktion:

func register(w http.ResponseWriter, r *http.Request) {
	files := []string{
		"./tmpl/register.page.gohtml",
		"./tmpl/base.layout.gohtml",
	}

	ts, err := template.ParseFiles(files...)
	if err != nil {
		log.Println(err.Error())
		http.Error(w, "Internal Server Error", 500)
		return
	}

	err = ts.Execute(w, nil)
	if err != nil {
		log.Println(err.Error())
		http.Error(w, "Internal Server Error", 500)
	}
}

Der Verify Route Handler

Wenn der Nutzer seine Registrierungsdaten eingegeben und auf die Schaltfläche "Registrieren" geklickt hat, ruft die App die /verify Route auf. Hier erstellen wir die erste Anfrage an die Verify API, um einen Code zu generieren und ihn an das Telefon des Nutzers zu senden.

Wenn Sie eine Anfrage an die Verify API übermitteln, gibt diese ein request_id zurück, um diese spezielle Anfrage zu identifizieren. Sie benötigen diese ID, wenn Sie den vom Benutzer eingegebenen Code überprüfen, also speichern Sie sie in einer globalen Variablen:

package main

import (
	...
)

var (
	...
)

// UserData: Info from session that we'll use in the UI
type UserData struct {
	...
}

var verifyClient *vonage.VerifyClient
var requestID string

Das Initiieren dieser Anfrage ist mit dem Go-SDK sehr einfach. Wir rufen die VerifyClient.Request Methode auf und übergeben die Telefonnummer des Benutzers, den Text, der in der Verifizierungs-SMS erscheinen soll, und einige Optionen zur Anpassung des Verifizierungsprozesses.

In diesem Beispiel geben wir die folgenden Optionen an:

• CodeLength: Dies ist die Länge des Codes, den wir an den Benutzer senden. Standardmäßig ist er vierstellig, aber wir generieren einen sechsstelligen Code.

• Lg: Legt die Sprache fest, in der die Verifizierungs-SMS gesendet werden soll, und zwar aus der Liste der verfügbaren Sprachen.

• WorkflowID: Die Verify API unternimmt mehrere Versuche, einen Verifizierungscode zu senden. Wie und wann diese Versuche unternommen werden, hängt von dem von Ihnen gewählten Workflow ab. Wir verwenden den Workflow mit einer ID von 4der den Code per SMS sendet und dann zwei Minuten wartet, bis der Code verifiziert ist. Wird er danach nicht verifiziert, wird der Code erneut gesendet und weitere drei Minuten gewartet, bevor der Vorgang abgebrochen wird. Andere Arbeitsabläufe verwenden eine Mischung aus SMS und Sprachanrufen mit Text-to-Speech, um den Verifizierungscode zu übermitteln.

Wir werden auch die Informationen, die der Benutzer eingegeben hat, in unserem Sitzungscookie speichern.

Schreiben Sie den Code für den verify Routenhandler oberhalb Ihrer main Funktion:

func verify(w http.ResponseWriter, r *http.Request) {

	session, _ := store.Get(r, "acmeinc-cookie")
	// retrieve user's name and phone number from the submitted form
	userName := r.URL.Query().Get("name")
	phoneNumber := r.URL.Query().Get("phone_number")
	session.Values["name"] = userName
	session.Values["phoneNumber"] = phoneNumber
	session.Save(r, w)
	log.Println("Verifying...." + userName + " at " + phoneNumber)
	response, errResp, err := verifyClient.Request(phoneNumber, "GoTest", vonage.VerifyOpts{CodeLength: 6, Lg: "en-gb", WorkflowID: 4})

	if err != nil {
		fmt.Printf("%#v\n", err)
	} else if response.Status != "0" {
		fmt.Println("Error status " + errResp.Status + ": " + errResp.ErrorText)
	} else {
		requestID = response.RequestId
		fmt.Println("Request started: " + response.RequestId)
		// redirect to "check" page
		http.Redirect(w, r, "/enter-code", 302)
	}
}

Der Handler für die Codeeingabe

Wenn alles nach Plan gelaufen ist, erhält der Nutzer nun eine SMS mit einem PIN-Code. Unsere /enter-code Route wird ein Formular bereitstellen, in das der Nutzer diesen Code eingeben kann.

Fügen Sie den enterCode Route Handler zu Ihrer Anwendung hinzu:

func enterCode(w http.ResponseWriter, r *http.Request) {
	files := []string{
		"./tmpl/entercode.page.gohtml",
		"./tmpl/base.layout.gohtml",
	}

	ts, err := template.ParseFiles(files...)
	if err != nil {
		log.Println(err.Error())
		http.Error(w, "Internal Server Error", 500)
		return
	}

	err = ts.Execute(w, nil)
	if err != nil {
		log.Println(err.Error())
		http.Error(w, "Internal Server Error", 500)
	}
}

Der Prüfcode-Routenhandler

Wenn der Benutzer den per SMS erhaltenen Code eingegeben hat, müssen wir eine Verify-Prüfung durchführen, um sicherzustellen, dass der eingegebene Code mit dem zugesandten übereinstimmt. Wir verwenden die VerifyClient.Check Methode und übergeben die ID der Anfrage, die wir im verify Route Handler und den Code, den sie in unsere Seite eingegeben haben.

Wenn der Code übereinstimmt, setzen wir den registered Sitzungscookie-Wert auf true und leiten zur Startseite weiter. Wenn nicht, wird eine Fehlermeldung auf der Konsole ausgegeben:

func checkCode(w http.ResponseWriter, r *http.Request) {
	// Retrieve the PIN code that the user entered
	session, _ := store.Get(r, "acmeinc-cookie")
	pinCode := r.URL.Query().Get("pin_code")
	response, errResp, err := verifyClient.Check(requestID, pinCode)

	if err != nil {
		fmt.Printf("%#v\n", err)
	} else if response.Status != "0" {
		fmt.Println("Error status " + errResp.Status + ": " + errResp.ErrorText)
	} else {
		fmt.Println("Request complete: " + response.RequestId)
		// Set user as authenticated and return to home page
		session.Values["registered"] = true
		session.Save(r, w)
		http.Redirect(w, r, "/", 302)
	}
}

Der Clear Route Handler

Dies wird für Tests nützlich sein. Damit können Sie den Benutzer zurücksetzen, indem Sie eine Anfrage an http://localhost:5000/cleardie das Sitzungs-Cookie löscht.

Erstellen Sie den unregister Routenhandler wie folgt:

func unregister(w http.ResponseWriter, r *http.Request) {
	// Delete the session
	session, _ := store.Get(r, "acmeinc-cookie")
	session.Options.MaxAge = -1
	session.Save(r, w)
	http.Redirect(w, r, "/", 302)
}

Probieren Sie es aus!

Sie sind fertig! Jetzt ist es an der Zeit, Ihre Anwendung zu testen.

1. Starten Sie die Anwendung, indem Sie go run main.go

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

3. Geben Sie Ihren Namen und Ihre Telefonnummer ein, einschließlich der Vorwahl, aber ohne führende Nullen. Zum Beispiel sollte die britische Mobiltelefonnummer 07700900001 sollte wie folgt eingegeben werden 447700900001:

   Registration page

4. Sie erhalten dann eine SMS mit einem sechsstelligen Code:

   The verification code, sent by SMS

5. Geben Sie diesen Code in die App ein:

   Entering the verificaiton code

6. Sie sind registriert und werden zur Startseite weitergeleitet:

   ![Angemeldet auf der Startseite]( "Angemeldet auf der Hauptseite")

Was nun?

Sie haben hoffentlich gesehen, wie einfach es ist, die Verify API und das Go SDK zu verwenden, um die Zwei-Faktor-Authentifizierung in Ihren Anwendungen zu aktivieren. Der gesamte Verifizierungsprozess erforderte tatsächlich nur ein paar Zeilen Code! Der größte Teil der Arbeit bestand in der Erstellung und Verwaltung der Benutzeroberfläche.

Hinweis: Falls Sie es nicht geschafft haben, dem Tutorial zu folgen, finden Sie den vollständigen Quellcode für dieses Tutorial auf GitHub.

Denken Sie, dass diese Demo einige Verbesserungen gebrauchen könnte? Ich stimme zu! Das sind die Verbesserungen, die mir einfallen:

• Der nicht ganz so elegante Abgang, wenn der Benutzer den falschen Code eingibt. Stattdessen könnten Sie den Benutzer auf die Seite "Code eingeben" umleiten und gleichzeitig den Fortschritt der Anfrage überprüfenund vielleicht sogar Abbrechen einer laufenden Anfrage nach zwei Fehlversuchen abbrechen.

• Das Format, in dem die Nutzer ihre Telefonnummern eingeben müssen. Die Vonage APIs erwarten, dass die Telefonnummern im E.164-Formataber es gibt keinen Grund, warum Sie das Ihren Benutzern zumuten sollten! Sie können sie ihre lokale Nummer und ihr Land aus einer Dropdown-Liste eingeben lassen und die Vonage Number Insight API verwenden, um sie in das richtige Format umzuwandeln. Auf diese Weise können Sie auch überprüfen, ob die vom Benutzer eingegebene Nummer rechtmäßig ist.

Wir hoffen, Sie sind von unserem neuen Go-SDK genauso begeistert wie wir. Um mehr darüber und über die Verify API zu erfahren, lesen Sie die folgenden Ressourcen:

• Das Vonage Go SDK-Paket

• Go SDK Anwendungsbeispiele

• Die Verify API-Dokumentation

• Die Verify API-Referenz