Android安全－对称加密和非对称加密

秘钥：分为加密秘钥和解密秘钥

明文：没有进行加密，能够直接代表原文含义的信息

密文：经过加密处理之后，隐藏原文含义的信息

加密：将明文转换为密文的过程

解密：将密文转换为明文的过程

对称加密

DES

　　1977年1月，美国政府颁布：采纳IBM公司设计的方案作为非机密数据的正式数据加密标准（DESData Encryption Standard) 。
　　目前在国内，随着三金工程尤其是金卡工程的启动，DES算法在POS、ATM、磁卡及智能卡（IC卡）、加油站、高速公路收费站等领域被广泛应用，以此来实现关键数据的保密，如信用卡持卡人的PIN的加密传输，IC卡与POS间的双向认证、金融交易数据包的MAC校验等，均用到DES算法。

       DES算法的入口参数有三个：Key、Data、Mode。其中Key为8个字节共64位，是DES算法的工作密钥；Data也为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式，有两种：加密或解密。
  DES算法是这样工作的：
　　如Mode为加密，则用Key去把数据Data进行加密， 生成Data的密码形式（64位）作为DES的输出结果；
　　如Mode为解密，则用Key去把密码形式的数据Data解密，还原为Data的明码形式（64位）作为DES的输出结果。
　　在通信网络的两端，双方约定一致的Key，在通信的源点用Key对核心数据进行DES加密，然后以密码形式在公共通信网（如电话网）中传输到通信网络的终点，数据到达目的地后，用同样的Key对密码数据进行解密，便再现了明码形式的核心数据。这样，便保证了核心数据（如PIN、MAC等）在公共通信网中传输的安全性和可靠性。
　　通过定期在通信网络的源端和目的端同时改用新的Key，便能更进一步提高数据的保密性，这正是现在金融交易网络的流行做法。

3DES

　　3DES是DES加密算法的一种模式，它使用3条64位的密钥对数据进行三次加密。数据加密标准（DES）是美国的一种由来已久的加密标准，它使用对称密钥加密法。
　　3DES（即Triple DES）是DES向AES过渡的加密算法（1999年，NIST将3-DES指定为过渡的加密标准），是DES的一个更安全的变形。它以DES为基本模块，通过组合分组方法设计出分组加密算法。
 
　　设Ek()和Dk()代表DES算法的加密和解密过程，K代表DES算法使用的密钥，P代表明文，C代表密表，这样，
　　3DES加密过程为：C=Ek3(Dk2(Ek1(P)))
　　3DES解密过程为：P=Dk1((EK2(Dk3(C)))
　　K1、K2、K3决定了算法的安全性，若三个密钥互不相同，本质上就相当于用一个长为168位的密钥进行加密。多年来，它在对付强力攻击时是比较安全的。若数据对安全性要求不那么高，K1可以等于K3。在这种情况下，密钥的有效长度为112位。

 AES

　　AES(Advanced Encryption Standard)：高级加密标准，是下一代的加密算法标准，速度快，安全级别高。
　　用AES加密2000年10月，NIST（美国国家标准和技术协会）宣布通过从15种候选算法中选出的一项新的密匙加密标准。Rijndael被选中成为将来的 AES。Rijndael是在1999年下半年，由研究员Joan Daemen 和 Vincent Rijmen 创建的。AES正日益成为加密各种形式的电子数据的实际标准。
　　美国标准与技术研究院（NIST）于2002年5月26日制定了新的高级加密标准（AES）规范。
　　AES算法基于排列和置换运算。排列是对数据重新进行安排，置换是将一个数据单元替换为另一个。
　　AES使用几种不同的方法来执行排列和置换运算。AES是一个迭代的、对称密钥分组的密码，它可以使用128、192和256位密钥，并且用128位（16字节）分组加密和解密数据。
　 与公共密钥加密使用密钥对不同，对称密钥密码使用相同的密钥加密和解密数据。通过分组密码返回的加密数据的位数与输入数据相同。迭代加密使用一个循环结构，在该循环中重复置换和替换输入数据。

调用AES/DES加密算法包最精要的就是下面两句话：

Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, key, zeroIv);

CBC是工作模式，DES一共有电子密码本模式（ECB）、加密分组链接模式（CBC）、加密反馈模式（CFB）和输出反馈模式（OFB）四种模式，
PKCS5Padding是填充模式，还有其它的填充模式
然后，cipher.init（)一共有三个参数：Cipher.ENCRYPT_MODE, key, zeroIv，zeroIv就是初始化向量。
工作模式、填充模式、初始化向量这三种因素一个都不能少。

1、加密

public static String encrypt(String text) throws Exception {
		// 私钥 AES固定格式为128/192/256bits.即：16/24/32bytes。DES固定格式为128bits，即8bytes。
		String key = "aaaaaaaaaaaaaaaa";
		// 初始化向量参数，AES 为16bytes. DES 为8bytes
		String iv ="bbbbbbbbbbbbbbbb"; 
		
		// 两个参数，第一个为私钥字节数组， 第二个为加密方式AES或者DES
		Key keySpec = new SecretKeySpec(key.getBytes(), "AES"); 

		IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes());
		// 实例化加密类，参数为加密方式，要写全
		Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
		// 初始化，此方法可以采用三种方式，按服务器要求来添加。（1）无第三个参数（2）第三个参数为SecureRandom
		//（3）采用此代码中的IVParameterSpec
		cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);
              
                // random = new SecureRandom();中random对象，随机数。(AES不可采用这种方法)
		// cipher.init(Cipher.ENCRYPT_MODE, keySpec);
		// SecureRandom random = new SecureRandom();
		// cipher.init(Cipher.ENCRYPT_MODE, keySpec, random);
		byte[] bytes = cipher.doFinal(text.getBytes());// 加密操作,返回加密后的字节数组，然后需要编码。主要编解码方式有Base64, HEX, UUE,
		// 7bit等等。此处看服务器需要什么编码方式
		String result = Base64.encodeToString(bytes, Base64.DEFAULT);
		return result;

	}

2、解密

public static String decrypt(String text) throws Exception {

		String keySpec = "aaaaaaaaaaaaaaaa";
		String iv = "bbbbbbbbbbbbbbbb";
		byte[] textBytes = Base64.decode(text.getBytes(), Base64.DEFAULT);

		IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes());

		Key key = new SecretKeySpec(keySpec.getBytes(), "AES");

		Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");

		cipher.init(Cipher.DECRYPT_MODE, key, ivSpec); // 与加密时不同MODE:Cipher.DECRYPT_MODE

		String result = cipher.doFinal(textBytes);

		return result;

}

非对称加密

非对称加密。 密钥不是一个，而是一对，A和B。使用A加密的密文只能使用B来解密。使用B加密的密文只能使用A来解密。选择其中的一个作为公钥，另一个作为私钥，可以用于许多非对称加密应用场合。比如电子证书、电子指纹、电子签名、握手协议等传统对称加密手段无法实现的功能。
其核心是基于“大数的分解质因数非常困难”这个数学难题。使得在得知A的人无法推算出B，B也无法推算出A。

    RSA公钥加密算法是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。
    RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密算法。
 

流程分析： 

• 甲方构建密钥对儿，将公钥公布给乙方，将私钥保留。
• 甲方使用私钥加密数据，然后用私钥对加密后的数据签名，发送给乙方签名以及加密后的数据；乙方使用公钥、签名来验证待解密数据是否有效，如果有效使用公钥对数据解密。
• 乙方使用公钥加密数据，向甲方发送经过加密后的数据；甲方获得加密数据，通过私钥解密。

  RSA加密解密的实现，需要有一对公私密钥，公私密钥的生成如下：

        /**
	 * 初始化密钥
	 * 
	 * @return
	 * @throws Exception
	 */
	public static Map<String, Object> initKey() throws Exception {
		KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
		keyPairGenerator.initialize(512);
		KeyPair keyPair = keyPairGenerator.generateKeyPair();
		// 公钥
		RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
		// 私钥
		RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

		Map<String, Object> keyMap = new HashMap<String, Object>(2);
		keyMap.put("PublicKey", publicKey);
		keyMap.put("PrivateKey", privateKey);

		return keyMap;
	}

  从代码中可以看出密钥的初始化长度为512位(密钥最短为512bit)，密钥的长度越长，安全性就越好，但是加密解密所用的时间就会越多。而一次能加密的密文长度也与密钥的长度成正比。一次能加密的密文长度为：密钥的长度/8-11。所以1024bit长度的密钥一次可以加密的密文为1024/8-11=117bit。所以非对称加密一般都用于加密对称加密算法的密钥，而不是直接加密内容。对于小文件可以使用RSA加密，但加密过程仍可能会使用分段加密。

  从map中获取公钥、私钥

	/**
	 * 取得公钥，并转化为String类型
	 * 
	 * @param keyMap
	 * @return
	 * @throws Exception
	 */
	public static String getPublicKey(Map<String, Object> keyMap)
			throws Exception {
		Key key = (Key) keyMap.get("PublicKey");
		return Base64.encodeToString(key.getEncoded(), Base64.DEFAULT);
	}

	/**
	 * 取得私钥，并转化为String类型
	 * 
	 * @param keyMap
	 * @return
	 * @throws Exception
	 */
	public static String getPrivateKey(Map<String, Object> keyMap)
			throws Exception {
		Key key = (Key) keyMap.get("PrivateKey");
		return Base64.encodeToString(key.getEncoded(), Base64.DEFAULT);
	}

 对于RSA产生的公钥、私钥，我们可以有两种方式可以对信息进行加密解密。私钥加密-公钥解密 和 公钥加密-私钥解密。

• 私钥加密

         /**
	 * 用私钥加密
	 * 
	 * @param data
	 *            加密数据
	 * @param key
	 *            密钥
	 * @return
	 * @throws Exception
	 */
	public static String encryptByPrivateKey(String data, String key)
			throws Exception {
		// 解密密钥
		byte[] keyBytes = Base64.decode(key.getBytes(), Base64.DEFAULT);
		// 取私钥
		PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(
				keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		Key privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

		// 对数据加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, privateKey);
		byte[] resultBytes=cipher.doFinal(data.getBytes("UTF-8"));
		return Base64.encodeToString(resultBytes, Base64.DEFAULT);
	}

• 私钥解密

	/**
	 * 用私钥解密
	 * 
	 * @param data
	 *            加密数据
	 * 
	 * @param key
	 *            密钥
	 * @return
	 * @throws Exception
	 */
	public static String decryptByPrivateKey(String data, String key)
			throws Exception {
		// 对私钥解密
		byte[] keyBytes = Base64.decode(key.getBytes(), Base64.DEFAULT);

		PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(
				keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance("RSA");
		Key privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
		// 对数据解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, privateKey);
		byte[] dataBytes=Base64.decode(data.getBytes(), Base64.DEFAULT);
		byte[] resultBytes=cipher.doFinal(dataBytes);
		return new String(resultBytes,"UTF-8");
	}

• 公钥加密

    /**
     * 用公钥加密
     * @param data   加密数据
     * @param key    密钥
     * @return
     * @throws Exception
     */
    public static String encryptByPublicKey(String data,String key)throws Exception{
        //对公钥解密
        byte[] keyBytes =  Base64.decode(key.getBytes(), Base64.DEFAULT);
        //取公钥
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
        Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
         
        //对数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] resultBytes=cipher.doFinal(data.getBytes());
	return Base64.encodeToString(resultBytes, Base64.DEFAULT);
    }

• 公钥解密

    /**
     * 用公钥解密
     * @param data   加密数据
     * @param key    密钥
     * @return
     * @throws Exception
     */
    public static String decryptByPublicKey(String data,String key)throws Exception{
        //对私钥解密
        byte[] keyBytes =  Base64.decode(key.getBytes(),Base64.DEFAULT);
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
        Key publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
         
        //对数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        byte[] dataBytes=Base64.decode(data.getBytes(), Base64.DEFAULT);
        byte[] resultBytes=cipher.doFinal(dataBytes);
        return new String(resultBytes,"UTF-8");
    }

  关于数字签名，先了解下何为数字签名。数字签名，就是只有信息的发送者才能产生的别人无法伪造的一段数字串，这段数字串同时也是对信息的发送者发送信息真实性的一个有效证明。数字签名是非对称密钥加密技术与数字摘要技术的应用。简单地说,所谓数字签名就是附加在数据单元上的一些数据,或是对数据单元所作的密码变换。这种数据或变换允许数据单元的接收者用以确认数据单元的来源和数据单元的完整性并保护数据,防止被人(例如接收者)进行伪造。
    数字签名的主要功能如下：
    保证信息传输的完整性、发送者的身份认证、防止交易中的抵赖发生。
    数字签名技术是将摘要信息用发送者的私钥加密，与原文一起传送给接收者。接收者只有用发送者的公钥才能解密被加密的摘要信息，然后用对收到的原文产生一个摘要信息，与解密的摘要信息对比。如果相同，则说明收到的信息是完整的，在传输过程中没有被修改，否则说明信息被修改过，因此数字签名能够验证信息的完整性。
    数字签名是个加密的过程，数字签名验证是个解密的过程.
     数字签名算法依靠公钥加密技术来实现的。在公钥加密技术里，每一个使用者有一对密钥：一把公钥和一把私钥。公钥可以自由发布，但私钥则秘密保存；还有一个要求就是要让通过公钥推算出私钥的做法不可能实现。

• 私钥签名

        /**
	 * 用私钥对信息生成数字签名
	 * 
	 * @param data
	 *            //加密数据
	 * @param privateKey
	 *            //私钥
	 * @return
	 * @throws Exception
	 */
	public static String sign(byte[] data, String privateKey) throws Exception {
		// 解密私钥
		byte[] keyBytes = Base64.decode(privateKey.getBytes(), Base64.DEFAULT);
		// 构造PKCS8EncodedKeySpec对象
		PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(
				keyBytes);
		// 指定加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
		// 取私钥匙对象
		PrivateKey privateKey2 = keyFactory
				.generatePrivate(pkcs8EncodedKeySpec);
		// 用私钥对信息生成数字签名
		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		signature.initSign(privateKey2);
		signature.update(data);
		return Base64.encodeToString(signature.sign(), Base64.DEFAULT);
	}

• 公钥校验

     /**
     * 校验数字签名
     * @param data   加密数据
     * @param publicKey  公钥
     * @param sign   数字签名
     * @return
     * @throws Exception
     */
    public static boolean verify(byte[] data,String publicKey,String sign)throws Exception{
        //解密公钥
        byte[] keyBytes = Base64.decode(publicKey.getBytes(), Base64.DEFAULT);
        //构造X509EncodedKeySpec对象
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
        //指定加密算法
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
        //取公钥匙对象
        PublicKey publicKey2 = keyFactory.generatePublic(x509EncodedKeySpec);
         
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicKey2);
        signature.update(data);
        //验证签名是否正常
        return signature.verify(Base64.decode(sign,Base64.DEFAULT));
         
    }

优缺点

• aes/des加密速度快,适合大量数据,des容易破解,一般用3重des,后来又出现了更快更安全的aes
• rsa是公钥加密,速度慢,只能处理少量数据,优点是公钥即使在不安全的网络上公开,也能保证安全
• 常见情况是双方用rsa协商出一个密钥后通过aes/3des给数据加密