使用DESede加密算法进行加密

 加密方式：

先用DESede加密算法进行加密，然后Base64编码

package com.utils.base64Crypt;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;


public class SecretUtils {
    private static final String Algorithm = "DESede"; //定义加密算法，可用DES,DESede，Blowfish

    /**
     * DESede加密
     * @param keyByte 加密秘钥 长度24字节
     * @param src 被加密的数据缓冲区
     * @return
     */
    public static byte[] encryptMode(byte[] keyByte , byte[] src){
        try {

            src = addPadding(src);
            //生成秘钥
            SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte, Algorithm);
            //加密填充方式
            Cipher instance = Cipher.getInstance("DESede/ECB/NoPadding");

            instance.init(Cipher.ENCRYPT_MODE,secretKeySpec);
            return instance.doFinal(src);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 自动生成秘钥加密
     * @param src
     * @return
     */
    public static byte[] encryptMode(byte[] src){
        return encryptMode(keyGenerator(),src);
    }

    /**
     * DESede解密
     * @param keyByte
     * @param src
     * @return
     */
    public static byte[] decryptMode(byte[] keyByte , byte[] src){
        try {
            //生成秘钥
            SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte, Algorithm);
            //解密
            Cipher instance = Cipher.getInstance("DESede/ECB/NoPadding");
            instance.init(Cipher.DECRYPT_MODE,secretKeySpec);
            return instance.doFinal(src);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 自动生成秘钥解密
     * @param src
     * @return
     */
    public static byte[] decryptMode(byte[] src){
        return decryptMode(keyGenerator(),src);
    }

    /**
     * Base64要求加密数据长度为8的倍数
     * @param content
     * @return
     */
    public static byte[] addPadding(byte[] content){
        long oldLength = content.length;
        long residue = oldLength % 8;
        if (residue>0){
            int tempLength = content.length + (8-(int)residue);
            byte[] tempContent = new byte[tempLength];
            for (int index = 0;index<content.length;index++){
                tempContent[index] = content[index];
            }
/*            for (int index = content.length;index<tempLength;index++){
                tempContent[index] = 0;
            }*/
            return tempContent;
        }else {
            return content;
        }
    }

    /**
     * 秘钥处理
     * AES的区块长度固定为128位，密钥长度则可以是128，192或256位
     * DES：算法DES要求密钥长度为64位密钥, 有效密钥56位。64bits=8*8*1，即8个ascii字符。
     * DESede：算法DESede要求的密钥位数为192位，即192bits=64*3=8*8*3，即24个ascii字符。
     * Blowfish：算法Blowfish要求密钥长度为8--448字位，即8--448(bits)。即：1个到56个ascii字符
     * @param key
     * @return
     */
    public static byte[] hex(byte[] key){
        byte[] enk = new byte[24];
        if (key.length<24){
            for (int i = 0;i<key.length;i++){
                enk[i] = key[i];
            }
        }else {
            for (int i = 0;i<24;i++){
                enk[i] = key[i];
            }
        }
        return enk;
    }

    /**
     * 随机生成秘钥
     * @return
     */
    public static byte[] keyGenerator(){
        byte[] keyByte = null;
        try {
            //初始算法，设置成SHA1PRNG，放置linux环境下随机生成算法
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
            //设置随机种子,保证加解密的秘钥一致
            secureRandom.setSeed("xxx".getBytes(StandardCharsets.UTF_8));
            //秘钥生成器
            KeyGenerator keyGen = KeyGenerator.getInstance("DESede");
            //DES    56
            //DESede    112或168
            //RC2    128
            //RC4    128
            //RC5    128
            //RSA    128
            keyGen.init(112,secureRandom);//168
            SecretKey secretKey = keyGen.generateKey();
            keyByte = secretKey.getEncoded();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return keyByte;
    }

    public static void main(String[] args) {
        byte[] bytes = keyGenerator();
        System.out.println(bytes.length);
        System.out.println(Arrays.toString(keyGenerator()));
    }
}

package com.utils.base64Crypt;


import java.nio.charset.StandardCharsets;
import java.util.Base64;


public class CryptUtils {

    /**
     * 加密方式
     * 先用DESede加密算法进行加密，然后Base64编码
     * @param src 待加密明文
     * @return
     */
    public static String encrypt(byte[] pWordKey,String src){

        byte[] keyBates = SecretUtils.hex(pWordKey);
        byte[] srcBytes = SecretUtils.encryptMode(keyBates, src.getBytes(StandardCharsets.UTF_8));
        srcBytes = Base64.getEncoder().encode(srcBytes);
        return new String(srcBytes, StandardCharsets.UTF_8);
    }

    public static String encrypt(String pWordKey,String src){
        return encrypt(pWordKey.getBytes(StandardCharsets.UTF_8),src);
    }


    /**
     *
     * @param pWordKey
     * @param src 待解密密文
     * @return
     */
    public static String decrypt(byte[] pWordKey,String src){

        //src = URLDecoder.decode(src); 若网络传输，需要用url解码
        byte[] keyBates = SecretUtils.hex(pWordKey);
        byte[] srcBytes = Base64.getDecoder().decode(src.getBytes(StandardCharsets.UTF_8));
        srcBytes = SecretUtils.decryptMode(keyBates, srcBytes);
        return new String(srcBytes,StandardCharsets.UTF_8);
    }

    public static String decrypt(String pWordKey,String src){
        return decrypt(pWordKey.getBytes(StandardCharsets.UTF_8),src);
    }
}

package com.utils.base64Crypt;

public class Test {

    //测试秘钥
    private static String pWordKey = "64AG7467GDB6Y4";

    public static void main(String[] args) {
        String s1 = CryptUtils.encrypt(pWordKey, "加密测试数据");
        System.out.println("密文=="+s1);
        String decrypt = CryptUtils.decrypt(pWordKey, s1);
        System.out.println("明文=="+decrypt);

    }
}

注：

算法DESede要求的密钥位数为192位，即192bits=64*3=8*8*3，即24个ascii字符。

若秘钥长度不足24位，回报一下错误