Självstudie: Lägg till registrering av metod för stark autentisering via e-post i din Android-app

Den här självstudien visar hur du implementerar registrering av stark autentiseringsmetod för e-post i din Android-app med inbyggd autentisering. Minst en stark autentisering är obligatorisk för MFA-aktiverade användare (multifaktorautentisering). För närvarande stöder vi endast e-post och SMS engångslösenord som stark autentiseringsmetod.

I den här tutorialen lär du dig följande:

  • Registrera en stark autentiseringsmetod för en MFA-aktiverad användare.
  • Hantera starka registreringsfel för autentiseringsmetoder.

Förutsättningar

  1. Slutför stegen i Självstudie: Lägg till inloggning i Android-appen med inbyggd autentisering.

  2. Om du vill framtvinga MFA för dina kunder använder du stegen i Lägg till MFA i en app för att lägga till OTP MFA för e-post i ditt inloggningsflöde. För närvarande stöder intern autentisering e-post och SMS engångslösenord som en andra faktor för MFA. Därför är e-post-OTP som andra faktor endast tillgänglig när autentiseringsmetoden är e-post med lösenord.

  3. Om du vill utforska vår implementering av stark autentiseringsmetod kan du ta en titt på vårt Code-exempel innan du kommer igång.

Lägga till stark autentiseringsmetodregistrering i klientkonfigurationsfilen

Om du vill ha stöd för en stark autentiseringsmetod uppdaterar du Android-klientkonfigurationen så att den innehåller de registreringsfunktioner som krävs.

{
    "client_id": "Enter_the_Application_Id_Here",
    "authorities": [
    {
        "type": "CIAM",
        "authority_url": "https://Enter_the_Tenant_Subdomain_Here.ciamlogin.com/Enter_the_Tenant_Subdomain_Here.onmicrosoft.com/"
    }
    ],
    "challenge_types": ["oob", "password"],
    "capabilities": ["registration_required"],
    "logging": {
    "pii_enabled": false,
    "log_level": "INFO",
    "logcat_enabled": true
    }
}

Registrera engångslösenord för e-post som stark autentiseringsmetod

Om du vill registrera ett engångslösenord för ett e-postmeddelande för en MFA-aktiverad användare kan du antingen använda standard-e-postadressen som angavs när kontot skapades eller ange en alternativ e-postadress som stark autentiseringsmetod. Den här processen utlöses bara första gången MFA krävs och användaren har ingen stark autentiseringsmetod registrerad. Efteråt måste du skicka ett e-postmeddelande som innehåller ett engångslösenord för att användaren ska kunna verifiera sin e-postadress. När användaren har angett ett giltigt engångslösenord slutför appen inloggningsprocessen.

Om du vill registrera en stark autentiseringsmetod (e-post engångslösenord) för MFA-aktiverad användare måste du:

  1. Skapa ett användargränssnitt (UI) för att:

    • Meddela användaren att stark autentiseringsmetodregistrering krävs för att logga in (valfritt).
    • Samla in en e-postadress som ska registreras som stark autentiseringsmetod. Om användaren inte anger någon e-postadress används standardadressen för e-postadressen som angavs när kontot skapades.
    • Samla in ett engångslösenord för e-post från användaren för att utföra tvåfaktorautentisering.
    • Skicka engångslösenordet igen (rekommenderas).

  2. Hantera StrongAuthMethodRegistrationRequired inloggningsresultat:

     val parameters = NativeAuthSignInParameters(username = email)
 parameters.password = password 
 val signInResult: SignInResult = authClient.signIn(parameters) 

 when (actionResult) {
     // Handle "strong authentication method registration required" result 
     is SignInResult.StrongAuthMethodRegistrationRequired -> {
         val authMethod = actionResult.authMethods.first {it.challengeChannel.uppercase() == "EMAIL"}
         // Next Step: challengeAuthMethod using nextState 
     }
 }

    När du loggar in, om MFA är nödvändigt och det inte finns någon stark autentisering registrerad, returnerar systemet SignInResult.StrongAuthMethodRegistrationRequired och kräver att användaren anger en alternativ e-postadress som sin starka autentiseringsmetod eller använder den e-postadress som angavs vid kontots skapande.

  3. Hantera challengeAuthMethod() resultat:

    val registerStrongAuthState = signInResult.nextState
verificationContact = "user@contoso.com" // Do NOT hard-code email in production. Use the email provided during account creation or prompt the user for input.
val params = NativeAuthChallengeAuthMethodParameters(authMethod, verificationContact = verificationContact)
val challengeAuthResult = registerStrongAuthState.challengeAuthMethod(params)

when (challengeAuthResult) {
    is RegisterStrongAuthChallengeResult.VerificationRequired -> {
        // Next Step: submitChallenge using nextState
    }
    is RegisterStrongAuthChallengeError -> {
        // Handle "register strong auth challenge" error
    }
    else -> {
        // Handle unexpected result
    }
}

    Metoden challengeAuthMethod() skickar ett engångslösenord till den e-postadress som anges i verificationContact. I det vanligaste scenariot challengeAuthMethod()returnerar ett resultat RegisterStrongAuthChallengeResult.VerificationRequiredsom anger att SDK förväntar sig att appen skickar engångslösenordet för e-post som har skickats till e-postadressen. Objektet RegisterStrongAuthChallengeResult.VerificationRequired innehåller en ny tillståndsreferens som du kan hämta via challengeAuthResult.nextState. Det nya tillståndet ger dig åtkomst till metoden submitChallenge() som du kan använda för att skicka engångslösenordet per e-post till användarens e-postadress.

  4. Hantera submitChallenge() resultat:

    val registerStrongAuthVerificationRequiredState = challengeAuthResult.nextState
val submitChallengeResult = registerStrongAuthVerificationRequiredState.submitChallenge(emailCode)

when (actionResult) {
    is SignInResult.Complete -> {
        // Handle sign in success      
    }
    is RegisterStrongAuthSubmitChallengeError -> {
        // Handle "register strong auth submit challenge" error
    }
    else -> {
        // Handle unexpected result      
    }
}

    I det vanligaste scenariot submitChallenge() returnerar resultatet SignInResult.Complete, vilket indikerar att användaren har autentiserats.

Hantera starka registreringsfel för autentiseringsmetoder

Om du vill hantera fel som uppstår vid registrering av stark autentiseringsmetod kan du använda följande kodfragment:

  1. Hantera fel för challengeAuthMethod() metoden:

    val challengeAuthResult = registerStrongAuthState.challengeAuthMethod(params)

if (challengeAuthResult is RegisterStrongAuthChallengeResult.VerificationRequired) {
    // Next Step: submit challenge
} else if (challengeAuthResult is RegisterStrongAuthChallengeError) {
    // Handle errors under RegisterStrongAuthChallengeError
    when {
        error.isInvalidInput() -> {
            // Display error
        }
        else -> {
            // Unexpected error
        }
    }
}

    RegisterStrongAuthChallengeError hanteras efter registrering av en utmaning med registerStrongAuthState.challengeAuthMethod()-metoden. isInvalidInput() Använd metoden för att söka efter det specifika felet, till exempel att den angivna verifieringskontakten är ogiltig. I det här fallet måste referensen till det tidigare tillståndet användas för att skicka en ny utmaning.

  2. Hantera fel för submitChallenge() metoden:

    val submitChallengeResult = registerStrongAuthVerificationRequiredState.submitChallenge(challenge = emailCode)

if (submitChallengeResult is SignInResult.Complete) {
    // Handle sign in success
} else if (submitChallengeResult is RegisterStrongAuthSubmitChallengeError) {
    // Handle errors under RegisterStrongAuthSubmitChallengeError
    when {
        error.isInvalidChallenge() -> {
            // Display error
        }
        else -> {
            // Unexpected error
        }
    }
}

    RegisterStrongAuthSubmitChallengeError bearbetas efter att uppgiften skickats in med hjälp av registerStrongAuthVerificationRequiredState.submitChallenge(challenge = emailCode). Använd isInvalidChallenge()-metoden för att söka efter det specifika felet, till exempel att den skickade uppgiften är ogiltig. I det här fallet måste den tidigare tillståndsreferensen användas för att upprepa utmaningens utförande.

Nästa steg

  • Last updated on