指纹识别-Android

@(Android进阶资料)[Android, 学习, 读书笔记, Markdown] 指纹识别是在Android6.0之后新增的功能,所以在使用的时候首先要判断用户的系统版本是否支持指纹识别。另外,实际开发场景中,使用指纹的主要场景有两种：

纯本地使用。即用户在本地完成指纹识别后,不需要将指纹信息传递给后台。
与后台交互。用户在本地完成指纹识别后,需要将指纹信息传递给后台。

由于使用指纹识别功能需要一个加密对象（CryptoObject）,该对象一般是由对称加密或者非对称加密获得。上述两种应用场景的实现大同小异,主要区别在于加密过程中密钥的创建和使用,一般来说,纯本地的指纹识别功能,只需要对称加密即可；而与后台则需要使用非对称加密：将私钥用于本地指纹识别,识别成功后将加密信息传给后台,后台用公钥解密,以获得用户信息。

[TOC]

对称加密、非对称加密和签名

在正式使用指纹识别功能之前，有必要先了解一下对称加密和非对称加密的相关内容。

对称加密：所谓对称，就是采用这种加密方法的双方使用方式用同样的密钥进行加密和解密。密钥是控制加密及解密过程的指令。算法是一组规则，规定如何进行加密和解密。因此加密的安全性不仅取决于加密算法本身，密钥管理的安全性更是重要。因为加密和解密都使用同一个密钥，如何把密钥安全地传递到解密者手上就成了必须要解决的问题。
非对称加密：非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。非对称加密算法实现机密信息交换的基本过程是：甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开；得到该公用密钥的乙方使用该密钥对机密信息进行加密后再发送给甲方；甲方再用自己保存的另一把专用密钥对加密后的信息进行解密。
签名：在信息的后面再加上一段内容，可以证明信息没有被修改过。一般是对信息做一个hash计算得到一个hash值，注意，这个过程是不可逆的，也就是说无法通过hash值得出原来的信息内容。在把信息发送出去时，把这个hash值加密后做为一个签名和信息一起发出去。

由以上内容可以了解到，对称加密和非对称加密的特点如下：

对称加密的优点是速度快，适合于本地数据和本地数据库的加密，安全性不如非对称加密。常见的对称加密算法有DES、3DES、AES、Blowfish、IDEA、RC5、RC6。
非对称加密的安全性比较高，适合对需要网络传输的数据进行加密，速度不如对称加密。非对称加密应用于SSH, HTTPS, TLS，电子证书，电子签名，电子身份证等等
指纹识别的对称加密实现

使用指纹识别的对称加密功能的主要流程如下：
1. 使用 KeyGenerator 创建一个对称密钥，存放在 KeyStore 里。
2. 设置 KeyGenParameterSpec.Builder.setUserAuthenticationRequired() 为true
3. 使用创建好的对称密钥初始化一个Cipher对象，并用该对象调用 FingerprintManager.authenticate() 方法启动指纹传感器并开始监听。
4. 重写 FingerprintManager.AuthenticationCallback 的几个回调方法，以处理指纹识别成功（onAuthenticationSucceeded()）、失败（onAuthenticationFailed() 和 onAuthenticationError()）等情况。

创建密钥

创建密钥要涉及到两个类：KeyStore 和 KeyGenerator。 KeyStore 是用于存储、获取密钥（Key）的容器，获取 KeyStore的方法如下：

try {
    mKeyStore = KeyStore.getInstance("AndroidKeyStore");
} catch (KeyStoreException e) {
    throw new RuntimeException("Failed to get an instance of KeyStore", e);
}

而生成 Key，如果是对称加密，就需要 KeyGenerator 类。获取一个 KeyGenerator 对象比较简单，方法如下：

// 对称加密， 创建 KeyGenerator 对象
try {
    mKeyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES,"AndroidKeyStore");
} catch (NoSuchAlgorithmException | NoSuchProviderException e) {
    throw new RuntimeException("Failed to get an instance of KeyGenerator", e);
}

获得 KeyGenerator 对象后，就可以生成一个 Key 了:

try {
    keyStore.load(null);
    KeyGenParameterSpec.Builder builder = new KeyGenParameterSpec.Builder(defaultKeyName,
            KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
            .setBlockModes(KeyProperties.BLOCK_MODE_CBC)
            .setUserAuthenticationRequired(true)
            .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_PKCS7);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        builder.setInvalidatedByBiometricEnrollment(true);
    }
    keyGenerator.init(builder.build());
    keyGenerator.generateKey();
} catch (CertificateException | NoSuchAlgorithmException | IOException | InvalidAlgorithmParameterException e) {
    e.printStackTrace();
}

创建并初始化 Cipher 对象

Cipher 对象是一个按照一定的加密规则，将数据进行加密后的一个对象。调用指纹识别功能需要使用到这个对象。创建 Cipher 对象很简单，如同下面代码那样：

Cipher defaultCipher;
try {
    defaultCipher = Cipher.getInstance(KeyProperties.KEY_ALGORITHM_AES + "/"
            + KeyProperties.BLOCK_MODE_CBC + "/" + KeyProperties.ENCRYPTION_PADDING_PKCS7);
} catch (NoSuchAlgorithmException | NoSuchPaddingException e) {
    throw new RuntimeException("创建Cipher对象失败", e);
}

然后使用刚才创建好的密钥，初始化 Cipher 对象:

try {
    keyStore.load(null);
    SecretKey key = (SecretKey) keyStore.getKey(keyName, null);
    cipher.init(Cipher.ENCRYPT_MODE, key);
    return true;
} catch (IOException | NoSuchAlgorithmException | CertificateException | UnrecoverableKeyException | KeyStoreException | InvalidKeyException e) {
    throw new RuntimeException("初始化 cipher 失败", e);
}

使用指纹识别功能

真正到了使用指纹识别功能的时候，你会发现其实很简单，只是调用 FingerprintManager 类的的方法authenticate()而已，然后系统会有相应的回调反馈给我们，该方法如下：

public void authenticate(CryptoObject crypto, CancellationSignal cancel, int flags, AuthenticationCallback callback, Handler handler)

该方法的几个参数解释如下：

第一个参数是一个加密对象。还记得之前我们大费周章地创建和初始化的Cipher对象吗？这里的 CryptoObject 对象就是使用 Cipher 对象创建创建出来的：new FingerprintManager.CryptoObject(cipher)。
第二个参数是一个 CancellationSignal 对象，该对象提供了取消操作的能力。创建该对象也很简单，使用 new CancellationSignal() 就可以了。
第三个参数是一个标志，默认为0。
第四个参数是 AuthenticationCallback 对象，它本身是 FingerprintManager 类里面的一个抽象类。该类提供了指纹识别的几个回调方法，包括指纹识别成功、失败等。需要我们重写。
最后一个 Handler，可以用于处理回调事件，可以传null。

完成指纹识别后，还要记得将 AuthenticationCallback 关闭掉：

public void stopListening() {
    if (cancellationSignal != null) {
        selfCancelled = true;
        cancellationSignal.cancel();
        cancellationSignal = null;
    }
}

重写回调方法

调用了 authenticate() 方法后，系统就会启动指纹传感器，并开始扫描。这时候根据扫描结果，会通过FingerprintManager.AuthenticationCallback类返回几个回调方法:

// 成功
onAuthenticationSucceeded()
// 失败
onAuthenticationFaile()
// 错误
onAuthenticationError()

一般我们需要重写这几个方法，以实现我们的功能。关于onAuthenticationFaile()和onAuthenticationError()的区别，后面会讲到。

实际应用中的注意事项

判断用户是否可以使用指纹识别功能

一般来说，为了增加安全性，要求用户在手机的“设置”中开启了密码锁屏功能。当然，使用指纹解锁的前提是至少录入了一个指纹。 // 如果没有设置密码锁屏，则不能使用指纹识别

if (!keyguardManager.isKeyguardSecure()) {
    Toast.makeText(this, "请在设置界面开启密码锁屏功能",
            Toast.LENGTH_LONG).show();
}
// 如果没有录入指纹，则不能使用指纹识别
if (!fingerprintManager.hasEnrolledFingerprints()) {
    Toast.makeText(this, "您还没有录入指纹, 请在设置界面录入至少一个指纹",
            Toast.LENGTH_LONG).show();
}

这里用到了两个类：KeyguardManager 和 FingerprintManager，前者是屏幕保护的相关类。后者是指纹识别的核心类。

关于指纹识别回调方法

前面说到AuthenticationCallback类里面的几个回调方法，其中有三个是我们开发中需要用到的：

onAuthenticationError()
onAuthenticationSucceeded()
onAuthenticationFailed()

关于这三个回调方法，有几点需要注意的：

当指纹识别失败后，会调用onAuthenticationFailed()方法，这时候指纹传感器并没有关闭，系统给我们提供了5次重试机会，也就是说，连续调用了5次onAuthenticationFailed()方法后，会调用onAuthenticationError()方法。
当系统调用了onAuthenticationError()和onAuthenticationSucceeded()后，传感器会关闭，只有我们重新授权，再次调用authenticate()方法后才能继续使用指纹识别功能。
当系统回调了onAuthenticationError()方法关闭传感器后，这种情况下再次调用authenticate()会有一段时间的禁用期，也就是说这段时间里是无法再次使用指纹识别的。当然，具体的禁用时间由手机厂商的系统不同而有略微差别，有的是1分钟，有的是30秒等等。而且，由于手机厂商的系统区别，有些系统上调用了onAuthenticationError()后，在禁用时间内，其他APP里面的指纹识别功能也无法使用，甚至系统的指纹解锁功能也无法使用。而有的系统上，在禁用时间内调用其他APP的指纹解锁功能，或者系统的指纹解锁功能，就能立即重置指纹识别功能。

示例代码

最后， Android Sample 里面关于指纹的示例代码地址如下:

完整代码

package com.zichenjiao.testapp;

import android.Manifest;
import android.annotation.TargetApi;
import android.app.KeyguardManager;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.hardware.fingerprint.FingerprintManager;
import android.os.Build;
import android.os.Bundle;
import android.os.CancellationSignal;
import android.support.v4.app.ActivityCompat;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

@TargetApi(Build.VERSION_CODES.M)
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private final static int REQUEST_CODE_CONFIRM_DEVICE_CREDENTIALS = 0;
    Button testfingerprint;
    CancellationSignal mCancellationSignal = new CancellationSignal();
    FingerprintManager manager;
    KeyguardManager mKeyManager;
    //回调方法
    FingerprintManager.AuthenticationCallback mSelfCancelled = new FingerprintManager.AuthenticationCallback() {
        @Override
        public void onAuthenticationError(int errorCode, CharSequence errString) {
            //但多次指纹密码验证错误后，进入此方法；并且，不能短时间内调用指纹验证
            Toast.makeText(MainActivity.this, errString, Toast.LENGTH_SHORT).show();
            showAuthenticationScreen();
        }

        @Override
        public void onAuthenticationHelp(int helpCode, CharSequence helpString) {

            Toast.makeText(MainActivity.this, helpString, Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onAuthenticationSucceeded(FingerprintManager.AuthenticationResult result) {

            Toast.makeText(MainActivity.this, "指纹识别成功", Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onAuthenticationFailed() {
            Toast.makeText(MainActivity.this, "指纹识别失败", Toast.LENGTH_SHORT).show();
        }
    };
    private String TAG = "TAG";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        testfingerprint = (Button) findViewById(R.id.testfingerprint);
        testfingerprint.setOnClickListener(this);
        //初始化指纹识别管理器
        manager = (FingerprintManager) this.getSystemService(Context.FINGERPRINT_SERVICE);
        mKeyManager = (KeyguardManager) this.getSystemService(Context.KEYGUARD_SERVICE);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.testfingerprint://测试指纹识别
                if (isFinger()) {
                    Toast.makeText(MainActivity.this, "请进行指纹识别", Toast.LENGTH_LONG).show();
                    Log(TAG, "keyi");
                    startListening(null);
                }
                break;
        }
    }

    public boolean isFinger() {

        //android studio 上，没有这个会报错
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.USE_FINGERPRINT) != PackageManager.PERMISSION_GRANTED) {
            Toast.makeText(this, "没有指纹识别权限", Toast.LENGTH_SHORT).show();
            return false;
        }
        Log(TAG, "有指纹权限");
        //判断硬件是否支持指纹识别
        if (!manager.isHardwareDetected()) {
            Toast.makeText(this, "没有指纹识别模块", Toast.LENGTH_SHORT).show();
            return false;
        }
        Log(TAG, "有指纹模块");
        //判断 是否开启锁屏密码

        if (!mKeyManager.isKeyguardSecure()) {
            Toast.makeText(this, "没有开启锁屏密码", Toast.LENGTH_SHORT).show();
            return false;
        }
        Log(TAG, "已开启锁屏密码");
        //判断是否有指纹录入
        if (!manager.hasEnrolledFingerprints()) {
            Toast.makeText(this, "没有录入指纹", Toast.LENGTH_SHORT).show();
            return false;
        }
        Log(TAG, "已录入指纹");

        return true;
    }

    public void startListening(FingerprintManager.CryptoObject cryptoObject) {
        //android studio 上，没有这个会报错
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.USE_FINGERPRINT) != PackageManager.PERMISSION_GRANTED) {
            Toast.makeText(this, "没有指纹识别权限", Toast.LENGTH_SHORT).show();
            return;
        }
        manager.authenticate(cryptoObject, mCancellationSignal, 0, mSelfCancelled, null);
    }

    /**
     * 锁屏密码
     */
    private void showAuthenticationScreen() {

        Intent intent = mKeyManager.createConfirmDeviceCredentialIntent("finger", "测试指纹识别");
        if (intent != null) {
            startActivityForResult(intent, REQUEST_CODE_CONFIRM_DEVICE_CREDENTIALS);
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (requestCode == REQUEST_CODE_CONFIRM_DEVICE_CREDENTIALS) {
            // Challenge completed, proceed with using cipher
            if (resultCode == RESULT_OK) {
                Toast.makeText(this, "识别成功", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(this, "识别失败", Toast.LENGTH_SHORT).show();
            }
        }
    }

    private void Log(String tag, String msg) {
        Log.d(tag, msg);
    }

}