Authentification en utilisant l'API Fingerprint

Google a présenté un exemple d'utilisation de l'authentification serveur avec un lecteur d'empreinte digitale. Présentation de l'exemple, mais aussi des clés symétriques et asymétriques.

Authentification via les empreintes digitales

L'API Fingerprint protège la vie privée de l'utilisateur en gardant les caractéristiques des empreintes digitales des utilisateurs contenus attentivement dans un hardware sécurisé sur l'appareil. Cet API protège contre les acteurs malveillants, en s'assurant que l'utilisateur peut utiliser de manière sécuriser ses empreintes digitales, même dans une application non fiables (pas dans le Play Store).

Android fournit aussi une protection pour les développeurs d'application, en fournissant l'assurance que l'empreinte digital de l'utilisateur a été identifié de manière positive avant de fournir l'accès à des ressources et des données sécuriser. Cela protège contre les applications trafiquées, en fournissant une sécurité au niveau du chiffrement pour les données hors ligne et les interactions en ligne.

Quand l'utilisateur active le lecteur d'empreinte digital, ils déverrouillent un coffre fort chiffré de manière hardware. En tant que développeur, il est possible de choisir quel type de clé materiel est stocké dans le coffre fort, selon les besoins de l'application :

• Clé symétrique : similaire à un mot de passe, il permet le chiffrement des données local. C'est un bon choix pour sécuriser l'accès aux bases de données ou aux fichiers offline.
• Clé asymétrique : Fournit une paire de clé, avec une clé publique et une privée. La clé publique peut être envoyé de manière sécuriser par Internet et stocké sur un serveur distant. La clé privée peut être utilisé par la suite pour signer les données, comme ça la signature peut être vérifiée à l'aide de la clé publique. Les données signées ne peuvent pas être manipulé avec, et identifie positivement l'auteur original de ces données. De cette manière, les clés asymétriques peuvent être utilisées pour la connexion réseau et les transactions en ligne d'authentification. De même , la clé publique peut être utilisé pour encrypter les données, de sorte que les données ne peuvent être déchiffrées seulement avec la clé privée.

Principe de la clé asymétrique

Mise en place de la connexion via une paire de clé asymétrique

Il faut tout d'abord créer une paire de clé asymétrique :

KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore"); keyPairGenerator.initialize( new KeyGenParameterSpec.Builder(KEY_NAME, KeyProperties.PURPOSE_SIGN) .setDigests(KeyProperties.DIGEST_SHA256) .setAlgorithmParameterSpec(new ECGenParameterSpec("secp256r1")) .setUserAuthenticationRequired(true) .build()); keyPairGenerator.generateKeyPair();

Pour récupérer les clés publiques et privées :

KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore"); keyStore.load(null); PublicKey publicKey = keyStore.getCertificate(MainActivity.KEY_NAME).getPublicKey(); KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore"); keyStore.load(null); PrivateKey key = (PrivateKey) keyStore.getKey(KEY_NAME, null);

Ensuite, il faut transmettre la clé publique au serveur pour que par la suite le serveur puisse vérifier que les transactions sont autorisées par l'utilisateur. Exemple d'appel :

boolean enroll(String userId, String password, PublicKey publicKey);

Appeler le détecteur d'empreinte et demander à l'utilisateur d'agir :

Signature.getInstance("SHA256withECDSA"); KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore"); keyStore.load(null); PrivateKey key = (PrivateKey) keyStore.getKey(KEY_NAME, null); signature.initSign(key); CryptoObject cryptObject = new FingerprintManager.CryptoObject(signature); CancellationSignal cancellationSignal = new CancellationSignal(); FingerprintManager fingerprintManager = context.getSystemService(FingerprintManager.class); fingerprintManager.authenticate(cryptoObject, cancellationSignal, 0, this, null);

Envoie des données au serveur et vérification :

Signature signature = cryptoObject.getSignature(); // Include a client nonce in the transaction so that the nonce is also signed // by the private key and the backend can verify that the same nonce can't be used // to prevent replay attacks. Transaction transaction = new Transaction("user", 1, new SecureRandom().nextLong()); try { signature.update(transaction.toByteArray()); byte[] sigBytes = signature.sign(); // Send the transaction and signedTransaction to the dummy backend if (mStoreBackend.verify(transaction, sigBytes)) { mActivity.onPurchased(sigBytes); dismiss(); } else { mActivity.onPurchaseFailed(); dismiss(); } } catch (SignatureException e) { throw new RuntimeException(e); }

@Override public boolean verify(Transaction transaction, byte[] transactionSignature) { try { if (mReceivedTransactions.contains(transaction)) { // It verifies the equality of the transaction including the client nonce // So attackers can't do replay attacks. return false; } mReceivedTransactions.add(transaction); PublicKey publicKey = mPublicKeys.get(transaction.getUserId()); Signature verificationFunction = Signature.getInstance("SHA256withECDSA"); verificationFunction.initVerify(publicKey); verificationFunction.update(transaction.toByteArray()); if (verificationFunction.verify(transactionSignature)) { // Transaction is verified with the public key associated with the user // Do some post purchase processing in the server return true; } } catch (NoSuchAlgorithmException | InvalidKeyException | SignatureException e) { // In a real world, better to send some error message to the user } return false; }

En savoir plus

Science étonnante propose sur Youtube une vidéo expliquant les différentes techniques de chiffrement dont les deux proposés ci-dessus.