Trousse SDK Guardian pour Android

La trousse SDK Guardian pour Android vous aide à créer des applications Android avec la fonctionnalité Guardian, offrant un accès sécurisé à l’authentification multifacteur (MFA) avec des notifications poussées. Avec cette boîte à outils, vous pouvez créer votre propre version personnalisée de l’application Guardian qui correspond à l’image de votre organization. Pour en savoir plus, consultez Configurer les notifications poussées pour la MFA.

Une version d’API Android supérieure ou égale à 15 est requise pour utiliser la trousse SDK Guardian pour Android.

Guardian est disponible sur Maven Central et JCenter.

1. Pour utiliser Guardian, ajoutez ces lignes à votre fichier de dépendances build.gradle : implementation ’com.auth0.android:guardian:0.4.0’ Vous pouvez vérifier la version la plus récente sous l’onglet Lancements du répertoire, dans Maven, ou dans JCenter.

2. Assurez-vous de synchroniser votre projet avec le fichier Gradle après avoir ajouté votre dépendance Gradle.

1. Allez à Dashboard > Sécurité > Authentification multifacteur > Notifications poussées via Gardien Auth0.

2. Basculez le commutateur vers le haut pour l’activer.

3. Configurer les notifications poussées.

Guardian est la portion centrale de la trousse SDK. Vous devrez créer une instance de cette classe pour l’URL de votre locataire spécifique.

Uri url = Uri.parse("https://<tenant>.<region>.auth0.com");

Guardian guardian = new Guardian.Builder()
    .url(url)
    .build();

ou

String domain = "<tenant>.<region>.auth0.com";

Guardian guardian = new Guardian.Builder()
    .domain(domain)
    .build();

Le lien entre le deuxième facteur (une instance de votre application sur un appareil) et un compte Auth0 est appelé inscription.

Vous pouvez créer une inscription à l’aide de la fonction Guardian.enroll, mais vous devrez d’abord créer une nouvelle paire de clés RSA pour celle-ci. La clé privée sera utilisée pour signer les demandes d’autorisation ou de rejet d’une connexion. La clé publique sera envoyée pendant le processus d’inscription afin que le serveur puisse vérifier la signature de la demande par la suite.

KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(2048); // you MUST use at least 2048 bit keys
KeyPair keyPair = keyPairGenerator.generateKeyPair();

Ensuite, obtenez les informations d’inscription en balayant le code QR de Guardian et utilisez-le pour inscrire le compte :

Uri enrollmentUriFromQr = ...; // the URI obtained from a Guardian QR code

CurrentDevice device = new CurrentDevice(context, "fcmToken", "deviceName");

Enrollment enrollment = guardian
    .enroll(enrollmentUriFromQr, device, keyPair)
    .execute();

Vous pouvez également exécuter la requête dans un thread en arrière-plan :

guardian
    .enroll(enrollmentUriFromQr, device, keyPair)
    .start(new Callback<Enrollment> {
        @Override
        void onSuccess(Enrollment enrollment) {
            // we have the enrollment data
        }

        @Override
        void onFailure(Throwable exception) {
            // something failed
        }
    });

Vous devez fournir les données suivantes :

Pour désactiver la MFA, vous pouvez supprimer l’inscription :

guardian
    .delete(enrollment)
    .execute(); // or start(new Callback<> ...)

Une fois l’inscription en place, vous recevrez une notification poussée FCM chaque fois que l’utilisateur aura besoin d’une authentification multifacteur (MFA).

Guardian procure une méthode pour analyser les données Map (Carte) <String, String > dans le RemoteMessage reçu du FCM et retourner une instance de Notification prête à être utilisée.

// at the FCM listener you receive a RemoteMessage
@Override
public void onMessageReceived(RemoteMessage message) {
    Notification notification = Guardian.parseNotification(message.getData());
    if (notification != null) {
        // you received a Guardian notification, handle it
        handleGuardianNotification(notification);
        return;
    }

    /* handle other push notifications you might be using ... */
}

Une fois que vous disposez de l’instance de notification, vous pouvez utiliser la méthode Allow (Autoriser) pour approuver la demande d’authentification. Vous aurez également besoin de l’inscription que vous avez obtenue précédemment. S’il y a plusieurs inscriptions, assurez-vous d’utiliser celle qui a le même id que la notification (la propriété enrollmentId).

guardian
    .allow(notification, enrollment)
    .execute(); // or start(new Callback<> ...)

Pour refuser une demande d’authentification, utilisez plutôt reject (rejeter). Vous pouvez également ajouter un motif facultatif de rejet, qui sera disponible dans les journaux de Guardian.

guardian
    .reject(notification, enrollment) // or reject(notification, enrollment, reason)
    .execute(); // or start(new Callback<> ...)

Vous pouvez activer les mots de passe à usage unique comme facteur MFA à l’aide du Auth0 Dashboard ou de Management API. Cette option ne nécessite pas de code QR et permet aux utilisateurs de s’inscrire manuellement.

Pour inviter un utilisateur à s’inscrire, naviguez vers Auth0 Dashboard > Gestion d’utilisateur > Utilisateurs et sélectionnez un utilisateur. Ensuite, accédez à son onglet Détails et utilisez la section Authentification multifacteur (MFA) pour envoyer une invitation d’inscription.

Vous pouvez connecter une ressource à partir du Auth0 Dashboard ou de la trousse SDK Guardian.

1. Accédez à l’invite de connexion Auth0 et copiez le code fourni ou une clé codée en base32 similaire obtenue à partir d’une autre source.

   

2. Après avoir obtenu votre code, ajoutez-le à la trousse SDK Guardian :

Java

public String copiedCode = "{copiedCode}";

Kotlin

val copiedCode: String = "{copiedCode}"

Premièrement, ajoutez la classe LoginCodeGenerator à votre projet. Ensuite, utilisez getCode (String copiedCode) pour générer un code à usage unique à votre application

Java

public class LoginCodeGenerator {

   private static final int TOTP_LENGTH = 6;

   private static final int TOTP_DURATION = 30;

   private static final String TOTP_ALGORITHM = "SHA1";

   public String getCode(String copedCode) {

       byte[] key = new byte[0];

       try {

           key = Base32.decode(copedCode);

       } catch (Base32.DecodingException ex) {

//            handle exception

       }

       TOTP totp = new TOTP(TOTP_ALGORITHM, key, TOTP_LENGTH, TOTP_DURATION);

       return totp.generate();

   }

}

Kotlin

class LoginCodeGenerator {

   fun getCode(copiedCode: String): String {

       var key: ByteArray? = ByteArray(0)

       try {

           key = Base32.decode(copiedCode)

       } catch (ex: Base32.DecodingException) {

//            handle exception

       }

       val totp = TOTP(TOTP_ALGORITHM, key, TOTP_LENGTH, TOTP_DURATION)

       return totp.generate()

   }

   companion object {

       private const val TOTP_LENGTH = 6

       private const val TOTP_DURATION = 30

       private const val TOTP_ALGORITHM = "SHA1"

   }

}

Saisissez le mot de passe à usage unique généré par getCode() dans l’invite de connexion Auth0.

Après avoir sélectionné Continue (Continuer), un message s’affiche indiquant que votre application a été ajoutée comme facteur d’authentification pour votre utilisateur.

Une fois le facteur inscrit, votre utilisateur peut se connecter à l’aide de votre application. Tout d’abord, choisissez l’application Guardian comme méthode d’authentification.

Pour générer le code à usage unique, appelez getCode(copiedCode: String) à l’aide du code copié de l’invite de connexion Auth0.

Ensuite, saisissez le code à usage unique dans l’invite de connexion pour vérifier votre identité.

• Configuration des notifications poussées pour MFA