阅读 2976

安卓指纹对称加密及登录功能的实现

一、概述

Android下的指纹识别是在Android6.0后添加的功能,因此,在实现的时候要判断用户机是否支持,然后对于开发来说,使用场景有两种,分别是本地识别和跟服务器交互;

  1. 本地识别:在本地完成指纹的识别后,跟本地信息绑定登陆;
  2. 后台交互:在本地完成识别后,将数据传输到服务器;

无论是本地还是与服务器交互,都需要对信息进行加密,通常来说,与本地交互的采用对称加密,与服务器交互则采用非对称加密,下面我们来简单介绍下对称加密和非对称加密

二、对称与非对称加密

1.对称加密

采用单密钥密码系统的方法,同一密钥作为加密和解密的工具,通过密钥控制加密和解密饿的指令,算法规定如何加密和解密。优点是算法公开、加密解密速度快、效率高,缺点是发送前的双方保持统一密钥,如果泄露则不安全,通常由AES、DES加密算法等;

2.非对称加密

非对称加密算法需要两个密钥来进行加密和解密,这两个秘钥是公开密钥(简称公钥)和私有密钥(简称私钥),如果一方用公钥进行加密,接受方应用私钥进行解密,反之发送方用私钥进行加密,接收方用公钥进行解密,由于加密和解密使用的不是同一密钥,故称为非对称加密算法;与对称加密算法相比,非对称加密的安全性得到了很大的提升,但是效率上则低了很多,因为解密加密花费的时间更长了,所以适合数据量少的加密,通常有RSA,ECC加密算法等等

三、指纹识别的对称加密

首先我们判断手机是否支持指纹识别,是否有相关的传感器,是否录入了相关指纹,然后才开始对指纹做出系列的操作;

fingerprintManager = FingerprintManagerCompat.from(this);
if (!fingerprintManager.isHardwareDetected()) {
	//是否支持指纹识别
	AlertDialog.Builder builder = new AlertDialog.Builder(this);
	builder.setMessage("没有传感器");
	builder.setCancelable(false);
	builder.create().show();
} else if (!fingerprintManager.hasEnrolledFingerprints()) {
	//是否已注册指纹
	AlertDialog.Builder builder = new AlertDialog.Builder(this);
	builder.setMessage("没有注册指纹");
	builder.setCancelable(false);
	builder.create().show();
} else {
	try {
		//这里去新建一个结果的回调,里面回调显示指纹验证的信息
		myAuthCallback = new MyAuthCallback(handler);
	} catch (Exception e) {
		e.printStackTrace();
	}
}
复制代码

这里初始化handle对应指纹识别完成后发送过来的消息

private void initHandler() {
	handler = new Handler() {
		@Override
		public void handleMessage(Message msg) {
			super.handleMessage(msg);
			switch (msg.what) {
				//识别成功
				case MSG_AUTH_SUCCESS:
					setResultInfo(R.string.fingerprint_success);
					mCancelBtn.setEnabled(false);
					mStartBtn.setEnabled(true);
					cancellationSignal = null;
				break;
				//识别失败
				case MSG_AUTH_FAILED:
				setResultInfo(R.string.fingerprint_not_recognized);
					mCancelBtn.setEnabled(false);
					mStartBtn.setEnabled(true);
					cancellationSignal = null;
				break;
				//识别错误
				case MSG_AUTH_ERROR:
					handleErrorCode(msg.arg1);
				break;
				//帮助
				case MSG_AUTH_HELP:
					handleHelpCode(msg.arg1);
				break;
			}
		}
	};
}
复制代码

对称加密的主要实现步骤如下:

  1. 新建一个KeyStore密钥库,用于存放密钥;
  2. 获取KeyGenerator密钥生成工具,生成密钥;
  3. 通过密钥初始化Cipher对象,生成加密对象CryptoObject;
  4. 调用authenticate() 方法启动指纹传感器并开始监听。

1.新建一个KeyStore密钥库存放密钥:

/**
 * 创建keystore
 * @throws Exception
 */
public CryptoObjectHelper() throws Exception {
	KeyStore _keystore = KeyStore.getInstance(KEYSTORE_NAME);
    _keystore.load(null);
}
复制代码

2.获取KeyGenerator密钥生成工具,生成密钥:

    /**
     * 获取秘钥生成器,用于生成秘钥
     * @throws Exception
     */
  public void CreateKey() throws Exception {
     KeyGenerator keyGen = KeyGenerator.getInstance(KEY_ALGORITHM, KEYSTORE_NAME);
     KeyGenParameterSpec keyGenSpec =
             new KeyGenParameterSpec.Builder(KEY_NAME, KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
            .setBlockModes(BLOCK_MODE)
            .setEncryptionPaddings(ENCRYPTION_PADDING)
            .setUserAuthenticationRequired(true)
            .build();
        keyGen.init(keyGenSpec);
        keyGen.generateKey();
    }
复制代码

3.通过密钥初始化Cipher对象,生成加密对象CryptoObject:

  /**
     * @throws Exception
     * 密码生成,递归实现
     */
    Cipher createCipher(boolean retry) throws Exception {
        Key key = GetKey();
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        try {
            cipher.init(Cipher.ENCRYPT_MODE | Cipher.DECRYPT_MODE, key);
        } catch (KeyPermanentlyInvalidatedException e) {
            _keystore.deleteEntry(KEY_NAME);//删除获取的码,保留生成的密码
            if (retry) {
                createCipher(false);
            } else {
                throw new Exception("Could not create the cipher", e);
            }
        }
        return cipher;
    }
复制代码

4.调用authenticate() 方法启动指纹传感器并开始监听:

CryptoObjectHelper cryptoObjectHelper = new CryptoObjectHelper();
    if (cancellationSignal == null) {
         cancellationSignal = new CancellationSignal();
     }
fingerprintManager.authenticate(cryptoObjectHelper.buildCryptoObject(), 0,
                            cancellationSignal, myAuthCallback, null);
复制代码

最后我们在回调的类中监听指纹识别的结果:

public class MyAuthCallback extends FingerprintManagerCompat.AuthenticationCallback {

    private Handler handler = null;

    public MyAuthCallback(Handler handler) {
        super();
        this.handler = handler;
    }

    /**
     * 验证错误信息
     */
    @Override
    public void onAuthenticationError(int errMsgId, CharSequence errString) {
        super.onAuthenticationError(errMsgId, errString);
        if (handler != null) {
            handler.obtainMessage(Constant.MSG_AUTH_ERROR, errMsgId, 0).sendToTarget();
        }
    }

    /**
     * 身份验证帮助
     */
    @Override
    public void onAuthenticationHelp(int helpMsgId, CharSequence helpString) {
        super.onAuthenticationHelp(helpMsgId, helpString);
        if (handler != null) {
            handler.obtainMessage(Constant.MSG_AUTH_HELP, helpMsgId, 0).sendToTarget();
        }
    }

    /**
     * 验证成功
     */
    @Override
    public void onAuthenticationSucceeded(FingerprintManagerCompat.AuthenticationResult result) {
        super.onAuthenticationSucceeded(result);
        if (handler != null) {
            handler.obtainMessage(Constant.MSG_AUTH_SUCCESS).sendToTarget();
        }
    }

    /**
     * 验证失败
     */
    @Override
    public void onAuthenticationFailed() {
        super.onAuthenticationFailed();
        if (handler != null) {
            handler.obtainMessage(Constant.MSG_AUTH_FAILED).sendToTarget();
        }
    }
}
复制代码

好了,上面一直讲的是对称加密以实现指纹识别;

接下来写了一个使用指纹进行登录的demo及封装(这里没有使用加密..):

我们先来看下我总结的指纹登录流程

这里写图片描述

指纹识别一定会有成功、失败等各种情况,所以先定义一个回调监听

/**
 * Description: 指纹识别回调
 * Created by jia on 2017/11/27.
 * 人之所以能,是相信能
 */
public interface FingerListener {

    /**
     * 开始识别
     */
    void onStartListening();

    /**
     * 停止识别
     */
    void onStopListening();

    /**
     * 识别成功
     * @param result
     */
    void onSuccess(FingerprintManager.AuthenticationResult result);

    /**
     * 识别失败
     */
    void onFail(boolean isNormal,String info);

    /**
     * 多次识别失败 的 回调方法
     * @param errorCode
     * @param errString
     */
    void onAuthenticationError(int errorCode, CharSequence errString);

    /**
     * 识别提示
     */
    void onAuthenticationHelp(int helpCode, CharSequence helpString);

}
复制代码

1、先封装了指纹工具类

    private FingerprintManager manager;
    private KeyguardManager mKeyManager;
    private CancellationSignal mCancellationSignal;
    //回调方法
    private FingerprintManager.AuthenticationCallback mSelfCancelled;

    private Context mContext;

    private FingerListener listener;
复制代码

指纹识别相关管理类当然是必须的了。

2、初始化它们

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
	manager = (FingerprintManager) mContext.getSystemService(Context.FINGERPRINT_SERVICE);
	mKeyManager = (KeyguardManager) mContext.getSystemService(Context.KEYGUARD_SERVICE);
	mCancellationSignal = new CancellationSignal();
	initSelfCancelled();
}
复制代码

3、初始化系统的识别回调

    private void initSelfCancelled() {
        mSelfCancelled = new FingerprintManager.AuthenticationCallback() {
            @Override
            public void onAuthenticationError(int errorCode, CharSequence errString) {
                // 多次指纹密码验证错误后,进入此方法;并且,不能短时间内调用指纹验证
                listener.onAuthenticationError(errorCode, errString);
            }

            @Override
            public void onAuthenticationHelp(int helpCode, CharSequence helpString) {
                listener.onAuthenticationHelp(helpCode, helpString);
            }

            @Override
            public void onAuthenticationSucceeded(FingerprintManager.AuthenticationResult result) {
                listener.onSuccess(result);
            }

            @Override
            public void onAuthenticationFailed() {
                listener.onFail(true, "识别失败");
            }
        };
    }
复制代码

4、开始识别

    /**
     * 开始监听识别
     */
    public void startListening(FingerListener listener) {

        this.listener = listener;

        if (ActivityCompat.checkSelfPermission(mContext, Manifest.permission.USE_FINGERPRINT) != PackageManager.PERMISSION_GRANTED) {
            listener.onFail(false, "未开启权限");
            return;
        }

        if (isFinger() == null) {
            listener.onStartListening();
            manager.authenticate(null, mCancellationSignal, 0, mSelfCancelled, null);
        } else {
            listener.onFail(false, isFinger());
        }
    }
复制代码

注意:ActivityCompat.checkSelfPermission必须在开始识别前执行,否则编译环境会报错...

5、取消识别

    /**
     * 停止识别
     */
    public void cancelListening() {
        if (mCancellationSignal != null) {
            mCancellationSignal.cancel();
            listener.onStopListening();
        }
    }
复制代码

同时也少不了各种情况的判断

    /**
     * 硬件是否支持
     * <p/>
     * 返回null则可以进行指纹识别
     * 否则返回对应的原因
     *
     * @return
     */
    public String isFinger() {

        //android studio 上,没有这个会报错
        if (ActivityCompat.checkSelfPermission(mContext, Manifest.permission.USE_FINGERPRINT) != PackageManager.PERMISSION_GRANTED) {

            //android studio 上,没有这个会报错
            if (ActivityCompat.checkSelfPermission(mContext, Manifest.permission.USE_FINGERPRINT) != PackageManager.PERMISSION_GRANTED) {
                return "没有指纹识别权限";
            }
            //判断硬件是否支持指纹识别
            if (!manager.isHardwareDetected()) {
                return "没有指纹识别模块";
            }
            //判断 是否开启锁屏密码
            if (!mKeyManager.isKeyguardSecure()) {
                return "没有开启锁屏密码";
            }
            //判断是否有指纹录入

            if (!manager.hasEnrolledFingerprints()) {
                return "没有录入指纹";
            }
        }

        return null;
    }
复制代码
    /**
     * 检查SDK版本
     *
     * @return
     */
    public boolean checkSDKVersion() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            return true;
        }
        return false;
    }
复制代码

看下效果图

开启指纹登录

这里写图片描述

登录识别

这里写图片描述

好了,指纹识别大概是这样了。

更多精彩内容,可以关注我的微信公众号——Android机动车

评论