对称加密算法

概念

对称加密算法中，数据发信方将明文（原始数据）和加密密钥一起经过特殊加密算法处理后，使其变成复杂的加密密文发送出去。收信方收到密文后，如果想解读原文，则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密，才能使其恢复成可读明文。在对称加密算法中，使用的密钥只有一个，发收信双发都是用这个密钥对数据进行加密和解密，这就要求解密方实现必须知道加密密钥。

优缺点

优点：算法公开、计算量小、加密速度快、加密效率高
缺点：
　　－交易双方都使用同样钥匙，安全性得不到保证。
　　－每对用户每次使用对称加密算法时，都需要使用其他人不知道的惟一钥匙，这会使得发收信双方所拥有的钥匙数量呈几何级数增长，密钥管理成为用户的负担。对称加密算法在分布式网络系统上使用较为困难，主要是因为密钥管理困难，使用成本较高。

常用对称加密算法

DES

        DES算法全称为Data Encryption Standard，即数据加密算法，它是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个：Key、Data、Mode。其中Key为8个字节共64位，是DES算法的工作密钥；Data也为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式,有两种：加密或解密。
        DES算法把64位的明文输入块变为64位的密文输出块，它所使用的密钥也是64位，其算法主要分为两步：
（1）初始置换
        其功能是把输入的64位数据块按位重新组合,并把输出分为L0、R0两部分，每部分各长32位，其置换规则为将输入的第58位换到第一位，第50位换到第2位……依此类推,最后一位是原来的第7位。L0、R0则是换位输出后的两部分，L0是输出的左32位，R0是右32位，例：设置换前的输入值为D1D2D3……D64，则经过初始置换后的结果为:L0=D58D50……D8；R0=D57D49……D7。

（2）逆置换
        经过16次迭代运算后，得到L16、R16,将此作为输入，进行逆置换，逆置换正好是初始置换的逆运算，由此即得到密文输出。

3DES

        3DES（或称为Triple DES）是三重数据加密算法（TDEA，Triple Data Encryption Algorithm）块密码的通称。它相当于是对每个数据块应用三次DES加密算法。由于计算机运算能力的增强，原版DES密码的密钥长度变得容易被暴力破解；3DES即是设计用来提供一种相对简单的方法，即通过增加DES的密钥长度来避免类似的攻击，而不是设计一种全新的块密码算法。
        使用3条56位的密钥对 数据进行三次加密。3DES（即Triple DES）是DES向AES过渡的加密算法（1999年，NIST将3-DES指定为过渡的加密标准）。
        其具体实现如下：设Ek()和Dk()代表DES算法的加密和解密过程，K代表DES算法使用的密钥，P代表明文，C代表密文，这样：
        3DES加密过程为：C=Ek3(Dk2(Ek1§))
        3DES解密过程为：P=Dk1(EK2(Dk3©))

AES

        高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥。

        AES为分组密码，分组密码也就是把明文分成一组一组的，每组长度相等，每次加密一组数据，直到加密完整个明文。在AES标准规范中，分组长度只能是128位，也就是说，每个分组为16个字节（每个字节8位）。密钥的长度可以使用128位、192位或256位。密钥的长度不同，推荐加密轮数也不同。

import javax.crypto.*;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.*;

public class DESTest {

    private static final String str = "DES";
    private static final String Algorithm = "DESede";
    private static final String Algo = "AES/ECB/PKCS5Padding";


    /**
     * DES加密
     * @param src
     * @param password
     * @return
     */
    private static byte[] encrypt(byte[] src, String password) {
        try {
            //DES算法要求有一个可信任的随机数源
            SecureRandom random = new SecureRandom();
            // 创建一个 DESKeySpec 对象
            DESKeySpec desKey = new DESKeySpec(password.getBytes());
            //创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(str);
            SecretKey secretKey = keyFactory.generateSecret(desKey);
            //Cipher对象实际完成加密操作
            Cipher cipher = Cipher.getInstance(str);
            //用秘钥初始化Cipher对象，ENCRYPT_MODE用于将Cipher初始化为加密模式的常量
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, random);
            //加密数据
            return cipher.doFinal(src);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * DES解密
     * @param src
     * @param password
     * @return
     */
    private static byte[] decrypt(byte[] src, String password) {
        try {
            //DES算法要求有一个可信任的随机数源
            SecureRandom random = new SecureRandom();
            // 创建一个 DESKeySpec 对象
            DESKeySpec desKey = new DESKeySpec(password.getBytes());
            //创建一个密钥工厂，然后用它吧DESKeySpec转换成SecretKey
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(str);
            SecretKey secretKey = keyFactory.generateSecret(desKey);
            // Cipher 对象实际完成解密操作
            Cipher cipher = Cipher.getInstance(str);
            // 用密匙初始化 Cipher 对象
            cipher.init(Cipher.DECRYPT_MODE, secretKey, random);
            // 解密数据
            return cipher.doFinal(src);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 3DES加密数据
     * @param keyByte
     * @param src
     * @return
     */
    private static byte[] encrypt(byte[] keyByte, byte[] src) {
        try {
            //生成密钥
            SecretKey deskey = new SecretKeySpec(keyByte, Algorithm);
            Cipher c1 = Cipher.getInstance(Algorithm);
            c1.init(Cipher.ENCRYPT_MODE, deskey);
            //加密数据
            return c1.doFinal(src);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 3DES解密数据
     * @param keyByte
     * @param src
     * @return
     */
    private static byte[] decrypt(byte[] keyByte, byte[] src) {
        try {
            //生成密钥
            SecretKey deskey = new SecretKeySpec(keyByte, Algorithm);
            Cipher c1 = Cipher.getInstance(Algorithm);
            c1.init(Cipher.DECRYPT_MODE, deskey);
            //解密
            return c1.doFinal(src);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * AES加密
     * @param data
     * @param key
     * @return
     */
    private static byte[] encrypt(String data, Key key) {
        try {
            Cipher cipher = Cipher.getInstance(Algo);
            cipher.init(Cipher.ENCRYPT_MODE, key);
            return cipher.doFinal(data.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * AES解密
     * @param result
     * @param Key
     * @return
     */
    private static byte[] decrypt(byte[] result, Key Key) {
        try {
            Cipher cipher = Cipher.getInstance(Algo);
            cipher.init(Cipher.DECRYPT_MODE, Key);
            return cipher.doFinal(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * AES生成Key
     * @return
     */
    private static Key createKey() {
        try {
            //生成key
            KeyGenerator keyGenerator;
            //构造密钥生成器，指定为AES算大，不区分大小写
            keyGenerator = KeyGenerator.getInstance("AES");
            //生成一个128位的随机源，根据传入的字节数组
            keyGenerator.init(128);
            //产生原始对称密钥
            SecretKey secretKey = keyGenerator.generateKey();
            //获得原始对称密钥的字节数组
            byte[] keyBytes = secretKey.getEncoded();
            //key转换，根据字节数组生成AES密钥
            return new SecretKeySpec(keyBytes, "AES");
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * AES加密经base64转码
     * @param content
     * @param password
     * @return
     * @throws Exception
     */
    public static String encrypt(String content, String password) throws Exception {
        try {
            byte[] raw = password.getBytes("UTF-8");
            if (raw.length != 16) {
                throw new IllegalArgumentException("Invalid key size. " + password + ", 密钥 token 长度不是16 位");
            }
            javax.crypto.spec.SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            javax.crypto.Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            // zero
            cipher.init(Cipher.ENCRYPT_MODE, skeySpec,
                    new javax.crypto.spec.IvParameterSpec(new byte[16]));
            byte[] fina = cipher.doFinal(content.getBytes("UTF-8"));
            return new String(org.apache.commons.codec.binary.Base64.encodeBase64(fina));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * AES解密经base64转码
     * @param content
     * @param password
     * @return
     * @throws Exception
     */
    public static String decrypt(String content, String password) throws Exception {
        try {
            byte[] raw = password.getBytes("UTF-8");
            if (raw.length != 16) {
                throw new IllegalArgumentException("Invalid key size. " + password + ", 密钥 token 长度不是16 位");
            }
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, skeySpec, new IvParameterSpec(new byte[16]));
            byte[] toDecrypt = org.apache.commons.codec.binary.Base64.decodeBase64(content.getBytes());
            byte[] original = cipher.doFinal(toDecrypt);
            return new String(original, "UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void main(String[] args) {
        /* DES
        String password = "12345678";
        String data = "Hello World";
        byte[] encryptData = encrypt(data.getBytes(), password);
        System.out.println("encryptData = " + new String(encryptData));
        byte[] decryptData = decrypt(encryptData, password);
        System.out.println("decryptData = " + new String(decryptData));*/

        /* 3DES
        //添加新安全算法，如果用JCE就要把它添加进去
        Security.addProvider(new SunJCE());
        //24字节的密钥
        final byte[] keyBytes = {
                0x11, 0x22, 0x4F, 0x58,
                (byte) 0x88, 0x10, 0x40, 0x38,
                0x28, 0x25, 0x79, 0x51,
                (byte) 0xCB, (byte) 0xDD, 0x55, 0x66,
                0x77, 0x29, 0x74, (byte) 0x98,
                0x30, 0x40, 0x36, (byte) 0xE2
        };
        String src = "Hello World";
        byte[] encryptData = encrypt(keyBytes, src.getBytes());
        System.out.println("encryptData: " + new String(encryptData));

        byte[] decryptData = decrypt(keyBytes,encryptData);
        System.out.println("decryptData: " + new String(decryptData));*/

        /* AES
        String src = "Hello World";
        Key key = createKey();
        byte[] encryptData = encrypt(src, key);
        System.out.println("encryptData: " + new String(encryptData));
        byte[] decryptData = decrypt(encryptData, key);
        System.out.println("decryptData: " + new String(decryptData));*/


        /* 经过BASE64输出
        try {
            String encryptData = encrypt("Hello World", "123456789abcdefg");
            System.out.println(encryptData);
            System.out.println(decrypt(encryptData,"123456789abcdefg"));
        } catch (Exception e) {
            e.printStackTrace();
        }*/
    }
}

参考：https://blog.csdn.net/qq_28205153/article/details/55798628
http://www.blogjava.net/amigoxie/archive/2014/07/06/415503.html