Android数据加密传输

客户端在和平台端进行数据的通讯时，有时需要对传输的数据进行加密，下面介绍一些在开发中常用的加解密方法。

一、对称加密

1、对称加密（又称为私人秘钥加密/共享秘钥加密）：加密与解密使用同一秘钥,也称为单密钥加密。
2、加密强度不高，但效率高，加密解密的速度比较快，适合数据比较长时的使用。
3、密钥分发困难，密钥传输的过程不安全，且容易被破解，密钥管理也比较麻烦
4、常见对称密钥加密算法
（1）、DES：替换+移位、56位密钥、64位数据块、速度快、密钥易产生
（2）、3DES(三重DES)：两个56位的密钥K1、K2
加密：K1加密、 K2解密 、K1加密
解密：K1解密、 K2加密、 K1解密

二、非对称加密

1、 非对称加密（又称为公开密钥加密）：密钥必须成对使用（公钥加密，相应的私钥解密）。发送方使用接收方的公钥进行加密，接收方接收到密文后用自己的私钥进行解密。
2、 加密速度慢，但强度高。
3、常见非对称密钥加密算法 RSA：512位（或1024位）密钥、计算量极大、难破解

三、对称加密的一般实现方案

1、在传输数据时，发送方先进行key和相关属性的MD5计算，接收方接到参数后也进行key和相关属性的MD5计算，在与传来的MD5值比对一致性。
2、相关代码实现

	// 64位
	public final static String KEY = "1234567895d8820c2ad87266599876543219aa667d777e5e7a217a1123456789";
    
    public void faceLogin(FaceLoginParam faceLoginParam, Observer observer) {
        if (!checkNetWork(observer)) {
            return;
        }
        SettingsInfo info = DataManager.getInstance().getSettingsInfo();
        String url = "http://" + info.libServerAddr + "/n/tp/face_scanning_result";

        String objString = faceLoginParam.equipmentId
                + faceLoginParam.personId
                + faceLoginParam.personName
                + faceLoginParam.personPart
                + faceLoginParam.timestamp
                + Const.KEY;

        String md5String = MD5Util.getMD5(objString);
        faceLoginParam.secStr = md5String;

        FaceScanResultClient client = ServiceGenerator.createService(FaceScanResultClient.class);
        Observable<HttpResult> observable = client.faceScanResult4Rx(url, faceLoginParam);
        observable.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(observer);
    }

	public class MD5Util {
	    //生成MD5
	    public static String getMD5(String message) {
	        String md5 = "";
	        try {
	            MessageDigest md = MessageDigest.getInstance("MD5");  // 创建一个md5算法对象
	            byte[] messageByte = message.getBytes("UTF-8");
	            byte[] md5Byte = md.digest(messageByte);              // 获得MD5字节数组,16*8=128位
	            md5 = bytesToHex(md5Byte);                            // 转换为16进制字符串
	        } catch (Exception e) {
	            e.printStackTrace();
	        }
	        return md5;
	    }
	
	    // 二进制转十六进制
	    private static String bytesToHex(byte[] bytes) {
	        StringBuffer hexStr = new StringBuffer();
	        int num;
	        for (int i = 0; i < bytes.length; i++) {
	            num = bytes[i];
	            if(num < 0) {
	                num += 256;
	            }
	            if(num < 16){
	                hexStr.append("0");
	            }
	            hexStr.append(Integer.toHexString(num));
	        }
	        return hexStr.toString();
	    }
	}

四、非对称算法的实现

import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class RSATest {
    //非对称密钥算法
    public static final String KEY_ALGORITHM = "RSA";

    /**
     * 密钥长度必须是64的倍数
     */
    private static final int KEY_SIZE = 512;

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        // 1、初始化密钥，生成密钥对
    	//实例化密钥生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGenerator.initialize(KEY_SIZE);
        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //甲方公钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        //甲方私钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

        System.out.println("公钥：\r\n" + Base64.getEncoder().encodeToString(publicKey.getEncoded()));
        System.out.println("私钥：\r\n" + Base64.getEncoder().encodeToString(privateKey.getEncoded()));
        System.out.println("\r\n密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输");
        
        
        String str = "这里是甲方向乙方发送数据的原文，RSA密码交换算法";
        System.out.println("\r\n甲方向乙方发送加密数据:");
        System.out.println("原文:" + str);
        
        // 2、甲方向乙方发送数据时，用自己的私钥进行数据的加密
        byte[] code1 = RSATest.encryptByPrivateKey(str.getBytes(), privateKey.getEncoded());
        System.out.println("加密后的数据：" + Base64.getEncoder().encodeToString(code1));
        
        
        //3、 乙方收到数据后，用甲方的公钥进行数据的解密
        System.out.println("\r\n乙方使用甲方提供的公钥对数据进行解密:");
        byte[] decode1 = RSATest.decryptByPublicKey(code1, publicKey.getEncoded());
        System.out.println("乙方解密后的数据：" + new String(decode1) + "\r\n");

        
        System.out.println("===========反向进行操作，乙方向甲方发送数据==============\r\n");
        str = "这里是乙方向甲方发送数据原文，RSA算法";
        System.out.println("原文:" + str);

        //4、乙方使用甲方的公钥对数据进行加密
        System.out.println("\r\n乙方使用公钥对数据进行加密:");
        byte[] code2 = RSATest.encryptByPublicKey(str.getBytes(), publicKey.getEncoded());
        System.out.println("加密后的数据：" + Base64.getEncoder().encodeToString(code2));

        System.out.println("\r\n==========乙方将数据传送给甲方,甲方使用私钥对数据进行解密===========");
        //甲方使用自己的私钥对数据进行解密
        byte[] decode2 = RSATest.decryptByPrivateKey(code2, privateKey.getEncoded());
        System.out.println("甲方解密后的数据：" + new String(decode2));
    }


    /**
     * 私钥加密
     *
     * @param data   待加密数据
     * @param key        密钥
     * @return byte[] 加密数据
     */
    public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception {
        //取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }


    /**
     * 私钥解密
     *
     * @param data 待解密数据
     * @param key  密钥
     * @return byte[] 解密数据
     */
    public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception {
        //取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }
      
    /**
     * 公钥加密
     *
     * @param data  待加密数据
     * @param key       密钥
     * @return byte[] 加密数据
     */
    public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception {
        //实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        //密钥材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
        //数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }

    /**
     * 公钥解密
     *
     * @param data 待解密数据
     * @param key  密钥
     * @return byte[] 解密数据
     */
    public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception {
        //实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
        //数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }
}