【Android】Android加密和解密方式

一、不可逆加密

不可逆加密算法的特征是加密过程中不需要使用密钥，输入明文后由系统直接经过加密算法处理成密文，这种加密后的数据是无法被解密的，只有重新输入明文，并再次经过同样不可逆的加密算法处理，得到相同的加密密文并被系统重新识别后，才能真正解密。 如信息摘要（Message Digest）和安全散列（Secure Hash）算法属于此类，常见的算法包括 MD5、SHA1、PBKDF2、bcrypt 等。 特点： 使用MD5和SHA进行加解密：

// MD5加密 private static String toMd5(String str) { // 实例化一个指定摘要算法为MD5的MessageDigest对象 MessageDigest algorithm; try { algorithm = MessageDigest.getInstance("MD5"); // 重置摘要以供再次使用 algorithm.reset(); // 使用bytes更新摘要 algorithm.update(str.getBytes()); // 使用指定的byte数组对摘要进行最后更新,然后完成摘要计算 return toHexString(algorithm.digest(), ""); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } return null; } // SHA加密 private static String toSHA(String str) { // 实例化一个指定摘要算法为SHA的MessageDigest对象 MessageDigest algorithm; try { algorithm = MessageDigest.getInstance("SHA"); // 重置摘要以供再次使用 algorithm.reset(); // 使用bytes更新摘要 algorithm.update(str.getBytes()); // 使用指定的byte数组对摘要进行最后更新,然后完成摘要计算 return toHexString(algorithm.digest(), ""); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } return null; } // 将字符串中的每个字符转换为十六进制 private static String toHexString(byte[] bytes, String separtor) { StringBuilder hexString = new StringBuilder(); for (byte b : bytes) { String hex = Integer.toHexString(0xff & b); if (hex.length() == 1) { hexString.append("0"); } hexString.append(hex).append(separtor); } return hexString.toString(); }

二、可逆加密

算法加密

基于算法的加密算法，也被称为古典加密算法，如 HTTP 认证中的 base64，是一种基于64个基本字符，加密后的内容只包含这64个字符，加密后长度会变大。它是最简单的一种算法，一般用于加密URL. 下图为Base64编码表

Base64加解密相关代码

// 需要引入包：java.util.Base64 // Base64加密 private static String encode(String str) { byte[] encodeBytes = Base64.getEncoder().encode(str.getBytes()); return new String(encodeBytes); } // Base64解密 private static String decode(String str) { byte[] decodeBytes = Base64.getDecoder().decode(str.getBytes()); return new String(decodeBytes); }

对称加密

对称加密：加密和解密的密钥一样。常见的对称加密算法有 DES、3DES、AES。这三者的关系可以理解为迭代和替代。3DES是对DES的发展，AES是为了替代DES. DES加解密相关代码

public class DESUtil { // 初始化向量 private static byte[] iv = { 'a', 'b', 'c', 'd', 'e', 1, 2, '*' }; // DES加密 // encryptText为原文 // encryptKey为密匙 private static String encryptDES(String encryptText, String encryptKey) throws Exception { // 实例化IvParameterSpec对象，使用指定的初始化向量 IvParameterSpec spec = new IvParameterSpec(iv); // 实例化SecretKeySpec类,根据字节数组来构造SecretKeySpec SecretKeySpec key = new SecretKeySpec(encryptKey.getBytes(), "DES"); // 创建密码器 Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding"); // 用密码初始化Cipher对象 cipher.init(Cipher.ENCRYPT_MODE, key, spec); // 执行加密操作 byte[] encryptData = cipher.doFinal(encryptText.getBytes()); // 返回加密后的数据 return Base64.getEncoder().encodeToString(encryptData); } // 解密 private static String decryptDES(String decryptString, String decryptKey) throws Exception { // 先使用Base64解密 byte[] base64byte = Base64.getDecoder().decode(decryptString); // 实例化IvParameterSpec对象，使用指定的初始化向量 IvParameterSpec spec = new IvParameterSpec(iv); // 实例化SecretKeySpec类,根据字节数组来构造SecretKeySpec SecretKeySpec key = new SecretKeySpec(decryptKey.getBytes(), "DES"); // 创建密码器 Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding"); // 用密码初始化Cipher对象 cipher.init(Cipher.DECRYPT_MODE, key, spec); // 获取解密后的数据 byte decryptedData[] = cipher.doFinal(base64byte); // 将解密后数据转换为字符串输出 return new String(decryptedData); } }

AES加解密相关代码

public class AESUtil { // 采用对称分组密码体制,密钥长度的最少支持为128、192、256 String key = "abcdefghijklmnop"; // 初始化向量参数，AES 为16bytes. DES 为8bytes， 16*8=128 String initVector = "0000000000000000"; IvParameterSpec iv; SecretKeySpec skeySpec; Cipher cipher; private static class HOLDER { private static AESUtil instance = new AESUtil(); } public static AESUtil getInstance() { return HOLDER.instance; } private AESUtil() { try { iv = new IvParameterSpec(initVector.getBytes("UTF-8")); skeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "AES"); // 这是CBC模式 // cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING"); // 默认就是ECB模式 cipher = Cipher.getInstance("AES/ECB/PKCS5PADDING"); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (NoSuchPaddingException e) { e.printStackTrace(); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } } public String encrypt(String value) { try { // CBC模式需要传入向量，ECB模式不需要 // cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv); cipher.init(Cipher.ENCRYPT_MODE, skeySpec); byte[] encrypted = cipher.doFinal(value.getBytes()); return Base64.encodeToString(encrypted, Base64.DEFAULT); } catch (Exception e) { e.printStackTrace(); } return null; } public String decrypt(String encrypted) { try { // CBC模式需要传入向量，ECB模式不需要 // cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv); cipher.init(Cipher.DECRYPT_MODE, skeySpec); byte[] original = cipher.doFinal(Base64.decode(encrypted, Base64.DEFAULT)); return new String(original); } catch (Exception ex) { ex.printStackTrace(); } return null; }

非对称加密

非对称加密：加密和解密的密钥不同，通常是公钥加密私钥解密，当然也可以私钥加密公钥解密，公钥通常用来对内容加密，而私钥既可以解密也可以用来确定是否是对应的公钥加的密，防止他人用错误的公钥进行加密。 非对称加密中另外两个重要的概念是公钥和私钥。公钥对外公开，任何人均可持有和使用；私钥自行保管，其安全性是通信安危的关键。常见的算法有 RSA、DH（Diffie-Hellman）、椭圆曲线算法（Elliptic curve cryptography，ECC）。 私钥和公钥的作用一般分为两种： 公钥加密，私钥解密，主要用于通信； 私钥加密（签名），公钥解密（验证），主要用于数字签名。 RSA算法相关代码

public class RSAUtil { public static final String RSA = "RSA"; public static final String ECB_PKCS1_PADDING = "RSA/ECB/PKCS1Padding"; // 秘钥默认长度 public static final int DEFAULT_KEY_SIZE = 2048; // 当要加密的内容超过bufferSize，则采用partSplit进行分块加密 public static final byte[] DEFAULT_SPLIT = "#PART#".getBytes(); // 当前秘钥支持加密的最大字节数 public static final int DEFAULT_BUFFERSIZE = (DEFAULT_KEY_SIZE / 8) - 11; // 随机生成RSA密钥对，密钥长度，范围：512～2048 public static KeyPair generateRSAKeyPair(int keyLength) { try { KeyPairGenerator kpg = KeyPairGenerator.getInstance(RSA); kpg.initialize(keyLength); return kpg.genKeyPair(); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); return null; } } /** * 私钥加密 * @param data 待加密数据 * @param privateKey 密钥 * @return byte[] 加密数据 */ public static byte[] encryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception { // 得到私钥 PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey); KeyFactory kf = KeyFactory.getInstance(RSA); PrivateKey keyPrivate = kf.generatePrivate(keySpec); // 数据加密 Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING); cipher.init(Cipher.ENCRYPT_MODE, keyPrivate); return cipher.doFinal(data); } // 使用私钥进行解密 public static byte[] decryptByPrivateKey(byte[] encrypted, byte[] privateKey) throws Exception { // 得到私钥 PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey); KeyFactory kf = KeyFactory.getInstance(RSA); PrivateKey keyPrivate = kf.generatePrivate(keySpec); // 解密数据 Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING); cp.init(Cipher.DECRYPT_MODE, keyPrivate); byte[] arr = cp.doFinal(encrypted); return arr; } // 用公钥对字符串进行加密 public static byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception { // 得到公钥 X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey); KeyFactory kf = KeyFactory.getInstance(RSA); PublicKey keyPublic = kf.generatePublic(keySpec); // 加密数据 Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING); cp.init(Cipher.ENCRYPT_MODE, keyPublic); return cp.doFinal(data); } /** * 公钥解密 * @param data 待解密数据 * @param publicKey 密钥 * @return byte[] 解密数据 */ public static byte[] decryptByPublicKey(byte[] data, byte[] publicKey) throws Exception { // 得到公钥 X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey); KeyFactory kf = KeyFactory.getInstance(RSA); PublicKey keyPublic = kf.generatePublic(keySpec); // 数据解密 Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING); cipher.init(Cipher.DECRYPT_MODE, keyPublic); return cipher.doFinal(data); } // 以下开始分段解密 // 使用私钥分段解密 public static byte[] decryptByPrivateKeyForSpilt(byte[] encrypted, byte[] privateKey) throws Exception { int splitLen = DEFAULT_SPLIT.length; if (splitLen <= 0) { return decryptByPrivateKey(encrypted, privateKey); } int dataLen = encrypted.length; List<Byte> allBytes = new ArrayList<Byte>(1024); int latestStartIndex = 0; for (int i = 0; i < dataLen; i++) { byte bt = encrypted[i]; boolean isMatchSplit = false; if (i == dataLen - 1) { // 到data的最后了 byte[] part = new byte[dataLen - latestStartIndex]; System.arraycopy(encrypted, latestStartIndex, part, 0, part.length); byte[] decryptPart = decryptByPrivateKey(part, privateKey); for (byte b : decryptPart) { allBytes.add(b); } latestStartIndex = i + splitLen; i = latestStartIndex - 1; } else if (bt == DEFAULT_SPLIT[0]) { // 这个是以split[0]开头 if (splitLen > 1) { if (i + splitLen < dataLen) { // 没有超出data的范围 for (int j = 1; j < splitLen; j++) { if (DEFAULT_SPLIT[j] != encrypted[i + j]) { break; } if (j == splitLen - 1) { // 验证到split的最后一位，都没有break，则表明已经确认是split段 isMatchSplit = true; } } } } else { // split只有一位，则已经匹配了 isMatchSplit = true; } } if (isMatchSplit) { byte[] part = new byte[i - latestStartIndex]; System.arraycopy(encrypted, latestStartIndex, part, 0, part.length); byte[] decryptPart = decryptByPrivateKey(part, privateKey); for (byte b : decryptPart) { allBytes.add(b); } latestStartIndex = i + splitLen; i = latestStartIndex - 1; } } byte[] bytes = new byte[allBytes.size()]; { int i = 0; for (Byte b : allBytes) { bytes[i++] = b.byteValue(); } } return bytes; } // 私钥分段加密 public static byte[] encryptByPrivateKeyForSpilt(byte[] data, byte[] privateKey) throws Exception { int dataLen = data.length; if (dataLen <= DEFAULT_BUFFERSIZE) { return encryptByPrivateKey(data, privateKey); } List<Byte> allBytes = new ArrayList<Byte>(2048); int bufIndex = 0; int subDataLoop = 0; byte[] buf = new byte[DEFAULT_BUFFERSIZE]; for (int i = 0; i < dataLen; i++) { buf[bufIndex] = data[i]; if (++bufIndex == DEFAULT_BUFFERSIZE || i == dataLen - 1) { subDataLoop++; if (subDataLoop != 1) { for (byte b : DEFAULT_SPLIT) { allBytes.add(b); } } byte[] encryptBytes = encryptByPrivateKey(buf, privateKey); for (byte b : encryptBytes) { allBytes.add(b); } bufIndex = 0; if (i == dataLen - 1) { buf = null; } else { buf = new byte[Math.min(DEFAULT_BUFFERSIZE, dataLen - i - 1)]; } } } byte[] bytes = new byte[allBytes.size()]; { int i = 0; for (Byte b : allBytes) { bytes[i++] = b.byteValue(); } } return bytes; } // 用公钥对字符串进行分段加密 public static byte[] encryptByPublicKeyForSpilt(byte[] data, byte[] publicKey) throws Exception { int dataLen = data.length; if (dataLen <= DEFAULT_BUFFERSIZE) { return encryptByPublicKey(data, publicKey); } List<Byte> allBytes = new ArrayList<Byte>(2048); int bufIndex = 0; int subDataLoop = 0; byte[] buf = new byte[DEFAULT_BUFFERSIZE]; for (int i = 0; i < dataLen; i++) { buf[bufIndex] = data[i]; if (++bufIndex == DEFAULT_BUFFERSIZE || i == dataLen - 1) { subDataLoop++; if (subDataLoop != 1) { for (byte b : DEFAULT_SPLIT) { allBytes.add(b); } } byte[] encryptBytes = encryptByPublicKey(buf, publicKey); for (byte b : encryptBytes) { allBytes.add(b); } bufIndex = 0; if (i == dataLen - 1) { buf = null; } else { buf = new byte[Math.min(DEFAULT_BUFFERSIZE, dataLen - i - 1)]; } } } byte[] bytes = new byte[allBytes.size()]; { int i = 0; for (Byte b : allBytes) { bytes[i++] = b.byteValue(); } } return bytes; } // 公钥分段解密 public static byte[] decryptByPublicKeyForSpilt(byte[] encrypted, byte[] publicKey) throws Exception { int splitLen = DEFAULT_SPLIT.length; if (splitLen <= 0) { return decryptByPublicKey(encrypted, publicKey); } int dataLen = encrypted.length; List<Byte> allBytes = new ArrayList<Byte>(1024); int latestStartIndex = 0; for (int i = 0; i < dataLen; i++) { byte bt = encrypted[i]; boolean isMatchSplit = false; if (i == dataLen - 1) { // 到data的最后了 byte[] part = new byte[dataLen - latestStartIndex]; System.arraycopy(encrypted, latestStartIndex, part, 0, part.length); byte[] decryptPart = decryptByPublicKey(part, publicKey); for (byte b : decryptPart) { allBytes.add(b); } latestStartIndex = i + splitLen; i = latestStartIndex - 1; } else if (bt == DEFAULT_SPLIT[0]) { // 这个是以split[0]开头 if (splitLen > 1) { if (i + splitLen < dataLen) { // 没有超出data的范围 for (int j = 1; j < splitLen; j++) { if (DEFAULT_SPLIT[j] != encrypted[i + j]) { break; } if (j == splitLen - 1) { // 验证到split的最后一位，都没有break，则表明已经确认是split段 isMatchSplit = true; } } } } else { // split只有一位，则已经匹配了 isMatchSplit = true; } } if (isMatchSplit) { byte[] part = new byte[i - latestStartIndex]; System.arraycopy(encrypted, latestStartIndex, part, 0, part.length); byte[] decryptPart = decryptByPublicKey(part, publicKey); for (byte b : decryptPart) { allBytes.add(b); } latestStartIndex = i + splitLen; i = latestStartIndex - 1; } } byte[] bytes = new byte[allBytes.size()]; { int i = 0; for (Byte b : allBytes) { bytes[i++] = b.byteValue(); } } return bytes; } }