> ## Documentation Index
> Fetch the complete documentation index at: https://docs-dev-actions-triggers-prototype.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Trousse SDK Guardian pour Android
> Décrit comment installer, configurer et utiliser les options de la trousse SDK Gardien Auth0 pour Android.
La [trousse SDK Guardian pour Android](https://github.com/auth0/Guardian.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](https://auth0.com/docs/secure/multi-factor-authentication/multi-factor-authentication-factors/configure-push-notifications-for-mfa#configure-push-notifications-for-apple-using-apn-).
Une version d’API Android supérieure ou égale à 15 est requise pour utiliser la trousse SDK Guardian pour Android.
## Installer la trousse SDK Guardian pour Android
Guardian est disponible sur [Maven Central](http://search.maven.org/) et [JCenter](https://bintray.com/auth0/android/guardian).
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](https://github.com/auth0/GuardianSDK.Android/releases) du répertoire, dans [Maven](http://search.maven.org/#search%7Cgav%7C1%7Cg%3A%22com.auth0.android%22%20AND%20a%3A%22guardian%22), ou dans [JCenter](https://bintray.com/auth0/android/guardian).
2. Assurez-vous de synchroniser votre projet avec le fichier Gradle après avoir ajouté votre dépendance Gradle.
### Activer les notifications poussées de Guardian
1. Allez à [Dashboard > Sécurité > Authentification multifacteur > Notifications poussées via Gardien Auth0.](https://manage.auth0.com/#/security/mfa/guardian)
2. Basculez le commutateur vers le haut pour l’activer.
3. [Configurer les notifications poussées](https://auth0.com/docs/secure/multi-factor-authentication/multi-factor-authentication-factors/configure-push-notifications-for-mfa#configure-push-notifications-for-android-using-fcm).
## Utiliser la trousse SDK
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.
```java lines theme={null}
Uri url = Uri.parse("https://..auth0.com");
Guardian guardian = new Guardian.Builder()
.url(url)
.build();
```
ou
```java lines theme={null}
String domain = "..auth0.com";
Guardian guardian = new Guardian.Builder()
.domain(domain)
.build();
```
### Inscription
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.
```java lines theme={null}
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 :
```java lines theme={null}
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 :
```java lines theme={null}
guardian
.enroll(enrollmentUriFromQr, device, keyPair)
.start(new Callback {
@Override
void onSuccess(Enrollment enrollment) {
// we have the enrollment data
}
@Override
void onFailure(Throwable exception) {
// something failed
}
});
```
Vous devez fournir les données suivantes :
| Variable | Description |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `deviceName` | Nom de l’inscription présentée à l’utilisateur lorsqu’un deuxième facteur d’authentification est requis. |
| `fcmToken` | Jeton pour pour le service de notification poussée FCM (Firebase Cloud Messaging). Consultez [Exemple de registre](https://firebase.google.com/docs/cloud-messaging/android/client#sample-register) pour en savoir plus. |
### Désinscription
Pour désactiver la MFA, vous pouvez supprimer l’inscription :
```java lines theme={null}
guardian
.delete(enrollment)
.execute(); // or start(new Callback<> ...)
```
### Autoriser les demandes de connexion
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) ` dans le [RemoteMessage](https://firebase.google.com/docs/reference/android/com/google/firebase/messaging/RemoteMessage) reçu du FCM et retourner une instance de `Notification` prête à être utilisée.
```javascript lines theme={null}
// 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`).
```java lines theme={null}
guardian
.allow(notification, enrollment)
.execute(); // or start(new Callback<> ...)
```
### Rejeter les demandes de connexion
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.
```java lines theme={null}
guardian
.reject(notification, enrollment) // or reject(notification, enrollment, reason)
.execute(); // or start(new Callback<> ...)
```
### Configurer l’inscription du mot de passe à usage unique seulement sur mobile
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](https://manage.auth0.com/#/users) 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.
#### Connecter une ressource
Vous pouvez connecter une ressource à partir du Auth0 Dashboard ou de la trousse SDK Guardian.
##### Utilisation de Auth0 Dashboard
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}"`
##### Installer la trousse SDK Guardian
Premièrement, ajoutez la classe `LoginCodeGenerator` à votre projet. Ensuite, utilisez `getCode (String copiedCode) pour` générer un code à usage unique à votre application
**Java**
```java lines expandable theme={null}
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**
```kotlin lines expandable theme={null}
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"
}
}
```
#### Saisir le code à usage unique
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.
#### Se connecter avec votre application
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é.
## En savoir plus
* [Configuration des notifications poussées pour MFA](/docs/fr-ca/secure/multi-factor-authentication/multi-factor-authentication-factors/configure-push-notifications-for-mfa)