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

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

Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, key, 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;

}

非对称加密

        /**
	 * 初始化密钥
	 * 
	 * @return
	 * @throws Exception
	 */
	public static Map 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 keyMap = new HashMap(2);
		keyMap.put("PublicKey", publicKey);
		keyMap.put("PrivateKey", privateKey);

		return keyMap;
	}

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

         /**
	 * 用私钥加密
	 * 
	 * @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给数据加密