一、Base64

1.概念：
Base64是一种用64个字符(ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/)来表示二进制数据的方法，只是一种编码方式，所以不建议使用Base64来进行加密数据。

2.由来：
为什么会有Base64编码呢？因为计算机中数据是按ascii码存储的，而ascii码的128～255之间的值是不可见字符。在网络上交换数据时，比如图片二进制流的每个字节不可能全部都是可见字符，所以就传送不了。最好的方法就是在不改变传统协议的情况下，做一种扩展方案来支持二进制文件的传送，把不可打印的字符也能用可打印字符来表示，所以就先把数据先做一个Base64编码，统统变成可见字符，降低错误率。

3.示例：

    @Test
    public void testBase64() {
        String text = "hello world!";
        //编码
        byte[] encode = Base64.getEncoder().encode(text.getBytes(StandardCharsets.UTF_8));
        System.out.println(encode);

        //解码
        byte[] decode = Base64.getDecoder().decode(encode);
        text = new String(decode, StandardCharsets.UTF_8);
        System.out.println(text);
    }

二、对称加密

加密和解密用到的密钥是相同的，这种加密方式加密速度非常快，适合经常发送数据的场合。缺点是密钥的传输比较麻烦。

1.DES
DES全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法。
DES算法把64位的明文输入块变为64位的密文输出块，它所使用的密钥也是64位，密钥事实上是56位参与DES运算（第8、16、24、32、40、48、56、64位是校验位，使得每个密钥都有奇数个1）分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。

    /**
     * 生成秘钥
     *
     * @return
     */
    public static byte[] generateKey() {
        try {
            KeyGenerator keyGen = KeyGenerator.getInstance("DES"); // 秘钥生成器
            keyGen.init(56); // 初始秘钥生成器,DES是一个基于56位密钥的对称的加密算法
            SecretKey secretKey = keyGen.generateKey(); // 生成秘钥
            return secretKey.getEncoded(); // 获取秘钥字节数组
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 进行加密/解密
     *
     * @param data 原始数据
     * @param key 密钥
     * @param opmode 加密/解密{@link Cipher#ENCRYPT_MODE},{@link Cipher#DECRYPT_MODE}
     * */
    private static byte[] doCipher(byte[] data, byte[] key, int opmode){
        byte[] bytes = null;
        try {
            //将密钥字节流转为SecretKey
            SecretKey secretKey = new SecretKeySpec(key, "DES");
            IvParameterSpec ivParameterSpec = new IvParameterSpec(key);
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(opmode, secretKey,ivParameterSpec);
            bytes = cipher.doFinal(data);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return bytes;
    }

2.3DES
3DES（或称为Triple DES）是三重数据加密算法（TDEA，Triple Data Encryption Algorithm）块密码的通称。是DES向AES过渡的加密算法，它使用3条56位的密钥对数据进行三次加密。是DES的一个更安全的变形。它以DES为基本模块，通过组合分组方法设计出分组加密算法。比起最初的DES，3DES更为安全。

    /**
     * 生成秘钥
     *
     * @return
     */
    public static byte[] generateKey(){
        byte[] key = null;
        try {
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");
            keyGenerator.init(56 * 3);
            key = keyGenerator.generateKey().getEncoded();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return key;
    }

/**
     * 进行加密/解密
     *
     * @param data 原始数据
     * @param key 密钥
     * @param opmode 加密/解密{@link Cipher#ENCRYPT_MODE},{@link Cipher#DECRYPT_MODE}
     * */
    private static byte[] doCipher(byte[] data, byte[] key, int opmode){
        byte[] bytes = null;
        try {
            SecretKey secretKey = new SecretKeySpec(key, "DESede");
            IvParameterSpec ivParameterSpec = new IvParameterSpec(key);
            Cipher cipher = Cipher.getInstance("DESede");
            cipher.init(opmode, secretKey, ivParameterSpec);
            bytes = cipher.doFinal(data);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return bytes;
    }

3.AES
AES全称Advanced Encryption Standard，即高级加密标准，当今最流行的对称加密算法之一，是DES的替代者。支持三种长度的密钥：128位，192位，256位。

AES算法是把明文拆分成一个个独立的明文块，每一个明文块长128bit。这些明文块经过AES加密器的复杂处理，生成一个个独立的密文块，这些密文块拼接在一起，就是最终的AES加密结果。
但是这里涉及到一个问题：假如一段明文长度是192bit，如果按每128bit一个明文块来拆分的话，第二个明文块只有64bit，不足128bit。这时候怎么办呢？就需要对明文块进行填充（Padding）：

• NoPadding：
  不做任何填充，但是要求明文必须是16字节的整数倍。
• PKCS5Padding（默认）：
  如果明文块少于16个字节（128bit），在明文块末尾补足相应数量的字符，且每个字节的值等于缺少的字符数。
  比如明文：{1,2,3,4,5,a,b,c,d,e},缺少6个字节，则补全为{1,2,3,4,5,a,b,c,d,e,6,6,6,6,6,6}
• ISO10126Padding：
  如果明文块少于16个字节（128bit），在明文块末尾补足相应数量的字节，最后一个字符值等于缺少的字符数，其他字符填充随机数。
  比如明文：{1,2,3,4,5,a,b,c,d,e},缺少6个字节，则可能补全为{1,2,3,4,5,a,b,c,d,e,5,c,3,G,$,6}

AES的工作模式，体现在把明文块加密成密文块的处理过程中。

• ECB模式：电码本模式 Electronic Codebook Book（默认）
• CBC模式：密码分组链接模式 Cipher Block Chaining
• CTR模式：计算器模式 Counter
• CFB模式：密码反馈模式 Cipher FeedBack
• OFB模式：输出反馈模式 Output FeedBack

    /**
     * 生成秘钥
     * @return
     */
    public static byte[] generateKey(){
        byte[] key = null;
        try {
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            keyGenerator.init(256);
            return keyGenerator.generateKey().getEncoded();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return key;
    }

    /**
     * 进行加密/解密
     *
     * @param data 原始数据
     * @param key 密钥
     * @param opmode 加密/解密{@link Cipher#ENCRYPT_MODE},{@link Cipher#DECRYPT_MODE}
     * */
      private static byte[] doCipher(byte[] data, byte[] key, int opmode){
        byte[] bytes = null;
        try {
            SecretKey secretKey = new SecretKeySpec(key, "AES");
            //AES 是加密方式、CBC 是工作模式、PKCS5Padding 填充方式
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            cipher.init(opmode, secretKey, new IvParameterSpec(new byte[cipher.getBlockSize()]));
            bytes = cipher.doFinal(data);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return bytes;
    }

三、非对称加密

加密和解密用的密钥是不同的，这种加密方式是用数学上的难解问题构造的，通常加密解密的速度比较慢，适合偶尔发送数据的场合。优点是密钥传输方便。

1.SHA
安全散列算法（英语：Secure Hash Algorithm，缩写为SHA）是一个密码散列函数家族，是FIPS所认证的安全散列算法。能计算出一个数字消息所对应到的，长度固定的字符串（又称消息摘要）的算法，且若输入的消息不同，它们对应到不同字符串的机率很高。
SHA分为SHA-1、SHA-224、SHA-256、SHA-384，和SHA-512五种算法，后四者有时并称为SHA-2。SHA-1在许多安全协定中广为使用，包括TLS和SSL、PGP、SSH、S/MIME和IPsec，曾被视为是MD5（更早之前被广为使用的杂凑函数）的后继者。但SHA-1的安全性如今被密码学家严重质疑；虽然至今尚未出现对SHA-2有效的攻击，它的算法跟SHA-1基本上仍然相似；因此有些人开始发展其他替代的杂凑算法。

• 优点：破解难度高，不可逆。
• 缺点：可以通过穷举法进行破解。

    /**
     * 通过SHA加密
     *
     * @param data 原始数据
     * @param algorithm 算法(SHA-1，SHA-224，SHA-256，SHA-384，和SHA-512)
     */
    public static String encrypt(String data, String algorithm) {
        String result = null;
        try {
            byte[] dataBytes = data.getBytes();
            MessageDigest md5 = MessageDigest.getInstance(algorithm);
            md5.update(dataBytes);
            byte[] bytes = md5.digest();
            StringBuilder sb = new StringBuilder();
            for (byte b : bytes) {
                if(Integer.toHexString(0xFF & b).length() == 1) {
                    sb.append("0");
                }
                sb.append(Integer.toHexString(0xFF & b));
            }
            result = sb.toString();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return result;
    }

2.RSA
RSA算法1978年出现，是第一个既能用于数据加密也能用于数字签名的算法，易于理解和操作。
RSA基于一个数论事实：将两个大素数相乘十分容易，但想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥，即公钥，而两个大素数组合成私钥。公钥是可提供给任何人使用，私钥则为自己所有，供解密之用。

• 优点：不可逆，既能用于数据加密，也可以应用于数字签名。
• 缺点：RSA非对称加密内容长度有限制，1024位key的最多只能加密127位数据。

    /**
     * 随机生成RSA密钥对
     *
     * @param keysize 密钥长度，范围：512-2048,一般2048
     */
    public static KeyPair generateKeyPair(int keysize) {
        try {
            KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
            kpg.initialize(keysize);
            return kpg.genKeyPair();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 公钥生成
     * @param key
     * @return
     * @throws Exception
     */
    public static PublicKey generatePublicKey(byte[] key) throws Exception{
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return keyFactory.generatePublic(keySpec);
    }

    /**
     * 秘钥生成
     * @param key
     * @return
     * @throws Exception
     */
    public static PrivateKey generatePrivateKey(byte[] key) throws Exception{
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return  keyFactory.generatePrivate(keySpec);
    }

    /**
     * 用公钥对字符串进行加密
     *
     * @param data 原文
     */
    public static byte[] encryptWithPublicKey(byte[] data, byte[] key)
            throws Exception {
        Cipher cp = Cipher.getInstance(ECB_PADDING);
        cp.init(Cipher.ENCRYPT_MODE, generatePublicKey(key));
        return cp.doFinal(data);
    }

    /**
     * 公钥解密
     *
     * @param data 待解密数据
     * @param key 密钥
     */
    public static byte[] decryptWithPublicKey(byte[] data, byte[] key)
            throws Exception {
        Cipher cipher = Cipher.getInstance(ECB_PADDING);
        cipher.init(Cipher.DECRYPT_MODE, generatePublicKey(key));
        return cipher.doFinal(data);
    }

    /**
     * 私钥加密
     *
     * @param data 待加密数据
     * @param key 密钥
     */
    public static byte[] encryptWithPrivateKey(byte[] data, byte[] key)
            throws Exception {
        Cipher cipher = Cipher.getInstance(ECB_PADDING);
        cipher.init(Cipher.ENCRYPT_MODE, generatePrivateKey(key));
        return cipher.doFinal(data);
    }

    /**
     * 私钥解密
     *
     * @param data 待解密数据
     * @param key 密钥
     */
    public static byte[] decryptWithPrivateKey(byte[] data, byte[] key)
            throws Exception {
        Cipher cp = Cipher.getInstance(ECB_PADDING);
        cp.init(Cipher.DECRYPT_MODE, generatePrivateKey(key));
        byte[] arr = cp.doFinal(data);
        return arr;
    }

3.MD5
MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值，用于确保信息传输完整一致。具有如下优点：

• 压缩性：任意长度的数据，算出的MD5值长度都是固定的。
• 容易计算：从原数据计算出MD5值很容易。
• 抗修改性：对原数据进行任何改动，所得到的MD5值都有很大区别。
• 强抗碰撞：已知原数据和其MD5值，想找到一个相同MD5值得数据是非常困难的。

    public static String md5(String string) {
        if (TextUtils.isEmpty(string)) {
            return "";
        }
        MessageDigest md5 = null;
        try {
            md5 = MessageDigest.getInstance("MD5");
            byte[] bytes = md5.digest(string.getBytes());
            StringBuilder result = new StringBuilder();
            for (byte b : bytes) {
                String temp = Integer.toHexString(b & 0xff);
                if (temp.length() == 1) {
                    temp = "0" + temp;
                }
                result.append(temp);
            }
            return result.toString();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return "";
    }

四、XOR

XOR：异或加密，既将某个字符或者数值 x 与一个数值 m 进行异或运算得到 y ，则再用 y 与 m 进行异或运算就可还原为 x。
使用场景：
（1）两个变量的互换（不借助第三个变量）；
（2）数据的简单加密解密。

   public static byte[] encrypt(byte[] data, int key) {
        if (data == null || data.length == 0){
            return null;
        }
        int length = data.length;
        for (int i = 0; i < length; i++) {
            data[i] ^= key;
        }
        return data;
    }