aes256加解密、base64编解码、md5加密

pom配置

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.1.41</version>
        </dependency>

        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk15on</artifactId>
            <version>1.62</version>
        </dependency>

aes256加解密

package com.xj;

import com.alibaba.fastjson.JSONObject;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.security.Security;
import java.util.Base64;


/**
 * aes256算法
 */
public class AES256Encryption {

    /**
     * 密钥算法
     * java6支持56位密钥，bouncycastle支持64位
     */
    public static final String KEY_ALGORITHM = "AES";

    /**
     * 加密/解密算法/工作模式/填充方式
     * <p>
     * JAVA6 支持PKCS5PADDING填充方式
     * Bouncy castle支持PKCS7Padding填充方式
     */
    public static final String CIPHER_ALGORITHM = "AES/ECB/PKCS7Padding";

    /**
     * 生成密钥，java6只支持56位密钥，bouncycastle支持64位密钥
     *
     * @return byte[] 二进制密钥
     */
    public static String initkey() throws Exception {

        //实例化密钥生成器
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM, "BC");
        //初始化密钥生成器，AES要求密钥长度为128位、192位、256位
        kg.init(256);
        kg.init(128);
        //生成密钥
        SecretKey secretKey = kg.generateKey();
        //获取二进制密钥编码形式

        return byteToHexString(secretKey.getEncoded());
    }

    public static String byteToHexString(byte[] bytes) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < bytes.length; i++) {
            String strHex = Integer.toHexString(bytes[i]);
            if (strHex.length() > 3) {
                sb.append(strHex.substring(6));
            } else {
                if (strHex.length() < 2) {
                    sb.append("0" + strHex);
                } else {
                    sb.append(strHex);
                }
            }
        }
        return sb.toString();
    }

    /**
     * 转换密钥
     *
     * @param key 二进制密钥
     * @return Key 密钥
     */
    public static Key toKey(String key) throws Exception {
        //实例化DES密钥
        //生成密钥
        byte[] raw = key.getBytes("ASCII");
        SecretKeySpec secretKey = new SecretKeySpec(raw, "AES");
        //  SecretKey secretKey=new SecretKeySpec(key,KEY_ALGORITHM);
        return secretKey;
    }

    /**
     * 加密数据
     *
     * @param data 待加密数据
     * @param key  密钥
     * @return byte[] 加密后的数据
     */
    public static String encrypt(String data, String key) throws Exception {
        //还原密钥
        Key k = toKey(key);
        /**
         * 实例化
         * 使用 PKCS7PADDING 填充方式，按如下方式实现,就是调用bouncycastle组件实现
         * Cipher.getInstance(CIPHER_ALGORITHM,"BC")
         */

        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM, "BC");
        //初始化，设置为加密模式
        cipher.init(Cipher.ENCRYPT_MODE, k);
        //执行操作
        byte[] encrypted = cipher.doFinal(data.getBytes("UTF-8"));
//        String enc = new BASE64Encoder().encode(encrypted);
        String enc = Base64.getEncoder().encodeToString(encrypted);
        return enc;
    }

    /**
     * 解密数据
     *
     * @param data 待解密数据
     * @param key  密钥
     * @return byte[] 解密后的数据
     */
    public static String decrypt(String data, String key) throws Exception {
        //欢迎密钥
        Key k = toKey(key);
        /**
         * 实例化
         * 使用 PKCS7PADDING 填充方式，按如下方式实现,就是调用bouncycastle组件实现
         * Cipher.getInstance(CIPHER_ALGORITHM,"BC")
         */
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        //初始化，设置为解密模式
        cipher.init(Cipher.DECRYPT_MODE, k);
        //byte[] encrypted1 = new BASE64Decoder().decodeBuffer(data);
        byte[] encrypted1 = Base64.getDecoder().decode(data);

        //执行操作
        byte[] original = cipher.doFinal(encrypted1);
        String originalString = new String(original, "utf-8");

        return originalString;
    }

    public static void main(String[] args) throws Exception {

        // 申请秘钥
        System.out.println("============申请秘钥");
        for (int i = 0; i < 5; i++) {
            String initkey = initkey();
            System.out.println("initkey:" + initkey);
        }

        // 加密
        System.out.println("\r\n=============加密");

        String aesKey = "D31ED481076DF46DC2345EF5963A7EEE";
        System.out.println("秘钥：" + aesKey);
        JSONObject json = new JSONObject();
        json.put("client_id", "xxx");
        json.put("date", "xxx");
        json.put("cmp_id", "xxx");
        json.put("prod_code", "xxx");
        json.put("times_tamp", "xxx");
        System.out.println("内容：" + json.toJSONString());

        String encryptStr = AES256Encryption.encrypt(json.toJSONString(), aesKey);
        System.out.println("加密结果：" + encryptStr);

        String enc = Base64.getEncoder().encodeToString(encryptStr.getBytes("UTF-8"));
        System.out.println("base64编码：" + enc);

        // 解密
        System.out.println("\r\n=================解密");
        System.out.println("秘钥：" + aesKey);
        System.out.println("密文：" + enc);

        byte[] bytes = Base64.getDecoder().decode(enc);
        String dec = new String(bytes);
        System.out.println("base64解码：" + dec);

        String decryptResult = AES256Encryption.decrypt(dec, aesKey);
        System.out.println("aes解密：" + decryptResult);


        System.out.println("\r\n=================base64");

    }

}

base64编解码

package com.xj;


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

public class Base64Encryption {

    public static void main(String[] args) throws UnsupportedEncodingException {
        String str = "hello Base64 啊啊\n" + "ADCDEFG";
        //编码加密
        String encodeStr = Base64.getEncoder().encodeToString(str.getBytes(StandardCharsets.UTF_8));
        System.out.println("加密后的字符串为:" + encodeStr);

        //解码解密
        String decoderStr = new String(Base64.getDecoder().decode(encodeStr), StandardCharsets.UTF_8);
        // 推荐使用StandardCharsets类指定
        System.out.println("解密后的字符串为" + decoderStr);
    }
}

md5加密

package com.xj;

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class Md5Encryption {


    public static String md5(String source) {
        StringBuffer sb = new StringBuffer(32);

        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] array = md.digest(source.getBytes("utf-8"));

            for (int i = 0; i < array.length; i++) {
                sb.append(Integer.toHexString((array[i] & 0xFF) | 0x100).toUpperCase().substring(1, 3));
            }
        } catch (Exception e) {
            System.out.println("Can not encode the string '" + source + "' to MD5!");
            e.printStackTrace();
            return null;
        }

        return sb.toString();
    }

    public static String MD5String(String s) {
        try {
            MessageDigest m = MessageDigest.getInstance("MD5");
            m.update(s.getBytes(), 0, s.length());
            BigInteger i = new BigInteger(1, m.digest());
            return String.format("%1$032x", i).toUpperCase();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return s;
    }

    public static void main(String[] args) {
        System.out.println(md5("aa"));

        System.out.println(MD5String("aa"));
    }
}