Android 项目必备（二十七）--＞加密和解密

概况

• 在对称加密算法中，双方使用的密钥相同，要求解密方事先必须知道加密密钥。这类加密算法技术较为成熟，加密效率高。
• 在非对称加密算法中，收发双方使用不同的密钥，发方使用公开密钥对消息进行加密，收发使用私有密钥机型解密，保密性更高，但效率更低。
• 单向加密算法在加密过程中不需要使用密钥，输入明文后由算法直接加密成密文，密文无法解密，只有重新输入密文，并经过同样的加密算法处理，得到形同的密文并被系统重新识别后，才能真正的解密，这种算法非常复杂，通常只在数据量有限的情形下使用，如广泛应用在计算机系统中的口令加密等。

对称加密和非对称加密

1. 对称加密

• 密钥可以自己指定，只有一把密钥,如果密钥暴露,文件就会被暴露；
• 特点是加密速度很快，但是缺点是安全性较低，因为只要密钥暴漏，数据就可以被解密了；
• 一句话概括：加密和解密都是用相同密钥。

2. 非对称加密

• 有两把钥匙(密钥对)，公钥和私钥，公钥的话给别人，私钥自己保存
• 把密钥通常是通过程序生成，不能自己指定
• 特点是加密速度慢些，但是安全系数很高
• 加密和解密的规则是：公钥加密只能私钥解密，私钥加密只能公钥解密
• 应用场景举例：在集成支付宝支付sdk时，需要生成私钥和公钥，公钥需要设置到支付宝网站的管理后台，在程序中调用支付接口的时候，使用我们自己的私钥进行加密，这样支付宝由于有公钥可以解密，其他人即时劫持了数据，但是没有公钥，也无法解密。

3. 常见对称加密

• DES 算法
• AES 算法

4. 常见非对称加密

• RSA

代码

1. DES 加密和解密【对称加密】

• 加密过程 需要加密的内容，也就是明文；然后需要密钥。最后通过工具类加密得到加密后的密文

private final String desEncryptString = "kevin0902";
String encrypt = DES.encrypt(desEncryptString);
        Log.e(TAG, "onCreate: "+ encrypt);
--------------------------------------------------------------------
E/MainActivity: onCreate: @2Ùj‡ùDE3.U

• 解密过程 利用加密后的密文，与设置的 key，也就是密钥，则可以解密得到加密的内容

String decrypt = DES.decrypt(encrypt);
        Log.e(TAG, "onCreate: "+ decrypt);
-------------------------------------------------------------------
E/MainActivity: onCreate: kevin0902

• 实现 DES 加密和解密的核心代码如下：

/**
 * Created on 2022/3/2 10:01
 *
 * @author Gong Youqiang
 */
public class DES {
    /** 加密KEY */
    private static final byte[] KEY = "7;9Ku7;:84VG*B78".getBytes();
    /** 算法 */
    private static final String ALGORITHM = "DES";
    /** IV */
    private static final byte[] IV = "sHjrydLq".getBytes();
    /** TRANSFORMATION */
    private static final String TRANSFORMATION = "DES/CBC/PKCS5Padding";

    private static int code = 0;

    public DES() {
    }

    /**
     * 构造函数
     * @param code 加密方式：0-“ISO-8859-1”编码，1-base64编码，其它-默认编码（utf-8）
     */
    public DES(int code) {
        this.code = code;
    }

    /**
     * 将字符串进行DES加密
     * @param source 未加密源字符串
     * @return 加密后字符串
     */
    public static String encrypt(String source)  {
        byte[] retByte = null;

        // Create SecretKey object
        DESKeySpec dks = null;
        try {
            dks = new DESKeySpec(KEY);
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
            SecretKey securekey = keyFactory.generateSecret(dks);

            // Create IvParameterSpec object with initialization vector
            IvParameterSpec spec = new IvParameterSpec(IV);

            // Create Cipter object
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);

            // Initialize Cipher object
            cipher.init(Cipher.ENCRYPT_MODE, securekey, spec);

            // Decrypting data
            retByte = cipher.doFinal(source.getBytes());

            String result = "";
            if (code == 0) {
                result = new String(retByte, "ISO-8859-1");
            } else if (code == 1) {
                result = Base64.encodeToString(retByte,false);
            } else {
                result = new String(retByte);
            }
            return result;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

    }

    /**
     * 将DES加密的字符串解密
     * @param encrypted 加密过的字符串
     * @return 未加密源字符串
     */
    public static String decrypt(String encrypted) {
        byte[] retByte = null;

        // Create SecretKey object
        DESKeySpec dks = null;
        try {
            dks = new DESKeySpec(KEY);
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
            SecretKey securekey = keyFactory.generateSecret(dks);

            // Create IvParameterSpec object with initialization vector
            IvParameterSpec spec = new IvParameterSpec(IV);

            // Create Cipter object
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);

            // Initialize Cipher object
            cipher.init(Cipher.DECRYPT_MODE, securekey, spec);

            if (code == 0) {
                retByte = encrypted.getBytes("ISO-8859-1");
            } else if (code == 1) {
                retByte = Base64.decode(encrypted);
            } else {
                retByte = encrypted.getBytes();
            }

            // Decrypting data
            retByte = cipher.doFinal(retByte);
            return new String(retByte, "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

    }
}

/**
 * Created on 2022/3/2 10:29
 *
 * @author Gong Youqiang
 */
public class Base64 {
    private static final char[] CA = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();
    private static final int[] IA = new int[256];
    static {
        Arrays.fill(IA, -1);
        for (int i = 0, iS = CA.length; i >> 2) & 0x3f;
                b2 = (d1 > 2) & 0x3f;
                b2 = ((d1 > 4)) & 0x3f;
                b3 = (d2