AUTHENTIFICATION PAR EMPREINTES DIGITALES DANS UN PROGRAMME ANDROID
Traduction du cours en français : https://www.techotopia.com/index.php...ation_Tutorial
INTRODUCTION
L'authentification par empreintes digitales utilise le capteur tactile intégré à de nombreux appareils Android pour identifier l'utilisateur et lui permettre d'accéder aux fonctionnalités de l'appareil et de l'application, telles que les options de paiement au sein de l'application. La mise en œuvre de l'authentification par empreintes digitales est un processus à plusieurs étapes qui peut, au premier abord, sembler accablant. Cependant, une fois décomposé en étapes individuelles, le processus devient beaucoup moins complexe. En termes de base, l'authentification d'empreinte digitale est principalement une question de chiffrement impliquant une clé, un chiffrement pour effectuer le chiffrement et un gestionnaire d'empreintes digitales pour gérer le processus d'authentification.
Ce chapitre fournit à la fois un aperçu de l'authentification des empreintes digitales et un tutoriel détaillé, étape par étape, qui démontre une approche pratique de la mise en œuvre.
Table des matières
I. Un aperçu de l'authentification par empreinte digitale
II. Création du projet d'authentification d'empreintes digitales
III. Configuration de l'authentification par empreinte digitale du périphérique
IV. Ajout de l'autorisation d'empreinte digitale au fichier manifeste
V. Téléchargement de l'icône d'empreinte digitale
VI. Concevoir l'interface utilisateur
VII. Accès aux services Keyguard et Fingerprint Manager
VIII. Vérification des paramètres de sécurité
IX. Accès au magasin de clés et au KeyGenerator Android
X. Générer la clé
XI. Initialiser le code
XII. Création de l'instance CryptoObject
XIII. Implémentation de la classe du gestionnaire d'authentification par empreintes digitales
XIV. Tester le projet
XV. Résumé
I. Un aperçu de l'authentification par empreinte digitale
Il existe essentiellement 10 étapes pour implémenter l'authentification par empreinte digitale dans une application Android. Ces étapes peuvent être résumées comme suit:
1. Demandez l'autorisation d'authentification d'empreinte digitale dans le fichier manifeste du projet.
2. Vérifiez que l'écran de verrouillage de l'appareil sur lequel s'exécute l'application est protégé par un code PIN, un modèle ou un mot de passe (les empreintes digitales ne peuvent être enregistrées que sur les appareils sur lesquels l'écran de verrouillage a été sécurisé).
3. Vérifiez qu'au moins une empreinte digitale a été enregistrée sur l'appareil.
4. Créez une instance de la classe FingerprintManager.
5. Utilisez une instance de Keystore pour accéder au conteneur Android Keystore. Ceci est une zone de stockage utilisée pour le stockage sécurisé des clés cryptographiques sur les appareils Android.
6. Générez une clé de chiffrement à l'aide de la classe KeyGenerator et stockez-la dans le conteneur Keystore.
7. Initialisez une instance de la classe Cipher à l'aide de la clé générée à l'étape 5.
8. Utilisez l'instance Cipher pour créer un objet CryptoObject et affectez-le à l'instance FingerprintManager créée à l'étape 4.
9. Appelez la méthode d'authentification de l'instance FingerprintManager.
10. Implémenter des méthodes pour gérer les callbacks déclenchés par le processus d'authentification. Fournissez un accès au contenu ou à la fonctionnalité protégée à la fin d'une authentification réussie.
Chacune des étapes ci-dessus sera abordée plus en détail tout au long du tutoriel décrit dans le reste de ce chapitre.
II. Création du projet d'authentification d'empreintes digitales
Commencez cet exemple en lançant l'environnement Android Studio et en créant un nouveau projet, en entrant FingerprintDemo dans le champ Nom de l'application et ebookfrenzy.com en tant que paramètre Domaine de la société avant de cliquer sur le bouton Suivant.
Dans l'écran des facteurs de forme, activez l'option Téléphone et tablette et définissez le paramètre SDK minimal sur API 23: Android 6.0 (Marshmallow). Continuez à travers les écrans de configuration, en demandant la création d'une activité vide nommée FingerprintDemoActivity avec une mise en page correspondante nommée activity_fingerprint_demo.
III. Configuration de l'authentification par empreinte digitale du périphérique
L'authentification par empreinte digitale n'est disponible que sur les appareils contenant un capteur tactile et sur lesquels les étapes de configuration appropriées ont été effectuées pour sécuriser l'appareil et enregistrer au moins une empreinte digitale. Pour plus d'informations sur la configuration d'une session d'émulateur pour tester l'authentification par empreinte, reportez-vous au chapitre Utilisation et configuration de l'émulateur AVD d'Android Studio 2.
Pour configurer l'authentification par empreinte digitale sur un périphérique physique, commencez par ouvrir l'application Paramètres et sélectionnez l'option Sécurité. Dans l'écran Paramètres de sécurité, sélectionnez l'option Empreinte digitale. Sur l'écran d'information résultant, cliquez sur le bouton Continuer pour passer à l'écran de configuration de l'empreinte digitale. Avant que la sécurité des empreintes digitales puisse être activée, une méthode de déverrouillage d'écran de secours (telle qu'un code PIN) doit être configurée. Cliquez sur le bouton Configurer le verrouillage de l'écran si l'écran de verrouillage n'est pas déjà sécurisé et suivez les étapes pour configurer le code PIN, le motif ou la sécurité du mot de passe.
Une fois l'écran verrouillé, passez à l'écran de détection des empreintes digitales et touchez le capteur lorsque vous y êtes invité (Fig. 1), en répétant le processus pour ajouter des empreintes digitales supplémentaires si nécessaire.
Fig. 1
IV. Ajout de l'autorisation d'empreinte digitale au fichier manifeste
L'authentification par empreinte nécessite que l'application demande l'autorisation USE_FINGERPRINT dans le fichier manifeste du projet. Dans la fenêtre de l'outil Projet Android Studio, recherchez et modifiez le fichier app -> manifestes -> AndroidManifest.xml pour ajouter la demande d'autorisation comme suit:
1
2
3
4
5
| <?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.ebookfrenzy.fingerprintdemo1">
<uses-permission
android:name="android.permission.USE_FINGERPRINT" /> |
V. Téléchargement de l'icône d'empreinte digitale
Google fournit une icône standard qui doit être affichée chaque fois qu'une application demande l'authentification d'un utilisateur.
Une copie de cette icône peut être téléchargée à partir de l'URL suivante:
http://www.ebookfrenzy.com/code/ic_fp_40px.png
Fig. 2
Ouvrez le navigateur du système de fichiers pour votre système d'exploitation, sélectionnez l'image nouvellement téléchargée et appuyez sur Ctrl-C (Cmd-C sur Mac OS X) pour copier le fichier. Revenez à Android Studio, cliquez avec le bouton droit sur le dossier app -> res -> drawable et sélectionnez l'option de menu Coller pour ajouter une copie du fichier image au projet. Lorsque la boîte de dialogue Copier apparaît, cliquez sur le bouton OK pour utiliser les paramètres par défaut.
VI. Concevoir l'interface utilisateur
Afin de garder l'exemple aussi simple que possible, les seuls éléments de l'interface utilisateur seront un TextView et un ImageView. Recherchez et sélectionnez le fichier de ressources de disposition activity_fingerprint_demo.xml pour le charger dans l'outil Designer. Une fois chargé, supprimez l'exemple d'objet TextView, faites glisser et déposez un objet ImageView à partir du panneau et placez-le au centre du canevas de mise en page.
Dans le panneau Propriétés, recherchez l'attribut src, cliquez dans le champ de texte correspondant suivi du bouton mis en surbrillance dans la Fig. 3 pour afficher la boîte de dialogue Ressources:
Fig. 3
Dans le panneau de gauche de la boîte de dialogue, sélectionnez l'option Dessiner. Dans le panneau principal, entrez ic_fp dans la zone de recherche, comme illustré à la Fig. 4 pour localiser l'icône d'empreinte digitale. Sélectionnez l'icône dans la boîte de dialogue et cliquez sur OK pour l'attribuer à l'objet ImageView.
Fig. 4
Localisez l'objet Grand texte de la palette et faites-le glisser et déposez-le pour qu'il soit positionné sous l'objet ImageView. Double-cliquez sur l'objet et changez le texte pour qu'il affiche "Touch Sensor". Utilisez l'icône ampoule pour extraire la chaîne vers une ressource appelée touch_sensor.
À la fin des étapes ci-dessus, la disposition doit correspondre à celle illustrée à la Fig. 5:
Fig. 5
VII. Accès aux services Keyguard et Fingerprint Manager
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| package com.ebookfrenzy.fingerprintdemo;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.app.KeyguardManager;
import android.hardware.fingerprint.FingerprintManager;
public class FingerprintDemoActivity extends AppCompatActivity {
private FingerprintManager fingerprintManager;
private KeyguardManager keyguardManager;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_fingerprint_demo);
keyguardManager =
(KeyguardManager) getSystemService(KEYGUARD_SERVICE);
fingerprintManager =
(FingerprintManager) getSystemService(FINGERPRINT_SERVICE);
}
} |
VIII. Vérification des paramètres de sécurité
Au début de ce chapitre, des mesures ont été prises pour configurer l'écran de verrouillage et enregistrer les empreintes digitales sur l'appareil ou l'émulateur sur lequel l'application va être testée. Cependant, il est important d'inclure du code défensif dans l'application pour s'assurer que ces exigences ont été satisfaites avant d'essayer de demander l'authentification par empreinte digitale. Ces étapes seront effectuées dans la méthode onCreate résidant dans le fichier FingerprintDemoActivity.java, en utilisant les services du gestionnaire Keyguard et Fingerprint. Notez que le code a également été ajouté pour vérifier que l'autorisation USE_FINGERPRINT a été configurée pour l'application:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
| package com.ebookfrenzy.fingerprintdemo;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.app.KeyguardManager;
import android.hardware.fingerprint.FingerprintManager;
import android.widget.Toast;
import android.Manifest;
import android.content.pm.PackageManager;
import android.support.v4.app.ActivityCompat;
public class FingerprintDemoActivity extends AppCompatActivity {
private FingerprintManager fingerprintManager;
private KeyguardManager keyguardManager;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_fingerprint_demo);
keyguardManager =
(KeyguardManager) getSystemService(KEYGUARD_SERVICE);
fingerprintManager =
(FingerprintManager) getSystemService(FINGERPRINT_SERVICE);
if (!keyguardManager.isKeyguardSecure()) {
Toast.makeText(this,
"Lock screen security not enabled in Settings",
Toast.LENGTH_LONG).show();
return;
}
if (ActivityCompat.checkSelfPermission(this,
Manifest.permission.USE_FINGERPRINT) !=
PackageManager.PERMISSION_GRANTED) {
Toast.makeText(this,
"Fingerprint authentication permission not enabled",
Toast.LENGTH_LONG).show();
return;
}
if (!fingerprintManager.hasEnrolledFingerprints()) {
// This happens when no fingerprints are registered.
Toast.makeText(this,
"Register at least one fingerprint in Settings",
Toast.LENGTH_LONG).show();
return;
}
}
.
.
.
} |
Les modifications de code ci-dessus commencent par utiliser le gestionnaire Keyguard pour vérifier qu'une méthode de déverrouillage de l'écran de sauvegarde a été configurée (en d'autres termes, un code PIN ou une autre méthode d'authentification peut remplacer l'authentification par empreinte digitale). Dans le cas où l'écran de verrouillage n'est pas sécurisé, le code rapporte le problème à l'utilisateur et revient de la méthode.
Le gestionnaire d'empreintes digitales est ensuite utilisé pour vérifier qu'au moins une empreinte digitale a été enregistrée sur l'appareil, signalant à nouveau le problème et revenant de la méthode si nécessaire.
IX. Accès au magasin de clés et au KeyGenerator Android
Une partie du processus d'authentification des empreintes digitales implique la génération d'une clé de chiffrement qui est ensuite stockée en toute sécurité sur l'appareil en utilisant le système Android Keystore. Avant que la clé ne puisse être générée et stockée, l'application doit d'abord avoir accès au magasin de clés. Une nouvelle méthode appelée generateKey va maintenant être implémentée dans le fichier FingerprintDemoActivity.java pour effectuer les tâches de génération et de stockage des clés. Initialement, seul le code permettant d'accéder au fichier de clés sera ajouté comme suit:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| package com.ebookfrenzy.fingerprintdemo;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.app.KeyguardManager;
import android.hardware.fingerprint.FingerprintManager;
import android.widget.Toast;
import android.Manifest;
import android.content.pm.PackageManager;
import android.support.v4.app.ActivityCompat;
import java.security.KeyStore;
public class FingerprintDemoActivity extends AppCompatActivity {
private FingerprintManager fingerprintManager;
private KeyguardManager keyguardManager;
private KeyStore keyStore;
.
.
.
protected void generateKey() {
try {
keyStore = KeyStore.getInstance("AndroidKeyStore");
} catch (Exception e) {
e.printStackTrace();
}
}
} |
Une référence à Keystore est obtenue en appelant la méthode getInstance de la classe Keystore et en passant l'identifiant du conteneur de clés Android standard ("AndroidKeyStore"). La prochaine étape du tutoriel consistera à générer une clé en utilisant le service KeyGenerator. Avant de générer cette clé, le code doit être ajouté pour obtenir une référence à une instance de KeyGenerator, en passant en argument le type de clé à générer et le nom du conteneur Keystore dans lequel la clé doit être sauvegardée:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
| package com.ebookfrenzy.fingerprintdemo;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.app.KeyguardManager;
import android.hardware.fingerprint.FingerprintManager;
import android.widget.Toast;
import android.Manifest;
import android.content.pm.PackageManager;
import android.support.v4.app.ActivityCompat;
import android.security.keystore.KeyProperties;
import java.security.KeyStore;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import javax.crypto.KeyGenerator;
public class FingerprintDemoActivity extends AppCompatActivity {
private FingerprintManager fingerprintManager;
private KeyguardManager keyguardManager;
private KeyStore keyStore;
private KeyGenerator keyGenerator;
protected void generateKey() {
try {
keyStore = KeyStore.getInstance("AndroidKeyStore");
} catch (Exception e) {
e.printStackTrace();
}
try {
keyGenerator = KeyGenerator.getInstance(
KeyProperties.KEY_ALGORITHM_AES,
"AndroidKeyStore");
} catch (NoSuchAlgorithmException |
NoSuchProviderException e) {
throw new RuntimeException(
"Failed to get KeyGenerator instance", e);
}
}
.
.
} |
X. Générer la clé
Maintenant que nous avons une référence au conteneur Android Keystore et à une instance KeyGenerator, l'étape suivante consiste à générer la clé qui sera utilisée pour créer un chiffrement pour le processus de chiffrement. Restant dans le fichier FingerprintDemoActivity.java, ajoutez ce nouveau code comme suit:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
| package com.ebookfrenzy.fingerprintdemo;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.app.KeyguardManager;
import android.hardware.fingerprint.FingerprintManager;
import android.widget.Toast;
import android.Manifest;
import android.content.pm.PackageManager;
import android.support.v4.app.ActivityCompat;
import android.security.keystore.KeyProperties;
import android.security.keystore.KeyGenParameterSpec;
import java.security.KeyStore;
import java.security.InvalidAlgorithmParameterException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.InvalidAlgorithmParameterException;
import java.io.IOException;
import javax.crypto.KeyGenerator;
public class FingerprintDemoActivity extends AppCompatActivity {
private static final String KEY_NAME = "example_key";
private FingerprintManager fingerprintManager;
private KeyguardManager keyguardManager;
private KeyStore keyStore;
private KeyGenerator keyGenerator;
.
.
.
protected void generateKey() {
try {
keyStore = KeyStore.getInstance("AndroidKeyStore");
} catch (Exception e) {
e.printStackTrace();
}
try {
keyGenerator = KeyGenerator.getInstance(
KeyProperties.KEY_ALGORITHM_AES,
"AndroidKeyStore");
} catch (NoSuchAlgorithmException |
NoSuchProviderException e) {
throw new RuntimeException(
"Failed to get KeyGenerator instance", e);
}
try {
keyStore.load(null);
keyGenerator.init(new
KeyGenParameterSpec.Builder(KEY_NAME,
KeyProperties.PURPOSE_ENCRYPT |
KeyProperties.PURPOSE_DECRYPT)
.setBlockModes(KeyProperties.BLOCK_MODE_CBC)
.setUserAuthenticationRequired(true)
.setEncryptionPaddings(
KeyProperties.ENCRYPTION_PADDING_PKCS7)
.build());
keyGenerator.generateKey();
} catch (NoSuchAlgorithmException |
InvalidAlgorithmParameterException
| CertificateException | IOException e) {
throw new RuntimeException(e);
}
}
.
.
} |
Les changements ci-dessus nécessitent quelques explications. Après l'importation d'un certain nombre de modules supplémentaires, le code déclare une variable de chaîne représentant le nom (dans ce cas "example_key") qui sera utilisée lors du stockage de la clé dans le conteneur Keystore.
Ensuite, le conteneur de keystore est chargé et KeyGenerator est initialisé. Ce processus d'initialisation utilise la classe KeyGenParameterSpec.Builder pour spécifier le type de clé en cours de génération. Cela inclut le référencement du nom de la clé, la configuration de la clé de manière à pouvoir l'utiliser à la fois pour le chiffrement et le déchiffrement et la définition de divers paramètres de chiffrement. L'appel à la méthode setUserAuthenticationRequired configure la clé de sorte que l'utilisateur soit obligé d'autoriser chaque utilisation de la clé avec une authentification par empreinte digitale. Une fois le KeyGenerator configuré, il est ensuite utilisé pour générer la clé via un appel à la méthode generateKey de l'instance.
XI. Initialiser le code
Maintenant que la clé a été générée, l'étape suivante consiste à initialiser le chiffrement qui sera utilisé pour créer l'instance FingerprintManager.CryptoObject chiffrée. Ce CryptoObject sera à son tour utilisé pendant le processus d'authentification des empreintes digitales. La configuration de chiffrement implique l'obtention d'une instance de chiffrement et l'initialisation avec la clé stockée dans le conteneur Keystore. Ajoutez une nouvelle méthode nommée cipherInit au fichier FingerprintDemoActivity.java pour effectuer ces tâches:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
| package com.ebookfrenzy.fingerprintdemo;
import android.security.keystore.KeyProperties;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.app.KeyguardManager;
import android.hardware.fingerprint.FingerprintManager;
import android.widget.Toast;
import android.Manifest;
import android.content.pm.PackageManager;
import android.support.v4.app.ActivityCompat;
import android.security.keystore.KeyGenParameterSpec;
import android.security.keystore.KeyPermanentlyInvalidatedException;
import java.security.KeyStore;
import java.security.InvalidAlgorithmParameterException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.InvalidAlgorithmParameterException;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.KeyStoreException;
import java.security.UnrecoverableKeyException;
import javax.crypto.KeyGenerator;
import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.Cipher;
public class FingerprintDemoActivity extends AppCompatActivity {
private static final String KEY_NAME = "example_key";
private FingerprintManager fingerprintManager;
private KeyguardManager keyguardManager;
private KeyStore keyStore;
private KeyGenerator keyGenerator;
private Cipher cipher;
.
.
.
public boolean cipherInit() {
try {
cipher = Cipher.getInstance(
KeyProperties.KEY_ALGORITHM_AES + "/"
+ KeyProperties.BLOCK_MODE_CBC + "/"
+ KeyProperties.ENCRYPTION_PADDING_PKCS7);
} catch (NoSuchAlgorithmException |
NoSuchPaddingException e) {
throw new RuntimeException("Failed to get Cipher", e);
}
try {
keyStore.load(null);
SecretKey key = (SecretKey) keyStore.getKey(KEY_NAME,
null);
cipher.init(Cipher.ENCRYPT_MODE, key);
return true;
} catch (KeyPermanentlyInvalidatedException e) {
return false;
} catch (KeyStoreException | CertificateException
| UnrecoverableKeyException | IOException
| NoSuchAlgorithmException | InvalidKeyException e) {
throw new RuntimeException("Failed to init Cipher", e);
}
}
} |
La méthode getInstance de la classe Cipher est appelée pour obtenir une instance Cipher qui est ensuite configurée avec les propriétés requises pour l'authentification par empreinte digitale. La clé précédemment générée est ensuite extraite du conteneur Keystore et utilisée pour initialiser l'instance Cipher. Les erreurs sont traitées en conséquence et un résultat vrai ou faux est renvoyé en fonction du succès ou de l'échec du processus d'initialisation du chiffrement.
Le travail est maintenant terminé sur les méthodes generateKey et cipherInit. L'étape suivante consiste à modifier la méthode onCreate pour appeler ces méthodes et, dans le cas d'une initialisation de chiffrement réussie, créer une instance CryptoObject.
XII. Création de l'instance CryptoObject
Restant dans le fichier FingerprintDemoActivity.java, modifiez la méthode onCreate pour appeler les deux méthodes nouvellement créées et générer le CryptoObject comme suit:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| public class FingerprintDemoActivity extends AppCompatActivity {
private static final String KEY_NAME = "example_key";
private FingerprintManager fingerprintManager;
private KeyguardManager keyguardManager;
private KeyStore keyStore;
private KeyGenerator keyGenerator;
private Cipher cipher;
private FingerprintManager.CryptoObject cryptoObject;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_fingerprint_demo);
.
.
.
if (!fingerprintManager.hasEnrolledFingerprints()) {
// This happens when no fingerprints are registered.
Toast.makeText(this,
"Register at least one fingerprint in Settings",
Toast.LENGTH_LONG).show();
return;
}
generateKey();
if (cipherInit()) {
cryptoObject =
new FingerprintManager.CryptoObject(cipher);
}
} |
La dernière tâche du projet consiste à implémenter une nouvelle classe pour gérer l'authentification par empreinte digitale.
XIII. Implémentation de la classe du gestionnaire d'authentification par empreintes digitales
Jusqu'à présent, dans ce chapitre, la plus grande partie du travail a consisté à préparer l'authentification par empreinte digitale en termes d'objet clé, chiffre et crypto. L'authentification réelle est déclenchée via un appel à la méthode d'authentification de l'instance FingerprintManager. Cependant, cet appel de méthode déclenchera l'un des nombreux événements de rappel en fonction du succès ou de l'échec de l'authentification. Les méthodes d'authentification de méthode et de gestionnaire de rappel doivent être implémentées dans une classe qui étend la classe FingerprintManager. AuthenticationCallback. Une telle classe doit maintenant être ajoutée au projet.
Accédez à l'entrée app -> java -> com.ebookfrenzy.fingerprintdemo dans la fenêtre de l'outil Projet Android Studio et cliquez dessus avec le bouton droit de la souris. Dans le menu résultant, sélectionnez l'option Nouveau -> Classe Java pour afficher la boîte de dialogue Créer une nouvelle classe. Nommez la classe FingerprintHandler et cliquez sur le bouton OK pour créer la classe.
Modifiez le nouveau fichier de classe afin qu'il étende FingerprintManager. AuthenticationCallback, importe des modules supplémentaires et implémente une méthode constructrice qui permettra au contexte de l'application d'être transmis lors de la création d'une instance de la classe (le contexte sera utilisé dans les méthodes de rappel pour informer l'utilisateur du statut d'authentification):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package com.ebookfrenzy.fingerprintdemo;
import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.hardware.fingerprint.FingerprintManager;
import android.os.CancellationSignal;
import android.support.v4.app.ActivityCompat;
import android.widget.Toast;
public class FingerprintHandler extends
FingerprintManager.AuthenticationCallback {
private CancellationSignal cancellationSignal;
private Context appContext;
public FingerprintHandler(Context context) {
appContext = context;
}
} |
Ensuite, il faut ajouter une méthode qui peut être appelée pour lancer l'authentification par empreinte digitale. Une fois appelée, cette méthode devra passer les instances FingerprintManager et CryptoObject. Nommez cette méthode startAuth et implémentez-la dans le fichier de classe FingerprintHandler.java comme suit (notez que le code a également été ajouté pour vérifier à nouveau que l'autorisation d'empreinte digitale a été accordée):
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public void startAuth(FingerprintManager manager,
FingerprintManager.CryptoObject cryptoObject) {
cancellationSignal = new CancellationSignal();
if (ActivityCompat.checkSelfPermission(appContext,
Manifest.permission.USE_FINGERPRINT) !=
PackageManager.PERMISSION_GRANTED) {
return;
}
manager.authenticate(cryptoObject, cancellationSignal, 0, this, null);
} |
Ensuite, ajoutez les méthodes du gestionnaire de rappel, chacune étant implémentée pour afficher un message toast indiquant le résultat de l'authentification par empreinte digitale:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
@Override
public void onAuthenticationError(int errMsgId,
CharSequence errString) {
Toast.makeText(appContext,
"Authentication error\n" + errString,
Toast.LENGTH_LONG).show();
}
@Override
public void onAuthenticationHelp(int helpMsgId,
CharSequence helpString) {
Toast.makeText(appContext,
"Authentication help\n" + helpString,
Toast.LENGTH_LONG).show();
}
@Override
public void onAuthenticationFailed() {
Toast.makeText(appContext,
"Authentication failed.",
Toast.LENGTH_LONG).show();
}
@Override
public void onAuthenticationSucceeded(
FingerprintManager.AuthenticationResult result) {
Toast.makeText(appContext,
"Authentication succeeded.",
Toast.LENGTH_LONG).show();
} |
La tâche finale avant de tester le projet consiste à modifier la méthode onCreate afin qu'elle crée une nouvelle instance de la classe FingerprintHandler et appelle la méthode startAuth. Editez le fichier FingerprintDemoActivity.java et modifiez la fin de la méthode onCreate afin qu'elle se lit comme suit:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_fingerprint);
.
.
.
if (initCipher()) {
cryptoObject = new FingerprintManager.CryptoObject(cipher);
FingerprintHandler helper = new FingerprintHandler(this);
helper.fingerprintHandler(fingerprintManager, cryptoObject);
}
} |
XIV. Tester le projet
Une fois le projet terminé, lancez l'application sur un appareil Android physique ou une session d'émulation. Une fois lancé, touchez le capteur d'empreintes digitales ou utilisez le panneau de contrôle étendu de l'émulateur pour simuler une empreinte digitale, comme indiqué dans le chapitre intitulé Utilisation et configuration de l'émulateur AVD d'Android Studio 2. En supposant qu'une empreinte digitale enregistrée est détectée, un message toast apparaîtra indiquant une authentification réussie, comme illustré à la Fig. 6:
Fig. 6
Arrêtez l'application en cours d'exécution et relancez-la, cette fois en utilisant une empreinte digitale non enregistrée pour tenter l'authentification. Cette fois, un message toast devrait apparaître indiquant que l'authentification a échoué.
XV. Résumé
L'authentification par empreintes digitales au sein d'Android est un processus en plusieurs étapes qui peut sembler complexe à première vue. Cependant, une fois décomposé en étapes individuelles, le processus devient plus clair. L'authentification par empreintes digitales implique l'utilisation de clés, de chiffrements et de stockage de clés combinés aux fonctionnalités de la classe FingerprintManager. Ce chapitre a fourni une introduction à ces étapes et travaillé à travers la création d'un exemple de projet d'application destiné à montrer la mise en œuvre pratique de l'authentification par empreintes digitales au sein d'Android.
Authentification par empreintes digitales dans un programme android
Répondre avec citation
Partager