springboot+html实现对输入内容的aes加密和解密

一个简单功能，主要是备存一下代码

这功能的想法，有些文档，基于安全考虑，不能明文写上密码，所以密码要么单独存储，要么就存加密内容，但加密内容每次都要选择和去找工具解密，比较麻烦。索性，就做成url的方式。

相关链接：

「链接」

上图看看：

加密内容和生成链接地址

输入密钥

输出u结果

相关代码：



    
        
        
        
            密码本
        
    
    
        
            类型：
        
        
            
            
        
    
    
        
            输入：
        
        
            
        
    
    
        
            密钥：
        
        
            
        
    
    
        

        
        
            编码：
            
            过滤空格
            填充：
             
            
            
        
    
    
        
            跳转URL地址：
        
        
            
        
    
    
        
        
        
            
        
    
    
        
            输出：
        
        
            
        
    
    
        
            
        
    
    
        
            
        
    


<script language="JavaScript" type="text/javascript">

    function convertGoUrl() {
        let result = $.trim($("#txt_goUrl").val());
        if (result == "" || result == "~") {
            result = window.location.href;
            let pkId = webUtil.httpFn.getQueryString("id");
            let idx = result.indexOf('?');
            if (idx != -1) {
                result = result.substring(0, idx);
            }
            if (pkId != null && pkId != undefined && pkId != "") {
                result = result += "?id=" + pkId;
            }

            return result;
        }

        return result;
    }

    function buildGoUrl(ajaxData, data) {
        if (data == null || data == undefined) {
            return "";
        }
        let result = convertGoUrl();
        let paramLink = "";
        paramLink += "&action=" + escape(ajaxData.action);
        if (data != "") {
            paramLink += "&input=" + escape(data);
        }

        if (ajaxData.removeFillKey != null && ajaxData.removeFillKey != undefined) {
            switch (ajaxData.removeFillKey) {
                case "input":
                    if (ajaxData.fillPreKey != "") {
                        paramLink += "&fillPreKey=" + escape(ajaxData.fillPreKey);
                    }
                    if (ajaxData.fillPostKey != "") {
                        paramLink += "&fillPostKey=" + escape(ajaxData.fillPostKey);
                    }
                    break;
                case "yes":
                case "no":
                default:
                    break;

            }
            paramLink += "&removeFillKey=" + escape(ajaxData.removeFillKey);
        }


        paramLink += "&decodeFlag=" + (ajaxData.decodeFlag == "1" ? "0" : "1");
        if (ajaxData.charsetName != "") {
            paramLink += "&charsetName=" + escape(ajaxData.charsetName);
        }
        paramLink += "&trimFlag=" + escape(ajaxData.trimFlag);

        let idx = result.indexOf('?');
        if (idx == -1) {
            // 去除开头多余的 & 符号
            if (paramLink.startsWith("&")) {
                paramLink = paramLink.substring(1);
            }

            result += "?" + paramLink;
        } else {
            result += paramLink;
        }

        return result;
    }

    function onRemoveFillKeyChange() {
        let removeFillKey = $("#ddl_removeFillKey").val();
        let showFlag = removeFillKey == "input";
        if (showFlag) {
            $("#txt_fillPreKey").show();
            $("#txt_fillPostKey").show();
        } else {
            $("#txt_fillPreKey").hide();
            $("#txt_fillPostKey").hide();
        }
    }

    function onOkClick() {

        let ajxData = {};
        ajxData["action"] = $.trim($("#ddl_action").val());
        ajxData["fillPreKey"] = $.trim($("#txt_fillPreKey").val());
        ajxData["fillPostKey"] = $.trim($("#txt_fillPostKey").val());
        ajxData["decodeFlag"] = $.trim($("#ddl_decodeFlag").val());
        ajxData["input"] = $.trim($("#txt_input").val());
        ajxData["secretKey"] = $.trim($("#txt_secretKey").val());
        ajxData["charsetName"] = $.trim($("#ddl_charsetName").val());
        ajxData["trimFlag"] = $("#chk_trimFlag").is(':checked') ? 1 : 0;
        ajxData["removeFillKey"] = $.trim($("#ddl_removeFillKey").val());

        let ajaxUrl = serverUrl + "/ctrl/app/tool/common/appToolCommon/encode";

        $.ajax({
            cache: false,
            async: true,
            url: ajaxUrl,
            data: JSON.stringify(ajxData),
            dataType: "json",
            contentType: "application/json",
            type: "post",
            success: function (rData) {

                if (rData == null || rData == undefined) {
                    alert("系统异常");
                    return;
                }


                $("#txt_result").val(rData.data);

                let goUrl = buildGoUrl(ajxData, rData.data);
                $("#txt_url").val(goUrl);

                $("#span_execTime").html(webUtil.dateFn.showDateTimeNow());

            }
        });
    }

    function toolPageLoad() {
        let item = webUtil.httpFn.getQueryString("action", "");
        if (item != "") {
            $("#ddl_action").val(item);
        }


        // 从 URL 中获取 "decodeFlag" 参数值，如果没有则默认为空字符串
        let decodeFlag = webUtil.httpFn.getQueryString("decodeFlag", "");
        if (decodeFlag != "") {
            // 如果 "decodeFlag" 参数存在，则设置下拉框 #ddl_decodeFlag 的值
            $("#ddl_decodeFlag").val(decodeFlag);
        }

        // 从 URL 中获取 "input" 参数值，如果没有则默认为空字符串
        let input = webUtil.httpFn.getQueryString("input", "");
        if (input != "") {
            // 如果 "input" 参数存在，则设置文本区域 #txt_input 的值
            $("#txt_input").val(input);
        }


        // 从 URL 中获取 "charsetName" 参数值，如果没有则默认为空字符串
        let charsetName = webUtil.httpFn.getQueryString("charsetName", "");
        if (charsetName != "") {
            // 如果 "charsetName" 参数存在，则设置下拉框 #ddl_charsetName 的值
            $("#ddl_charsetName").val(charsetName);
        }

        // 从 URL 中获取 "trimFlag" 参数值，如果没有则默认为空字符串
        let trimFlag = webUtil.httpFn.getQueryString("trimFlag", "");
        if (trimFlag != "") {
            // 如果 "trimFlag" 为 "1"，则勾选复选框 #chk_trimFlag；否则取消勾选
            if (trimFlag === "1") {
                $("#chk_trimFlag").prop("checked", true);
            } else {
                $("#chk_trimFlag").prop("checked", false);
            }
        }

        // 从 URL 中获取 "removeFillKey" 参数值，如果没有则默认为空字符串
        let removeFillKey = webUtil.httpFn.getQueryString("removeFillKey", "");
        if (removeFillKey != "") {
            // 如果 "removeFillKey" 参数存在，则设置下拉框 #ddl_removeFillKey 的值
            $("#ddl_removeFillKey").val(removeFillKey);
            // 根据 "removeFillKey" 的值显示或隐藏自定义填充输入框
            onRemoveFillKeyChange();
        }

        // 从 URL 中获取 "fillPreKey" 参数值，如果没有则默认为空字符串
        let fillPreKey = webUtil.httpFn.getQueryString("fillPreKey", "");

        // 如果 "fillPreKey" 参数存在，则设置输入框 #txt_fillPreKey 的值
        $("#txt_fillPreKey").val(fillPreKey);


        // 从 URL 中获取 "fillPostKey" 参数值，如果没有则默认为空字符串
        let fillPostKey = webUtil.httpFn.getQueryString("fillPostKey", "");

        // 如果 "fillPostKey" 参数存在，则设置输入框 #txt_fillPostKey 的值
        $("#txt_fillPostKey").val(fillPostKey);


    }

    $(function () {
        toolPageLoad();
    });


</script>

package com.zx.app.work.app.enums.tool;


import lombok.AllArgsConstructor;
import lombok.Getter;

import java.util.LinkedHashMap;
import java.util.Map;


/**
 * 编码类型
 */
@AllArgsConstructor
@Getter
public enum EncodeActionEnum {

    MD5("md5", "", "", ""),
    BASE64("base64", "", "", ""),
    AES("aes", "", "DES@", ""),
    ENC("enc", "", "ENC(", ")"),
    UNKNOWN("unknown", "未知", "", ""),
    ;

    private final String code;
    private final String desc;
    private final String fillPreKey;
    private final String fillPostKey;


    public static EncodeActionEnum getItem(String pCode, EncodeActionEnum defaultValue) {
        if (pCode == null || pCode.isEmpty()) {
            return defaultValue;
        }
        for (EncodeActionEnum item : EncodeActionEnum.values()) {
            if (pCode.equals(item.getCode())) {
                return item;
            }
        }
        return defaultValue;
    }


    /**
     * 获得枚举的数据源Key-Value
     *
     * @return
     */
    public static Map getList() {
        Map result = new LinkedHashMap();

        for (EncodeActionEnum item : EncodeActionEnum.values()) {
            result.put(item.getCode(), item.getDesc());
        }

        return result;
    }


    protected static String toJson() {
        StringBuilder sb = new StringBuilder();
        for (EncodeActionEnum em : EncodeActionEnum.values()) {
            if(EncodeActionEnum.UNKNOWN.equals(em)){
                continue;
            }

            sb.append("");
        }

        return sb.toString();
    }

    public static void main(String[] args) {

        String str = toJson();
        System.out.println(str);

    }
}

package com.zx.app.work.app.enums.tool;


import lombok.AllArgsConstructor;
import lombok.Getter;
 


/**
 * 填充操作
 */
@AllArgsConstructor
@Getter
public enum RemoveFillKeyEnum {

    YES("yes", ""),
    NO("no", ""),
    INPUT("input", ""),
    ;

    private final String code;
    /**
     * 描述
     */
    private final String desc;


    public static RemoveFillKeyEnum getItem(String pCode, RemoveFillKeyEnum defaultValue) {
        if (pCode == null || pCode.isEmpty()) {
            return defaultValue;
        }
        for (RemoveFillKeyEnum item : RemoveFillKeyEnum.values()) {
            if (pCode.equals(item.getCode())) {
                return item;
            }
        }
        return defaultValue;
    }
 
}

package com.zx.app.work.app.svc.tool;

import com.zx.app.ba.tool.demo.EncUniUtil;
import com.zx.app.ba.tool.enums.BooleanEnum;
import com.zx.app.ba.tool.util.*;
import com.zx.app.work.app.bs.tool.LoadJenkinsConfigBs;
import com.zx.app.work.app.enums.tool.EncodeActionEnum;
import com.zx.app.work.app.enums.tool.RemoveFillKeyEnum;
import com.zx.app.work.app.item.cp.tool.LoadJenkinsConfigCp;
import com.zx.app.work.app.item.cp.tool.ToolCommonEncodeCp;
import com.zx.app.work.app.item.cr.tool.LoadJenkinsConfigCr;
import com.zx.app.work.common.constant.ConstantName;

/**
 * @author SH.YE
 */
public class AppToolCommonSvc {

    protected String getFillPreKey(ToolCommonEncodeCp cp){
        EncodeActionEnum encodeActionEnumV = EncodeActionEnum.getItem(cp.getAction(), EncodeActionEnum.UNKNOWN);
        RemoveFillKeyEnum keyEnum = RemoveFillKeyEnum.getItem(cp.getRemoveFillKey(),RemoveFillKeyEnum.NO);
        switch (keyEnum){
            case YES:
                return encodeActionEnumV.getFillPreKey();
            case INPUT:
                return StrUniUtil.strNullToEmpty(cp.getFillPreKey());
            case NO:
            default:
                return "";
        }
    }

    protected String getFillPostKey(ToolCommonEncodeCp cp){
        EncodeActionEnum encodeActionEnumV = EncodeActionEnum.getItem(cp.getAction(), EncodeActionEnum.UNKNOWN);
        RemoveFillKeyEnum keyEnum = RemoveFillKeyEnum.getItem(cp.getRemoveFillKey(),RemoveFillKeyEnum.NO);
        switch (keyEnum){
            case YES:
                return encodeActionEnumV.getFillPostKey();
            case INPUT:
                return StrUniUtil.strNullToEmpty(cp.getFillPostKey());
            case NO:
            default:
                return "";
        }
    }

    public String encode(ToolCommonEncodeCp cp) {
        EncodeActionEnum encodeActionEnumV = EncodeActionEnum.getItem(cp.getAction(), EncodeActionEnum.UNKNOWN);
        boolean trimFlag = BooleanEnum.dataIsTrue(cp.getTrimFlag());
        String input = StrUniUtil.strNullToTrimEmpty(cp.getInput(),trimFlag);
        boolean decodeFlag = BooleanEnum.dataIsTrue(cp.getDecodeFlag());
        String fillPreKey = getFillPreKey(cp);
        String fillPostKey = getFillPostKey(cp);

        if(decodeFlag) {
            input = StrUniUtil.strRemoveStartKey(input, fillPreKey);
            input = StrUniUtil.strRemoveEndKey(input, fillPostKey);
        }

        String result = null;
        switch (encodeActionEnumV) {
            case MD5:
                result = Md5Util.getMD5ByEncodingName(input, cp.getCharsetName());
                break;
            case BASE64:
                if (decodeFlag) {
                    result = Base64Util.decryptBase64(input);
                } else {
                    result = Base64Util.encryptBase64(input, cp.getCharsetName());
                    result = StrUniUtil.strNotEmptyFillKey(result,fillPreKey,fillPostKey);
                }
                break;
            case AES:
                if (decodeFlag) {
                    result = AesUtil.decode(input, cp.getSecretKey());
                } else {
                    result = AesUtil.encode(input, cp.getSecretKey(), cp.getCharsetName());
                    result = StrUniUtil.strNotEmptyFillKey(result,fillPreKey,fillPostKey);
                }
                break;
            case ENC:
                if (decodeFlag) {
                    result = EncUniUtil.decode(input, cp.getSecretKey());
                } else {
                    result = EncUniUtil.encode(input, cp.getSecretKey());
                    result = StrUniUtil.strNotEmptyFillKey(result,fillPreKey,fillPostKey);
                }
                break;
            case UNKNOWN:
            default:
                return cp.getAction() + "指令未知";
        }

        return result;
    }
}

package com.zx.app.ba.tool.demo;

import org.jasypt.util.text.BasicTextEncryptor;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;

public class EncUniUtil {

    public static String encode(String secret, String strPwd) {
        BasicTextEncryptor worker = new BasicTextEncryptor();
        // application.properties,
        // jasypt.encryptor.password 加密盐值
        worker.setPassword(strPwd);
        return worker.encrypt(secret);
    }

    public static String decode(String secret) {
        return decode(secret, UNI_KEY_PWD);
    }

    public static String decode(String secret, String strPwd) {
        BasicTextEncryptor worker = new BasicTextEncryptor();
        // application.properties,
        // jasypt.encryptor.password 加密盐值
        worker.setPassword(strPwd);
        return worker.decrypt(secret);
    }
}

package com.zx.app.ba.tool.util;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;
 
public class AesUtil {
    private static final String AES = "AES";
    private static final String SHA1PRNG = "SHA1PRNG";
    private static final String UTF8 = "UTF-8";


    /**
     * 将二进制转换成16进制
     */
    public static String parseByte2HexStr(byte[] buf) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < buf.length; ++i) {
            String hex = Integer.toHexString(buf[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 将16进制转换为二进制
     */
    public static byte[] parseHexStr2Byte(String hexStr) {
        if (hexStr == null) {
            return null;
        }

        int hexStrLen = hexStr.length();
        if (hexStrLen < 1) {
            return null;
        }

        int iLen = hexStrLen / 2;

        byte[] result = new byte[iLen];
        for (int i = 0; i < iLen; ++i) {
            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }


    public static String encode(String secret, String strPwd, String charsetName) {
        byte[] encryptResult = encrypt(secret, strPwd, charsetName);
        String encryptResultStr = parseByte2HexStr(encryptResult);
        return encryptResultStr;
    }


    public static String decode(String secret, String strPwd) {
        //解密
        byte[] decryptFrom = parseHexStr2Byte(secret);
        byte[] decryptResult = decrypt(decryptFrom, strPwd);
        return new String(decryptResult);
    }


    /**
     * 加密
     *
     * @param content     需要加密的内容
     * @param password    加密密码
     * @param charsetName 编码
     */
    private static byte[] encrypt(String content, String password, String charsetName) {
        try {
            KeyGenerator keyGen = KeyGenerator.getInstance(AES);
            SecureRandom secureRandom = SecureRandom.getInstance(SHA1PRNG);
            secureRandom.setSeed(password.getBytes());
            keyGen.init(128, secureRandom);
            SecretKey secretKey = keyGen.generateKey();
            byte[] enCodeFormat = secretKey.getEncoded();
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, AES);
            Cipher cipher = Cipher.getInstance(AES);
            if (charsetName == null || charsetName.length() == 0) {
                charsetName = UTF8;
            }
            byte[] byteContent = content.getBytes(charsetName);
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] result = cipher.doFinal(byteContent);
            return result;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 解密
     */
    private static byte[] decrypt(byte[] content, String password) {
        try {
            KeyGenerator keyGen = KeyGenerator.getInstance(AES);
            //防止linux下 随机生成key
            SecureRandom secureRandom = SecureRandom.getInstance(SHA1PRNG);
            secureRandom.setSeed(password.getBytes());
            keyGen.init(128, secureRandom);
            SecretKey secretKey = keyGen.generateKey();
            byte[] enCodeFormat = secretKey.getEncoded();
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, AES);
            Cipher cipher = Cipher.getInstance(AES);
            cipher.init(Cipher.DECRYPT_MODE, key);
            byte[] result = cipher.doFinal(content);
            return result;
        } catch (Exception e) {
            return null;
        }
    }

}

package com.zx.app.ba.tool.util;

import java.security.MessageDigest;

/**
 * MD5相关的方法
 */
public class Md5Util {

    /**
     * byte[] 数组转成Md5的字符串
     *
     * @param b
     * @return
     */
    private static String byteArrayToHexString(byte b[]) {
        StringBuffer resultSb = new StringBuffer();
        for (int i = 0; i < b.length; ++i) {
            resultSb.append(byteToHexString(b[i]));
        }

        return resultSb.toString();
    }

    /**
     * byte 转成字符串
     *
     * @param b
     * @return
     */
    private static String byteToHexString(byte b) {
        int n = b;
        if (n < 0) {
            n += 256;
        }
        int d1 = n / 16;
        int d2 = n % 16;
        return hexDigits[d1] + hexDigits[d2];
    }

    /**
     * 通过编码类型生成MD5
     *
     * @param origin      | 原字符串 | 如：Java编程
     * @param charsetName |编码类型 | 如：gb2312
     * @return
     */
    public static String getMD5ByEncodingName(String origin, String charsetName) {
        String resultString = null;
        try {
            resultString = new String(origin);
            MessageDigest md = MessageDigest.getInstance("MD5");
            if (charsetName == null || charsetName.isEmpty()) {
                resultString = byteArrayToHexString(md.digest(resultString.getBytes()));
            } else {
                resultString = byteArrayToHexString(md.digest(resultString.getBytes(charsetName)));
            }
        } catch (Exception err) {
            err.printStackTrace();
        }
        return resultString;
    }

    /**
     *
     */
    private static final String[] hexDigits = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d",
            "e", "f"};


    /**
     * 获得中文编码类型（gb2312）的MD5
     *
     * @param s 要MD5的字符串|如：Java编程
     * @return
     */
    public static String getGb2312Md5(String s) {
        return getMD5ByEncodingName(s, "gb2312");
    }


    /**
     * 获得中文编码类型（gb2312）的MD5
     *
     * @param s 要MD5的字符串|如：Java编程
     * @return
     */
    public static String getUtf8Md5(String s) {
        return getMD5ByEncodingName(s, "UTF-8");
    }

}

package com.zx.app.ba.tool.util;

import java.io.UnsupportedEncodingException;
import java.util.Base64;

/**
 * @author SH.YE
 */
public class Base64Util {

    /**
     * Base64编码
     *
     * @param str
     * @return
     */
    public static String getBase64En(String str) {
        if (str == null) {
            return "";
        }
        return Base64.getEncoder().encodeToString(str.getBytes());
    }

    /**
     * Base64解码
     *
     * @param str
     * @return
     */
    public static String getBase64De(String str) {
        if (str == null) {
            return "";
        }

        byte[] decodeBytes = Base64.getDecoder().decode(str);
        return new String(decodeBytes);
    }


    /**
     * 给字符串加密
     *
     * @param text
     * @return
     */
    public static String encryptBase64(String text) {
        if (text == null || text.isEmpty()) {
            return "";
        }
        byte[] textByte = new byte[0];
        try {
            textByte = text.getBytes("UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        String encodedText = Base64.getEncoder().encodeToString(textByte);
        return encodedText;
    }


    /**
     * 给字符串加密
     *
     * @param text
     * @return
     */
    public static String encryptBase64(String text, String charsetName) {
        if (text == null || text.isEmpty()) {
            return "";
        }
        byte[] textByte = new byte[0];
        try {
            if (charsetName == null || charsetName.isEmpty()) {
                charsetName = "utf-8";
            }
            textByte = text.getBytes(charsetName);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        String encodedText = Base64.getEncoder().encodeToString(textByte);
        return encodedText;
    }

    /**
     * 将加密后的字符串进行解密
     *
     * @param encodedText
     * @return
     */
    public static String decryptBase64(String encodedText) {
        if (encodedText == null || encodedText.isEmpty()) {
            return "";
        }

        String text = null;
        try {
            text = new String(Base64.getDecoder().decode(encodedText), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return text;
    }

    public static String encodeToString(byte[] src) {
        return Base64.getEncoder().encodeToString(src);
    }
}


    public static String strNullToTrimEmpty(String data, boolean trimFlag) {
        if (data == null) {
            return "";
        }
        if (trimFlag) {
            return data.trim();
        }
        return data;
    }

    public static String strRemoveStartKey(String data, String key) {
        if (data == null || data.isEmpty()) {
            return "";
        }

        if (key == null || key.isEmpty()) {
            return data;
        }
        if (!data.startsWith(key)) {
            return data;
        }

        if (data.equals(key)) {
            return "";
        }

        return data.substring(key.length());
    }

    public static String strRemoveEndKey(String data, String key) {
        if (data == null || data.isEmpty()) {
            return "";
        }

        if (key == null || key.isEmpty()) {
            return data;
        }
        if (!data.endsWith(key)) {
            return data;
        }

        if (data.equals(key)) {
            return "";
        }

        return data.substring(0, data.length() - key.length());
    }

    public static String strNotEmptyFillKey(String data, String preKey, String postKey) {
        if (data == null || data.isEmpty()) {
            return "";
        }

        return strNullToEmpty(preKey) + strNullToEmpty(data) + strNullToEmpty(postKey);
    }

	密码本
类型：
输入：
密钥：
	编码：过滤空格填充：
跳转URL地址：

输出：