java-加密解密

1、Base64

package ai.saas.framework.common.util;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class Base64Util {

	// 
    public static byte[] decryBASE64ToByteArr(String key) throws Exception{
        return (new BASE64Decoder()).decodeBuffer(key);
    }


    public static String encryptBASE64(byte[] key) throws Exception{
        return (new BASE64Encoder()).encode(key);
    }


}

2、AES

• AES算法作为DES算法和MD5算法的替代产品，10轮循环到目前为止还没有被破解。
  一般多数人的意见是：它是目前可获得的最安全的加密算法。
  AES与目前使用广泛的加密算法─DES算法的差别在于，
  如果一秒可以解DES，则仍需要花费1490000亿年才可破解AES，由此可知AES的安全性。
  AES 已被列为比任何现今其它对称加密算法更安全的一种算法。

package ai.saas.framework.common.util;

import ai.saas.framework.common.constant.CommonConstant;
import org.springframework.util.Base64Utils;
import org.springframework.util.StringUtils;
import org.yaml.snakeyaml.util.ArrayUtils;

import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * 2020-12-05
 * AES算法作为DES算法和MD5算法的替代产品，10轮循环到目前为止还没有被破解。
 * 一般多数人的意见是：它是目前可获得的最安全的加密算法。
 * AES与目前使用广泛的加密算法─DES算法的差别在于，
 * 如果一秒可以解DES，则仍需要花费1490000亿年才可破解AES，由此可知AES的安全性。
 * AES 已被列为比任何现今其它对称加密算法更安全的一种算法。
 * 2020-12-05
 */
public class AESUtil {


    public static void main(String[] args) throws Exception {
        // 加密
        String str = "2023-01-01 23:59:59";

        String reEnStr = encryptAes(str, CommonConstant.AES_KEY);
        // vGLm7x0DR8XC4vsa/ljXoAUHEsgAiW2Y5JVsvAnHXkE=
        System.out.println(reEnStr);
        String reDeStr = decryptAes(reEnStr, CommonConstant.AES_KEY);
        System.out.println(reDeStr);
    }






    public static final String algorithm = "AES";
    // AES/CBC/NOPaddin
    // AES 默认模式
    // 使用CBC模式, 在初始化Cipher对象时, 需要增加参数, 初始化向量IV : IvParameterSpec iv = new
    // IvParameterSpec(key.getBytes());
    // NOPadding: 使用NOPadding模式时, 原文长度必须是8byte的整数倍   ECB模式是可重复解密的
    public static final String transformation = "AES/ECB/NOPadding";


    /**
     * AES加密
     *
     * @param str
     *            将要加密的内容
     * @param key
     *            密钥
     * @return 已经加密的字节数组内容 再 base64 之后的字符串
     */
    public static String encryptAes(String str, String key) throws Exception {
        byte[] data = str.getBytes("UTF-8");
        byte[] keyByte = key.getBytes("UTF-8");
        //不足16字节，补齐内容为差值
        int len = 16 - data.length % 16;
        for (int i = 0; i < len; i++) {
            byte[] bytes = { (byte) len };
            data = concat(data, bytes);
        }
        try {
            SecretKeySpec skeySpec = new SecretKeySpec(keyByte, "AES");
            Cipher cipher = Cipher.getInstance(transformation);
            cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
            byte[] resultByte = cipher.doFinal(data);
            return Base64Util.encryptBASE64(resultByte);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * AES解密
     *
     * @param base64Str
     *            将要解密的字节数组内容 的 base64编码后的字符串
     * @param key
     *            密钥
     * @return 已经解密的内容
     */
    public static String decryptAes(String base64Str, String key) throws Exception {

        try {
            byte[] data = Base64Util.decryBASE64ToByteArr(base64Str);
            data = noPadding(data, -1);
            byte[] keyByte = key.getBytes("UTF-8");
            SecretKeySpec skeySpec = new SecretKeySpec(keyByte, "AES");
            Cipher cipher = Cipher.getInstance(transformation);
            cipher.init(Cipher.DECRYPT_MODE, skeySpec);
            byte[] decryptData = cipher.doFinal(data);
            int len = 2 + byteToInt(decryptData[4]) + 3;
            byte[] resultByte = noPadding(decryptData, len);
            String resultStr = new String(resultByte);
            return resultStr.trim();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 合并数组
     *
     * @param firstArray
     *            第一个数组
     * @param secondArray
     *            第二个数组
     * @return 合并后的数组
     */
    public static byte[] concat(byte[] firstArray, byte[] secondArray) {
        if (firstArray == null || secondArray == null) {
            return null;
        }
        byte[] bytes = new byte[firstArray.length + secondArray.length];
        System.arraycopy(firstArray, 0, bytes, 0, firstArray.length);
        System.arraycopy(secondArray, 0, bytes, firstArray.length,
                secondArray.length);
        return bytes;
    }




    /**
     * 去除数组中的补齐
     *
     * @param paddingBytes
     *            源数组
     * @param dataLength
     *            去除补齐后的数据长度
     * @return 去除补齐后的数组
     */
    public static byte[] noPadding(byte[] paddingBytes, int dataLength) {
        if (paddingBytes == null) {
            return null;
        }

        byte[] noPaddingBytes = null;
        if (dataLength > 0) {
            if (paddingBytes.length > dataLength) {
                noPaddingBytes = new byte[dataLength];
                System.arraycopy(paddingBytes, 0, noPaddingBytes, 0, dataLength);
            } else {
                noPaddingBytes = paddingBytes;
            }
        } else {
            int index = paddingIndex(paddingBytes);
            if (index > 0) {
                noPaddingBytes = new byte[index];
                System.arraycopy(paddingBytes, 0, noPaddingBytes, 0, index);
            }
        }

        return noPaddingBytes;
    }



    /**
     * 获取补齐的位置
     *
     * @param paddingBytes
     *            源数组
     * @return 补齐的位置
     */
    private static int paddingIndex(byte[] paddingBytes) {
        for (int i = paddingBytes.length - 1; i >= 0; i--) {
            if (paddingBytes[i] != 0) {
                return i + 1;
            }
        }
        return -1;
    }



    public static int byteToInt(byte b) {
        return (b) & 0xff;
    }






}

3、RSA

非对称加密 唯一广泛接受并实现 数据加密&数字签名 公钥加密、私钥解密 私钥加密、公钥解密

package ai.saas.framework.common.util;

import java.io.UnsupportedEncodingException;
import java.nio.charset.CharsetDecoder;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

import ai.saas.framework.common.constant.CommonConstant;
import lombok.SneakyThrows;
import org.apache.commons.codec.binary.Base64;
import sun.misc.BASE64Decoder;

/**
 * 非对称加密 唯一广泛接受并实现 数据加密&数字签名 公钥加密、私钥解密 私钥加密、公钥解密
 *
 * @author jjs
 */
public class RSAUtil {

    private static String src = "li123123LS";

    private static RSAPublicKey rsaPublicKey;
    private static RSAPrivateKey rsaPrivateKey;


    static {
        // 1、初始化密钥
        KeyPairGenerator keyPairGenerator;
        try {
            keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(1024);// 64的整倍数
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
            rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();

            System.out.println("Public Key  " + Base64.encodeBase64String(rsaPublicKey.getEncoded()));

            System.out.println("Private Key : " + Base64.encodeBase64String(rsaPrivateKey.getEncoded()));
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }


    /**
     * 私钥 解密
     *
     * @param ciphertext 密文
     */
    @SneakyThrows
    public static String privateKeyEncryption(String ciphertext) {
        // base64 解码
        //
        byte[] base64 = Base64.decodeBase64(ciphertext);
//        String priKey = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBALEXi2bqonTQqF9lWS5vOBLOcW5UCrDm8/eYxQt+Pfcdw/1eNR23GybC0NAAGBIt2KHAK2WIYFuWx+Sht5DEkS3IAsQJ3W7exTxAlqtIYJlkGAP5jas1B5MpyY/Taog3wVLfLzWODAvfbVJyviut9FscDSFrH0Cn1/khQGktZf7nAgMBAAECgYAoIfHRjPLsDi1aERm40DOg72/9VMZneK9pORHOnPll+zTjQmo/JbPdgODZgmvyErm5TleHVvSfTPhX894pzKIpoViT/dK/1W8eaJwD5r1l6pVptgm8yjHz5wcTdfB3Pu4OFgkciKKbMkinhx7GdBPcT5kyHUsJ4rLb4xvXy7RC4QJBANjJxkNcnsuWq6pzZnO+ktdRqtSoNTnTswqa0NYdXUnvkBilzFqzfzu7SZkN61picjYxE0bGdsnQGSIKfxemuD0CQQDRH6ormeGD7Z6WXyzKIW2gOrm/jcfSi61/czyGOziXRL8wULE4UyymYw8g3vhdmKjsqMxS3bt/E/cPavQXDmHzAkABdJlYKm8GfuR4KH4vmL/zoiC7fMWetcUl9RQh2+CcdndJMxPEKCBajk9YL7e8y5xosLuoZfy2Lid9CwT/a6chAkBdDCHDVKyq7sdpUN+08Dq+2GJdgNAwNkX0N2nur9r2M3h+Huk7joaHYfwRPCR2QL6ozlJbbJ1IZbHAAm6o85VRAkBQYUGoP40qE8eKUsZfTLyrOGy6FUiX8p+kJRv9RoYVa/aQDxisdo1+lwe9rhnpWkyjE3jRm3XDKScEhl6MAMnN";

        // String 转 私钥
        PrivateKey rsaPrivateKey = getPrivateKey(CommonConstant.priKey);
        //私钥解密
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] result = cipher.doFinal(base64);
        System.out.println("公钥加密，私钥解密 --解密: " + new String(result));
        return new String(result);

    }
    /**
     * 公钥加密，私钥解密
     *
     * @author jijs
     */
    @SneakyThrows
    public static void pubEn2PriDe() {

        String pubKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCxF4tm6qJ00KhfZVkubzgSznFuVAqw5vP3mMULfj33HcP9XjUdtxsmwtDQABgSLdihwCtliGBblsfkobeQxJEtyALECd1u3sU8QJarSGCZZBgD+Y2rNQeTKcmP02qIN8FS3y81jgwL321Scr4rrfRbHA0hax9Ap9f5IUBpLWX+5wIDAQAB";
        String priKey = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBALEXi2bqonTQqF9lWS5vOBLOcW5UCrDm8/eYxQt+Pfcdw/1eNR23GybC0NAAGBIt2KHAK2WIYFuWx+Sht5DEkS3IAsQJ3W7exTxAlqtIYJlkGAP5jas1B5MpyY/Taog3wVLfLzWODAvfbVJyviut9FscDSFrH0Cn1/khQGktZf7nAgMBAAECgYAoIfHRjPLsDi1aERm40DOg72/9VMZneK9pORHOnPll+zTjQmo/JbPdgODZgmvyErm5TleHVvSfTPhX894pzKIpoViT/dK/1W8eaJwD5r1l6pVptgm8yjHz5wcTdfB3Pu4OFgkciKKbMkinhx7GdBPcT5kyHUsJ4rLb4xvXy7RC4QJBANjJxkNcnsuWq6pzZnO+ktdRqtSoNTnTswqa0NYdXUnvkBilzFqzfzu7SZkN61picjYxE0bGdsnQGSIKfxemuD0CQQDRH6ormeGD7Z6WXyzKIW2gOrm/jcfSi61/czyGOziXRL8wULE4UyymYw8g3vhdmKjsqMxS3bt/E/cPavQXDmHzAkABdJlYKm8GfuR4KH4vmL/zoiC7fMWetcUl9RQh2+CcdndJMxPEKCBajk9YL7e8y5xosLuoZfy2Lid9CwT/a6chAkBdDCHDVKyq7sdpUN+08Dq+2GJdgNAwNkX0N2nur9r2M3h+Huk7joaHYfwRPCR2QL6ozlJbbJ1IZbHAAm6o85VRAkBQYUGoP40qE8eKUsZfTLyrOGy6FUiX8p+kJRv9RoYVa/aQDxisdo1+lwe9rhnpWkyjE3jRm3XDKScEhl6MAMnN";

        // String 转 公钥
        PublicKey rsaPublicKey = getPublicKey(pubKey);

        //公钥加密
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] result = cipher.doFinal(src.getBytes());
        System.out.println("公钥加密，私钥解密 --加密: " + Base64.encodeBase64String(result));

        // String 转 私钥
        PrivateKey rsaPrivateKey = getPrivateKey(priKey);

        //私钥解密
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
        keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        result = cipher.doFinal(result);
        System.out.println("公钥加密，私钥解密 --解密: " + new String(result));
    }


    /**
     * String转公钥PublicKey
     *
     * @param key
     * @return
     * @throws Exception
     */
    public static PublicKey getPublicKey(String key) throws Exception {
        byte[] keyBytes;
        keyBytes = (new BASE64Decoder()).decodeBuffer(key);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }

    /**
     * String转私钥PrivateKey
     *
     * @param key
     * @return
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(String key) throws Exception {
        byte[] keyBytes;
        keyBytes = (new BASE64Decoder()).decodeBuffer(key);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }



    /**
     * 私钥加密，公钥解密
     *
     * @author jijs
     */
    @SneakyThrows
    public static void priEn2PubDe() {

        //私钥加密
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        byte[] result = cipher.doFinal(src.getBytes());
        System.out.println("私钥加密，公钥解密 --加密 : " + Base64.encodeBase64String(result));

        //公钥解密
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
        keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
        cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        result = cipher.doFinal(result);
        System.out.println("私钥加密，公钥解密   --解密: " + new String(result));
    }

    public static void main(String[] args) {
        pubEn2PriDe();  //公钥加密，私钥解密
        priEn2PubDe();  //私钥加密，公钥解密
    }
}

4、 MD5

不可解密

// MD5加密
    public static String MD5(String inStr){

        MessageDigest md5 = null;
        byte[] hash;
        try {
            hash = MessageDigest.getInstance("MD5").digest(inStr.getBytes("UTF-8"));
        } catch (NoSuchAlgorithmException var7) {
            throw new RuntimeException("MD5 should be supported?", var7);
        } catch (UnsupportedEncodingException var8) {
            throw new RuntimeException("UTF-8 should be supported?", var8);
        }

        StringBuilder hex = new StringBuilder(hash.length * 2);
        byte[] var6 = hash;
        int var5 = hash.length;

        for(int var4 = 0; var4 < var5; ++var4) {
            byte b = var6[var4];
            if((b & 255) < 16) {
                hex.append("0");
            }

            hex.append(Integer.toHexString(b & 255));
        }
        System.out.println(hex.toString());
        return hex.toString();

    }

5、sha - 256

 MessageDigest messageDigest;

        String encodeStr = "";

        try {
            messageDigest = MessageDigest.getInstance("SHA-256");

            messageDigest.update(参数.getBytes("UTF-8"));

            encodeStr = byte2Hex(messageDigest.digest());

        } catch (Exception e) {
            System.out.println("getSHA256 is error" + e.getMessage());

        }
        System.out.println("sha256:"+encodeStr);
        return encodeStr;
    }

    private static String byte2Hex(byte[] bytes) {
        StringBuilder builder = new StringBuilder();

        String temp;

        for (int i = 0; i < bytes.length; i++) {
            temp = Integer.toHexString(bytes[i] & 0xFF);

            if (temp.length() == 1) {
                builder.append("0");

            }

            builder.append(temp);

        }

        return builder.toString();

    }