（附示例代码）AES算法实现前端加解密&后端解密

小鱼儿 2022-11-04 11:28 394阅读 0赞

# 问题现象： #

最近在项目中需要使用加密算法，在组长的推荐下，了解了 **RSA** 和 **AES** 算法，这里先发表一下我在学习 **AES算法**的心得体会。

--------------------

# 问题分析： #

## **1.简介：** ##

### **AES** 高级加密标准(AES,Advanced Encryption Standard) ###

**AES算法**常用于**微信小程序加密**传输，是最常见的**对称加密算法（加密和解密用相同的密钥****）**之一，具体的加密流程如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjU4NTM4Ng_size_16_color_FFFFFF_t_70][]

下面简单介绍下各个部分的作用与意义：

*  明文P
    
    > 没有经过加密的数据。
 *  密钥K
    
    > 用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。密钥为接收方与发送方协商产生，但不可以直接在网络上传输，否则会导致密钥泄漏，通常是通过非对称加密算法加密密钥，然后再通过网络传输给对方，或者直接面对面商量密钥。密钥是绝对不可以泄漏的，否则会被攻击者还原密文，窃取机密数据。
 *  AES加密函数
    
    > 设AES加密函数为E，则 C = E(K, P),其中P为明文，K为密钥，C为密文。也就是说，把明文P和密钥K作为加密函数的参数输入，则加密函数E会输出密文C。
 *  密文C
    
    > 经加密函数处理后的数据
 *  AES解密函数
    
    > 设AES解密函数为D，则 P = D(K, C),其中C为密文，K为密钥，P为明文。也就是说，把密文C和密钥K作为解密函数的参数输入，则解密函数会输出明文P。

## ##

## 2.实现逻辑及其他加密算法相关参考： ##

### AES的**底层算法**就是基于**密钥长度**设置**加密轮数，**通过**轮密钥加进行逐位异或操作**等基础算法来完成**对状态矩阵**的描述，想要深入了解的小伙伴可以前往： ###

> **[https://blog.csdn.net/gulang03/article/details/81175854][https_blog.csdn.net_gulang03_article_details_81175854]**

### 其他加密算法相关参考： ###

RSA 加密算法原理简述：[https://blog.csdn.net/gulang03/article/details/81176133][https_blog.csdn.net_gulang03_article_details_81176133]

Java 实现 AES 和 RSA 算法：[https://blog.csdn.net/gulang03/article/details/81771341][https_blog.csdn.net_gulang03_article_details_81771341]

JS 与 JAVA 跨语言实现 RSA 和 AES 加密算法：[https://blog.csdn.net/gulang03/article/details/82230408][https_blog.csdn.net_gulang03_article_details_82230408]

## 3.心得体会 ##

上文看不懂的朋友也不用着急，这里我总结一下自己的学习心得，比较通俗易懂：

### **3.1.  AES算法**有 4个 关键变量： ###

> ### **1. data（明文）：需要加密的数据；** ###
> 
> ### **2. aesKey（密钥）：用于生成独特的加密规则；** ###
> 
> ### **3. IV（向量/偏移量）：辅助生成独特的加密规则（也可以不用，建议使用，可以提高安全性）；** ###
> 
> ### **4. charEncoding（字符编码格式）：设置加密所用的字符编码格式（基本上都使用 **Utf8 ，前后端都能识别**）**； ###

### **3.**2. **AES算法**有 2个 基本函数： ###

> ### **1.** encrypt**（加密**函数**）；** ###
> 
> ### **2.** decrypt**（解密**函数**）；** ###

### **3.**3. **AES算法的**加密思路： ###

> ### 1. 基于 **charEncoding（字符编码格式）规则，**把 **data（明文），aesKey（密钥）和 IV（向量/偏移量）转为 字节数组；** ###
> 
> ### 2. 基于1.中的数据，配置AES密码器规则和加密模式，构建AES密码器，利用该密码器后即可将 **明文字节数组** 加密成 **AES**字节数组； ###
> 
> ### 3. 用Base64加密算法将 2.中的**AES**字节数组 转成字符串（密文）即可； ###

### **3.**4. **AES算法的**加密思路（和加密思路差不多）： ###

> ### 1. 用Base64解密算法将 密文数据 **转为 字节数组；** ###
> 
> ### 2. 基于 charEncoding（字符编码格式）规则，把 aesKey（密钥）和 IV（向量/偏移量）转为 字节数组； ###
> 
> ### 3. 基于1.和2.中的数据，配置AES密码器规则和解密模式，构建AES密码器，利用该密码器后即可生成 data（明文）的字节码数组，再转成字符串（明文）即可； ###

## 4.实例演示 ##

上面简单介绍了**AES算法思维**，相信很多小伙伴还是一知半解，还不如**直接上代码**，理解起来会快得多：

### 4.1 首先是**前端的加密和解密算法**： ###

<!DOCTYPE html>
    <html lang="en">
    
    <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>
    
        
        <script src="./rollups/aes.js"></script>
    </head>
    
    <body>
    <script>
        //约定的 AES_KEY
        let AES_KEY = 'ABCDEFGHIJKL_key';
        //约定的 AES_IV
        let AES_IV = 'ABCDEFGHIJKLM_iv';
    
        // 加密
        function encrypt(data, key, iv) {
            // 此处 data 不用转为 Utf8 字符编码格式
            var key1 = CryptoJS.enc.Utf8.parse(key);    // key 转为 Utf8 字符编码格式的字符串对象
            var iv1 = CryptoJS.enc.Utf8.parse(iv);      // iv 转为 Utf8 字符编码格式的字符串对象
            return CryptoJS.AES.encrypt(data, key1, {   // 使用转码后的 key 和 iv 对 data 加密
                iv: iv1,
                mode: CryptoJS.mode.CBC,                //使用CBC模式创建密码器
                padding: CryptoJS.pad.Pkcs7             //使用Pkcs7偏移算法，增加加密算法的强度
            }).toString();                              //对象转为字符串格式并输出
        }
    
        // 解密
        function decrypt(data, key, iv) {
            var key1 = CryptoJS.enc.Utf8.parse(key);    // key 转为 Utf8 字符编码格式的字符串对象
            var iv1 = CryptoJS.enc.Utf8.parse(iv);      // iv 转为 Utf8 字符编码格式的字符串对象
            return CryptoJS.AES.decrypt(data, key1, {   // 使用转码后的 key 和 iv 对 data 解密
                iv: iv1,
                mode: CryptoJS.mode.CBC,                //使用CBC模式创建密码器
                padding: CryptoJS.pad.Pkcs7             //使用Pkcs7偏移算法，增加加密算法的强度
            }).toString(CryptoJS.enc.Utf8);             //使用 Utf8 字符编码格式 转为字符串并输出
        }
    
        //调用函数并打印
        let data = 'admin123456'
        let code = encrypt(data, AES_KEY, AES_IV)       //加密 明文为：'admin123456'
        console.log(code)                               //打印 密文为：'AzPbSRRVk2f7EHwbSw/reg=='
        console.log(decrypt(code, AES_KEY, AES_IV))     //解密 并打印 明文为：'admin123456'
    
    </script>
    </body>
    
    </html>

结果：

AzPbSRRVk2f7EHwbSw/reg==         //密文
    admin123456                      //明文

### 4.1 后端算法： ###

### AESUtil: ###

//package 配置文件路径
    import org.apache.commons.lang.StringUtils;
    import sun.misc.BASE64Decoder;
    
    import javax.crypto.Cipher;
    import javax.crypto.spec.IvParameterSpec;
    import javax.crypto.spec.SecretKeySpec;
    
    public class AESUtil {
    
    	/**
    	 * 判空
    	 *
    	 * @param data         原文/明文/密文
    	 * @param key          AES密钥
    	 * @param iv           IV向量
    	 * @param charEncoding 字符编码格式
    	 * @return
    	 */
    	private static String isEmpty(String data, String key, String iv, String charEncoding) {
    		if ( StringUtils.isEmpty(data) ) {
    			throw new IllegalArgumentException("'Data' must be specified and not be null!");
    		}
    		if ( StringUtils.isEmpty(key) ) {
    			throw new IllegalArgumentException("'AES Key' must be specified and not be null!");
    		}
    		if ( StringUtils.isEmpty(iv) ) {
    			throw new IllegalArgumentException("'IV' must be specified and not be null!");
    		}
    		if ( key.length() != 16 ) {
    			throw new RuntimeException("Invalid 'AES Key' length (must be 16 bytes)!");
    		}
    		if ( StringUtils.isEmpty(data) && iv.length() != 16 ) {
    			throw new RuntimeException("Invalid 'IV' length (must be 16 bytes)!");
    		}
    		if ( iv.length() != 16 ) {
    			throw new RuntimeException("Invalid 'IV' length (must be 16 bytes)!");
    		}
    		if ( StringUtils.isEmpty(charEncoding) ) {
    			charEncoding = VariableConfigure.UTF8_CHAR_ENCODING;
    		}
    		return charEncoding;
    	}
    
    	/**
    	 * AES加密
    	 *
    	 * @param data         原文/明文
    	 * @param key          AES密钥
    	 * @param iv           IV向量
    	 * @param charEncoding 字符编码格式
    	 * @return 返回密文字符串
    	 */
    	public static String encrypt(String data, String key, String iv, String charEncoding) {
    		charEncoding = isEmpty(data, key, iv, charEncoding);
    		try {
    			byte[] dataByte = data.getBytes(charEncoding);//转为utf8字节数组
    			byte[] keyByte = key.getBytes(charEncoding);//转为utf8字节数组
    			byte[] ivByte = iv.getBytes(charEncoding);//转为utf8字节数组
    			Cipher cipher = Cipher.getInstance(VariableConfigure.AES_ALGORITHM);// 使用CBC模式创建密码器
    			IvParameterSpec ivParameterSpec = new IvParameterSpec(ivByte);//创建向量/偏移量iv，增加加密算法的强度
    			cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(keyByte, "AES"), ivParameterSpec);// 配置加密模式并初始化
    			byte[] valueByte = cipher.doFinal(dataByte); // 密码器加密数据
    			return new String(Base64.encode(valueByte)); // Base64加密并转成字符串
    		} catch (Exception e) {
    			e.printStackTrace();
    			throw new RuntimeException("Encrypt Fail!", e);
    		}
    	}
    
    	/**
    	 * AES解密
    	 *
    	 * @param encryptCode
    	 * @param key
    	 * @param iv
    	 * @param charEncoding
    	 * @return
    	 */
    	public static String decrypt(String encryptCode, String key, String iv, String charEncoding) {
    		charEncoding = isEmpty(encryptCode, key, iv, charEncoding);
    		try {
    			byte[] encryptCodeByte = new BASE64Decoder().decodeBuffer(encryptCode);//对密文进行Base64解密
    			byte[] keyByte = key.getBytes(charEncoding);//转为utf8字节数组
    			byte[] ivByte = iv.getBytes(charEncoding);//转为utf8字节数组
    			Cipher cipher = Cipher.getInstance(VariableConfigure.AES_ALGORITHM);// 使用CBC模式创建密码器
    			IvParameterSpec ivParameterSpec = new IvParameterSpec(ivByte);//创建向量/偏移量iv，增加加密算法的强度
    			cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(keyByte, "AES"), ivParameterSpec);// 配置加密模式并初始化
    			byte[] decryptBytes = cipher.doFinal(encryptCodeByte);// 密码器解密数据
    			return new String(decryptBytes);// 转为字符串
    		} catch (Exception e) {
    			e.printStackTrace();
    			throw new RuntimeException("Decrypt Fail!", e);
    		}
    	}
    
    	//测试
    	public static void main(String[] args) throws Exception {
    		String data = "admin123456";
    		String key = "ABCDEFGHIJKL_key";
    		String iv = "ABCDEFGHIJKLM_iv";
    
    		String encryptCode = encrypt(data, key, iv, null);
    		System.out.println("密文： " + encryptCode);
    
    		String decryptCode = decrypt(encryptCode, key, iv, null);
    		System.out.println("明文： " + decryptCode);
    	}
    }

### Base64（Base64工具类）: ###

//package 配置文件路径
    
    import java.io.UnsupportedEncodingException;
    
    public class Base64 {
        /**
         * Chunk size per RFC 2045 section 6.8.
         *
         * <p>The {@value} character limit does not count the trailing CRLF, but counts
         * all other characters, including any equal signs.</p>
         *
         * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section 6.8</a>
         */
        static final int CHUNK_SIZE = 76;
    
        /**
         * Chunk separator per RFC 2045 section 2.1.
         *
         * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section 2.1</a>
         */
        static final byte[] CHUNK_SEPARATOR = "\r\n".getBytes();
    
        /**
         * The base length.
         */
        static final int BASELENGTH = 255;
    
        /**
         * Lookup length.
         */
        static final int LOOKUPLENGTH = 64;
    
        /**
         * Used to calculate the number of bits in a byte.
         */
        static final int EIGHTBIT = 8;
    
        /**
         * Used when encoding something which has fewer than 24 bits.
         */
        static final int SIXTEENBIT = 16;
    
        /**
         * Used to determine how many bits data contains.
         */
        static final int TWENTYFOURBITGROUP = 24;
    
        /**
         * Used to get the number of Quadruples.
         */
        static final int FOURBYTE = 4;
    
        /**
         * Used to test the sign of a byte.
         */
        static final int SIGN = -128;
    
        /**
         * Byte used to pad output.
         */
        static final byte PAD = (byte) '=';
    
        // Create arrays to hold the base64 characters and a
        // lookup for base64 chars
        private static byte[] base64Alphabet = new byte[BASELENGTH];
        private static byte[] lookUpBase64Alphabet = new byte[LOOKUPLENGTH];
    
        // Populating the lookup and character arrays
        static {
            for (int i = 0; i < BASELENGTH; i++) {
                base64Alphabet[i] = (byte) -1;
            }
            for (int i = 'Z'; i >= 'A'; i--) {
                base64Alphabet[i] = (byte) (i - 'A');
            }
            for (int i = 'z'; i >= 'a'; i--) {
                base64Alphabet[i] = (byte) (i - 'a' + 26);
            }
            for (int i = '9'; i >= '0'; i--) {
                base64Alphabet[i] = (byte) (i - '0' + 52);
            }
    
            base64Alphabet['+'] = 62;
            base64Alphabet['/'] = 63;
    
            for (int i = 0; i <= 25; i++) {
                lookUpBase64Alphabet[i] = (byte) ('A' + i);
            }
    
            for (int i = 26, j = 0; i <= 51; i++, j++) {
                lookUpBase64Alphabet[i] = (byte) ('a' + j);
            }
    
            for (int i = 52, j = 0; i <= 61; i++, j++) {
                lookUpBase64Alphabet[i] = (byte) ('0' + j);
            }
    
            lookUpBase64Alphabet[62] = (byte) '+';
            lookUpBase64Alphabet[63] = (byte) '/';
        }
    
        private static boolean isBase64(byte octect) {
            if (octect == PAD) {
                return true;
            } else if (base64Alphabet[octect] == -1) {
                return false;
            } else {
                return true;
            }
        }
    
        /**
         * Tests a given byte array to see if it contains
         * only valid characters within the Base64 alphabet.
         *
         * @param arrayOctect byte array to test
         * @return true if all bytes are valid characters in the Base64
         *         alphabet or if the byte array is empty; false, otherwise
         */
        public static boolean isArrayByteBase64(byte[] arrayOctect) {
    
            arrayOctect = discardWhitespace(arrayOctect);
    
            int length = arrayOctect.length;
            if (length == 0) {
                // shouldn't a 0 length array be valid base64 data?
                // return false;
                return true;
            }
            for (int i = 0; i < length; i++) {
                if (!isBase64(arrayOctect[i])) {
                    return false;
                }
            }
            return true;
        }
    
        /**
         * Encodes binary data using the base64 algorithm but
         * does not chunk the output.
         *
         * @param binaryData binary data to encode
         * @return Base64 characters
         */
        public static byte[] encodeBase64(byte[] binaryData) {
            return encodeBase64(binaryData, false);
        }
    
        /**
         * Encodes binary data using the base64 algorithm and chunks
         * the encoded output into 76 character blocks
         *
         * @param binaryData binary data to encode
         * @return Base64 characters chunked in 76 character blocks
         */
        public static byte[] encodeBase64Chunked(byte[] binaryData) {
            return encodeBase64(binaryData, true);
        }
    
        /**
         * Decodes a byte[] containing containing
         * characters in the Base64 alphabet.
         *
         * @param pArray A byte array containing Base64 character data
         * @return a byte array containing binary data
         */
        public static byte[] decode(byte[] pArray) {
            return decodeBase64(pArray);
        }
    
        /**
         * Encodes binary data using the base64 algorithm, optionally
         * chunking the output into 76 character blocks.
         *
         * @param binaryData Array containing binary data to encode.
         * @param isChunked if isChunked is true this encoder will chunk
         *                  the base64 output into 76 character blocks
         * @return Base64-encoded data.
         */
        public static byte[] encodeBase64(byte[] binaryData, boolean isChunked) {
            int lengthDataBits = binaryData.length * EIGHTBIT;
            int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
            int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
            byte encodedData[] = null;
            int encodedDataLength = 0;
            int nbrChunks = 0;
    
            if (fewerThan24bits != 0) {
                //data not divisible by 24 bit
                encodedDataLength = (numberTriplets + 1) * 4;
            } else {
                // 16 or 8 bit
                encodedDataLength = numberTriplets * 4;
            }
    
            // If the output is to be "chunked" into 76 character sections,
            // for compliance with RFC 2045 MIME, then it is important to
            // allow for extra length to account for the separator(s)
            if (isChunked) {
    
                nbrChunks =
                    (CHUNK_SEPARATOR.length == 0 ? 0 : (int) Math.ceil((float) encodedDataLength / CHUNK_SIZE));
                encodedDataLength += nbrChunks * CHUNK_SEPARATOR.length;
            }
    
            encodedData = new byte[encodedDataLength];
    
            byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
    
            int encodedIndex = 0;
            int dataIndex = 0;
            int i = 0;
            int nextSeparatorIndex = CHUNK_SIZE;
            int chunksSoFar = 0;
    
            //log.debug("number of triplets = " + numberTriplets);
            for (i = 0; i < numberTriplets; i++) {
                dataIndex = i * 3;
                b1 = binaryData[dataIndex];
                b2 = binaryData[dataIndex + 1];
                b3 = binaryData[dataIndex + 2];
    
                //log.debug("b1= " + b1 +", b2= " + b2 + ", b3= " + b3);
    
                l = (byte) (b2 & 0x0f);
                k = (byte) (b1 & 0x03);
    
                byte val1 =
                    ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
                byte val2 =
                    ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
                byte val3 =
                    ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);
    
                encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
                //log.debug( "val2 = " + val2 );
                //log.debug( "k4   = " + (k<<4) );
                //log.debug(  "vak  = " + (val2 | (k<<4)) );
                encodedData[encodedIndex + 1] =
                    lookUpBase64Alphabet[val2 | (k << 4)];
                encodedData[encodedIndex + 2] =
                    lookUpBase64Alphabet[(l << 2) | val3];
                encodedData[encodedIndex + 3] = lookUpBase64Alphabet[b3 & 0x3f];
    
                encodedIndex += 4;
    
                // If we are chunking, let's put a chunk separator down.
                if (isChunked) {
                    // this assumes that CHUNK_SIZE % 4 == 0
                    if (encodedIndex == nextSeparatorIndex) {
                        System.arraycopy(
                            CHUNK_SEPARATOR,
                            0,
                            encodedData,
                            encodedIndex,
                            CHUNK_SEPARATOR.length);
                        chunksSoFar++;
                        nextSeparatorIndex =
                            (CHUNK_SIZE * (chunksSoFar + 1)) +
                            (chunksSoFar * CHUNK_SEPARATOR.length);
                        encodedIndex += CHUNK_SEPARATOR.length;
                    }
                }
            }
    
            // form integral number of 6-bit groups
            dataIndex = i * 3;
    
            if (fewerThan24bits == EIGHTBIT) {
                b1 = binaryData[dataIndex];
                k = (byte) (b1 & 0x03);
                //log.debug("b1=" + b1);
                //log.debug("b1<<2 = " + (b1>>2) );
                byte val1 =
                    ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
                encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
                encodedData[encodedIndex + 1] = lookUpBase64Alphabet[k << 4];
                encodedData[encodedIndex + 2] = PAD;
                encodedData[encodedIndex + 3] = PAD;
            } else if (fewerThan24bits == SIXTEENBIT) {
    
                b1 = binaryData[dataIndex];
                b2 = binaryData[dataIndex + 1];
                l = (byte) (b2 & 0x0f);
                k = (byte) (b1 & 0x03);
    
                byte val1 =
                    ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
                byte val2 =
                    ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
    
                encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
                encodedData[encodedIndex + 1] =
                    lookUpBase64Alphabet[val2 | (k << 4)];
                encodedData[encodedIndex + 2] = lookUpBase64Alphabet[l << 2];
                encodedData[encodedIndex + 3] = PAD;
            }
    
            if (isChunked) {
                // we also add a separator to the end of the final chunk.
                if (chunksSoFar < nbrChunks) {
                    System.arraycopy(
                        CHUNK_SEPARATOR,
                        0,
                        encodedData,
                        encodedDataLength - CHUNK_SEPARATOR.length,
                        CHUNK_SEPARATOR.length);
                }
            }
    
            return encodedData;
        }
    
        /**
         * Decodes Base64 data into octects
         *
         * @param base64Data Byte array containing Base64 data
         * @return Array containing decoded data.
         */
        public static byte[] decodeBase64(byte[] base64Data) {
            // RFC 2045 requires that we discard ALL non-Base64 characters
            base64Data = discardNonBase64(base64Data);
    
            // handle the edge case, so we don't have to worry about it later
            if (base64Data.length == 0) {
                return new byte[0];
            }
    
            int numberQuadruple = base64Data.length / FOURBYTE;
            byte decodedData[] = null;
            byte b1 = 0, b2 = 0, b3 = 0, b4 = 0, marker0 = 0, marker1 = 0;
    
            // Throw away anything not in base64Data
    
            int encodedIndex = 0;
            int dataIndex = 0;
            {
                // this sizes the output array properly - rlw
                int lastData = base64Data.length;
                // ignore the '=' padding
                while (base64Data[lastData - 1] == PAD) {
                    if (--lastData == 0) {
                        return new byte[0];
                    }
                }
                decodedData = new byte[lastData - numberQuadruple];
            }
    
            for (int i = 0; i < numberQuadruple; i++) {
                dataIndex = i * 4;
                marker0 = base64Data[dataIndex + 2];
                marker1 = base64Data[dataIndex + 3];
    
                b1 = base64Alphabet[base64Data[dataIndex]];
                b2 = base64Alphabet[base64Data[dataIndex + 1]];
    
                if (marker0 != PAD && marker1 != PAD) {
                    //No PAD e.g 3cQl
                    b3 = base64Alphabet[marker0];
                    b4 = base64Alphabet[marker1];
    
                    decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
                    decodedData[encodedIndex + 1] =
                        (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
                    decodedData[encodedIndex + 2] = (byte) (b3 << 6 | b4);
                } else if (marker0 == PAD) {
                    //Two PAD e.g. 3c[Pad][Pad]
                    decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
                } else if (marker1 == PAD) {
                    //One PAD e.g. 3cQ[Pad]
                    b3 = base64Alphabet[marker0];
    
                    decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
                    decodedData[encodedIndex + 1] =
                        (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
                }
                encodedIndex += 3;
            }
            return decodedData;
        }
    
        /**
         * Discards any whitespace from a base-64 encoded block.
         *
         * @param data The base-64 encoded data to discard the whitespace
         * from.
         * @return The data, less whitespace (see RFC 2045).
         */
        static byte[] discardWhitespace(byte[] data) {
            byte groomedData[] = new byte[data.length];
            int bytesCopied = 0;
    
            for (int i = 0; i < data.length; i++) {
                switch (data[i]) {
                case (byte) ' ' :
                case (byte) '\n' :
                case (byte) '\r' :
                case (byte) '\t' :
                        break;
                default:
                        groomedData[bytesCopied++] = data[i];
                }
            }
    
            byte packedData[] = new byte[bytesCopied];
    
            System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);
    
            return packedData;
        }
    
        /**
         * Discards any characters outside of the base64 alphabet, per
         * the requirements on page 25 of RFC 2045 - "Any characters
         * outside of the base64 alphabet are to be ignored in base64
         * encoded data."
         *
         * @param data The base-64 encoded data to groom
         * @return The data, less non-base64 characters (see RFC 2045).
         */
        static byte[] discardNonBase64(byte[] data) {
            byte groomedData[] = new byte[data.length];
            int bytesCopied = 0;
    
            for (int i = 0; i < data.length; i++) {
                if (isBase64(data[i])) {
                    groomedData[bytesCopied++] = data[i];
                }
            }
    
            byte packedData[] = new byte[bytesCopied];
    
            System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);
    
            return packedData;
        }
    
        /**
         * Encodes a byte[] containing binary data, into a byte[] containing
         * characters in the Base64 alphabet.
         *
         * @param pArray a byte array containing binary data
         * @return A byte array containing only Base64 character data
         */
        public static byte[] encode(byte[] pArray) {
            return encodeBase64(pArray, false);
        }
    
        public static String encode(String str) throws UnsupportedEncodingException
         {
             String baseStr = new String(encode(str.getBytes("UTF-8")));
             String tempStr = Digest.digest(str).toUpperCase();
             String result = tempStr+baseStr;
             return new String(encode(result.getBytes("UTF-8")));
         }
    
         public static String decode(String cryptoStr) throws
           UnsupportedEncodingException {
           if(cryptoStr.length()<40)
             return "";
           try
           {
             String tempStr = new String(decode(cryptoStr.getBytes("UTF-8")));
             String result = tempStr.substring(40, tempStr.length());
             return new String(decode(result.getBytes("UTF-8")));
           }
           catch(ArrayIndexOutOfBoundsException ex)
           {
             return "";
           }
         }
         
         /**
          * Decodes Base64 data into octects
          *
          * @param encoded string containing Base64 data
          * @return Array containind decoded data.
          */
         public static byte[] decode2(String encoded) {
    
             if (encoded == null) {
                 return null;
             }
    
             char[] base64Data = encoded.toCharArray();
             // remove white spaces
             int len = removeWhiteSpace(base64Data);
    
             if (len % FOURBYTE != 0) {
                 return null;//should be divisible by four
             }
    
             int numberQuadruple = (len / FOURBYTE);
    
             if (numberQuadruple == 0) {
                 return new byte[0];
             }
    
             byte decodedData[] = null;
             byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
             char d1 = 0, d2 = 0, d3 = 0, d4 = 0;
    
             int i = 0;
             int encodedIndex = 0;
             int dataIndex = 0;
             decodedData = new byte[(numberQuadruple) * 3];
    
             for (; i < numberQuadruple - 1; i++) {
    
                 if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))
                     || !isData((d3 = base64Data[dataIndex++]))
                     || !isData((d4 = base64Data[dataIndex++]))) {
                     return null;
                 }//if found "no data" just return null
    
                 b1 = base64Alphabet[d1];
                 b2 = base64Alphabet[d2];
                 b3 = base64Alphabet[d3];
                 b4 = base64Alphabet[d4];
    
                 decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
                 decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
                 decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
             }
    
             if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {
                 return null;//if found "no data" just return null
             }
    
             b1 = base64Alphabet[d1];
             b2 = base64Alphabet[d2];
    
             d3 = base64Data[dataIndex++];
             d4 = base64Data[dataIndex++];
             if (!isData((d3)) || !isData((d4))) {//Check if they are PAD characters
                 if (isPad(d3) && isPad(d4)) {
                     if ((b2 & 0xf) != 0)//last 4 bits should be zero
                     {
                         return null;
                     }
                     byte[] tmp = new byte[i * 3 + 1];
                     System.arraycopy(decodedData, 0, tmp, 0, i * 3);
                     tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
                     return tmp;
                 } else if (!isPad(d3) && isPad(d4)) {
                     b3 = base64Alphabet[d3];
                     if ((b3 & 0x3) != 0)//last 2 bits should be zero
                     {
                         return null;
                     }
                     byte[] tmp = new byte[i * 3 + 2];
                     System.arraycopy(decodedData, 0, tmp, 0, i * 3);
                     tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
                     tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
                     return tmp;
                 } else {
                     return null;
                 }
             } else { //No PAD e.g 3cQl
                 b3 = base64Alphabet[d3];
                 b4 = base64Alphabet[d4];
                 decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
                 decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
                 decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
    
             }
    
             return decodedData;
         }
         
         private static boolean isWhiteSpace(char octect) {
             return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
         }     
         
         private static boolean isData(char octect) {
             return (octect < BASELENGTH && base64Alphabet[octect] != -1);
         }
         
         private static boolean isPad(char octect) {
             return (octect == PAD);
         }
         
         /**
          * remove WhiteSpace from MIME containing encoded Base64 data.
          *
          * @param data  the byte array of base64 data (with WS)
          * @return      the new length
          */
         private static int removeWhiteSpace(char[] data) {
             if (data == null) {
                 return 0;
             }
    
             // count characters that's not whitespace
             int newSize = 0;
             int len = data.length;
             for (int i = 0; i < len; i++) {
                 if (!isWhiteSpace(data[i])) {
                     data[newSize++] = data[i];
                 }
             }
             return newSize;
         } 
    }

### ConvertUtils（公式转换工具类）： ###

//package 配置文件路径
    
    import java.io.UnsupportedEncodingException;
    import java.sql.Date;
    import java.sql.Time;
    import java.sql.Timestamp;
    import java.text.DecimalFormat;
    import java.util.Calendar;
    import java.util.GregorianCalendar;
    import java.util.Locale;
    import java.util.TimeZone;
    
    public abstract class ConvertUtils {
    
        private static final DecimalFormat simpleFormat = new DecimalFormat("####");
    
        public static final boolean objectToBoolean(Object o){
            return o != null ? Boolean.valueOf(o.toString()).booleanValue() : false;
        }
    
        public static final int objectToInt(Object o){
            if(o instanceof Number)
                return ((Number)o).intValue();
            try{
                if(o == null)
                    return -1;
                else
                    return Integer.parseInt(o.toString());
            }catch(NumberFormatException e){
                return -1;
            }
        }
    
        public static final short objectToShort(Object o){
            if(o instanceof Number)
                return ((Number)o).shortValue();
            try{
                if(o == null)
                    return -1;
                else
                    return Short.parseShort(o.toString());
            }catch(NumberFormatException e){
                return -1;
            }
        }
    
        public static final double objectToDouble(Object o){
            if(o instanceof Number)
                return ((Number)o).doubleValue();
            try{
                if(o == null)
                    return -1D;
                else
                    return Double.parseDouble(o.toString());
            }catch(NumberFormatException e){
                return -1D;
            }
        }
    
        public static final long objectToLong(Object o)
        {
            if(o instanceof Number)
                return ((Number)o).longValue();
            try{
                if(o == null)
                    return -1L;
                else
                    return Long.parseLong(o.toString());
            }catch(NumberFormatException e){
                return -1L;
            }
        }
    
        public static final String objectToString(Object obj, DecimalFormat fmt)
        {
            fmt.setDecimalSeparatorAlwaysShown(false);
            if(obj instanceof Double)
                return fmt.format(((Double)obj).doubleValue());
            if(obj instanceof Long)
                return fmt.format(((Long)obj).longValue());
            else
                return obj.toString();
        }
    
        public static final Object getObjectValue(String value)
        {
            try{
                return Long.valueOf(value);
            }catch(NumberFormatException e) {}
    
            try{
                return Double.valueOf(value);
            }catch(NumberFormatException e){
                return value;
            }
        }
    
        public static String longToSimpleString(long value){
            return simpleFormat.format(value);
        }
    
        public static String asHex(byte hash[]){
            return toHex(hash);
        }
    
        public static String toHex(byte input[]){
            if(input == null)
                return null;
            StringBuffer output = new StringBuffer(input.length * 2);
            for(int i = 0; i < input.length; i++){
                int current = input[i] & 0xff;
                if(current < 16)
                    output.append("0");
                output.append(Integer.toString(current, 16));
            }
    
            return output.toString();
        }
    
        public static byte[] fromHex(String input){
            if(input == null)
                return null;
            byte output[] = new byte[input.length() / 2];
            for(int i = 0; i < output.length; i++)
                output[i] = (byte)Integer.parseInt(input.substring(i * 2, (i + 1) * 2), 16);
    
            return output;
        }
    
        public static String stringToHexString(String input, String encoding)
            throws UnsupportedEncodingException{
            return input != null ? toHex(input.getBytes(encoding)) : null;
        }
    
        public static String stringToHexString(String input){
            try{
                return stringToHexString(input, "UTF-8");
            }catch(UnsupportedEncodingException e){
                throw new IllegalStateException("UTF-8 encoding is not supported by JVM");
            }
        }
    
        public static String hexStringToString(String input, String encoding)
            throws UnsupportedEncodingException{
            return input != null ? new String(fromHex(input), encoding) : null;
        }
    
        public static String hexStringToString(String input){
            try{
                return hexStringToString(input, "UTF-8");
            }catch(UnsupportedEncodingException e){
                throw new IllegalStateException("UTF-8 encoding is not supported by JVM");
            }
        }
    
        public static String timeZoneToCode(TimeZone tz){
    
            return timeZoneToString(tz);
        }
    
        public static TimeZone codeToTimeZone(String tzString){
    
            return stringToTimeZone(tzString);
        }
    
        public static String timeZoneToString(TimeZone tz){
    
            return tz != null ? tz.getID() : "";
        }
    
        public static TimeZone stringToTimeZone(String tzString){
    
            return TimeZone.getTimeZone(tzString != null ? tzString : "");
        }
    
        public static String localeToCode(Locale aLocale){
    
            return localeToString(aLocale);
        }
    
        public static Locale codeToLocale(String locString){
    
            return stringToLocale(locString);
        }
    
        public static String localeToString(Locale loc){
    
            return loc != null ? loc.toString() : "";
        }
    
        public static Locale stringToLocale(String locString){
    
            locString = locString != null ? locString.trim() : "";
            if(locString.equals(""))
                return new Locale("", "", "");
            int pos = locString.indexOf(95);
            if(pos == -1)
                return new Locale(locString, "", "");
            String language = locString.substring(0, pos);
            locString = locString.substring(pos + 1);
            pos = locString.indexOf(95);
            if(pos == -1){
                return new Locale(language, locString, "");
            }else{
                String country = locString.substring(0, pos);
                locString = locString.substring(pos + 1);
                return new Locale(language, country, locString);
            }
        }
    
        public static Date dateToSQLDate(java.util.Date d){
    
            return d != null ? new Date(d.getTime()) : null;
        }
    
        public static Time dateToSQLTime(java.util.Date d){
    
            return d != null ? new Time(d.getTime()) : null;
        }
    
        public static Timestamp dateToSQLTimestamp(java.util.Date d){
    
            return d != null ? new Timestamp(d.getTime()) : null;
        }
    
        public static java.util.Date sqlTimestampToDate(Timestamp t){
    
            return t != null ? new java.util.Date(Math.round((double)t.getTime() + (double)t.getNanos() / 1000000D)) : null;
        }
    
        public static Timestamp getCurrentDate(){
    
            Calendar c = Calendar.getInstance();
            c.set(c.get(1), c.get(2), c.get(5), 0, 0, 0);
            Timestamp t = new Timestamp(c.getTime().getTime());
            t.setNanos(0);
            return t;
        }
    
        public static java.util.Date getDate(int y, int m, int d, boolean inclusive)
        {
            java.util.Date dt = null;
            Calendar c = Calendar.getInstance();
            c.clear();
            if(c.getActualMinimum(1) <= y && y <= c.getActualMaximum(1))
            {
                c.set(1, y);
                if(c.getActualMinimum(2) <= m && m <= c.getActualMaximum(2))
                {
                    c.set(2, m);
                    if(c.getActualMinimum(5) <= d && d <= c.getActualMaximum(5))
                        c.set(5, d);
                }
                if(inclusive)
                {
                    c.add(5, 1);
                    c.add(14, -1);
                }
                dt = c.getTime();
            }
            return dt;
        }
    
        public static java.util.Date getDateStart(java.util.Date d)
        {
    
             Calendar c = new GregorianCalendar();
             c.clear();
             Calendar co = new GregorianCalendar();
             co.setTime(d);
             c.set(Calendar.DAY_OF_MONTH,co.get(Calendar.DAY_OF_MONTH));
             c.set(Calendar.MONTH,co.get(Calendar.MONTH));
             c.set(Calendar.YEAR,co.get(Calendar.YEAR));
             //c.add(Calendar.DAY_OF_MONTH,1);
             //c.add(Calendar.MILLISECOND,-1);
             return c.getTime();
        }
    
        public static java.util.Date getDateEnd(java.util.Date d)
        {
             Calendar c = Calendar.getInstance();
             c.clear();
             Calendar co = Calendar.getInstance();
             co.setTime(d);
             c.set(Calendar.DAY_OF_MONTH,co.get(Calendar.DAY_OF_MONTH));
             c.set(Calendar.MONTH,co.get(Calendar.MONTH));
             c.set(Calendar.YEAR,co.get(Calendar.YEAR));
             c.add(Calendar.DAY_OF_MONTH,1);
             c.add(Calendar.MILLISECOND,-1);
             return c.getTime();
        }
    
        public static double roundNumber(double rowNumber, int roundingPoint)
        {
            double base = Math.pow(10D, roundingPoint);
            return (double)Math.round(rowNumber * base) / base;
        }
        public static Object getObject(String type,String value) throws Exception{
    
        	type=type.toLowerCase();
        	if("boolean".equals(type))
                return Boolean.valueOf(value);
            if("byte".equals(type))
                return Byte.valueOf(value);
            if("short".equals(type))
                return Short.valueOf(value);
            if("char".equals(type))
                if(value.length() != 1)
                    throw new NumberFormatException("Argument is not a character!");
                else
                    return Character.valueOf(value.toCharArray()[0]);
            if("int".equals(type))
                return Integer.valueOf(value);
            if("long".equals(type))
                return Long.valueOf(value);
            if("float".equals(type))
                return Float.valueOf(value);
            if("double".equals(type))
                return Double.valueOf(value);
            if("string".equals(type))
                return value;
    		else{
    	        Object objs[]=new String[]{value};
    			return Class.forName(type).getConstructor(new Class[] {
    				    String.class
    				}).newInstance(objs);
    		}
        }
        private ConvertUtils(){}
    
    //    public static void main(String[] args)
    //    {
    //    	System.out.println(getDateStart(new java.util.Date()));
    //    }
    }

### Digest（摘要工具类）： ###

//package 配置文件路径
    
    import org.bouncycastle.jcajce.provider.asymmetric.RSA;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.UnsupportedEncodingException;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.util.Arrays;
    
    public class Digest {
    	private final static Logger log = LoggerFactory.getLogger(RSA.class);
    
    	public static final String ENCODE = "UTF-8";
    
    	public static String signMD5(String aValue, String encoding) {
    		try {
    			byte[] input = aValue.getBytes(encoding);
    			MessageDigest md = MessageDigest.getInstance("MD5");
    			return ConvertUtils.toHex(md.digest(input));
    		} catch (NoSuchAlgorithmException e) {
    			log.error(e.getMessage(), e);
    			return null;
    		} catch (UnsupportedEncodingException e) {
    			log.error(e.getMessage(), e);
    			return null;
    		}
    	}
    
    	public static String hmacSign(String aValue) {
    		try {
    			byte[] input = aValue.getBytes();
    			MessageDigest md = MessageDigest.getInstance("MD5");
    			return ConvertUtils.toHex(md.digest(input));
    		} catch (NoSuchAlgorithmException e) {
    			log.error(e.getMessage(), e);
    			return null;
    		}
    	}
    
    	public static String hmacSign(String aValue, String aKey) {
    		return hmacSign(aValue, aKey, ENCODE);
    	}
    
    	public static String hmacSign(String aValue, String aKey, String encoding) {
    		byte k_ipad[] = new byte[64];
    		byte k_opad[] = new byte[64];
    		byte keyb[];
    		byte value[];
    		try {
    			keyb = aKey.getBytes(encoding);
    			value = aValue.getBytes(encoding);
    		} catch (UnsupportedEncodingException e) {
    			keyb = aKey.getBytes();
    			value = aValue.getBytes();
    		}
    		Arrays.fill(k_ipad, keyb.length, 64, (byte)54);
    		Arrays.fill(k_opad, keyb.length, 64, (byte)92);
    		for ( int i = 0; i < keyb.length; i++ ) {
    			k_ipad[i] = (byte)(keyb[i] ^ 0x36);
    			k_opad[i] = (byte)(keyb[i] ^ 0x5c);
    		}
    
    		MessageDigest md = null;
    		try {
    			md = MessageDigest.getInstance("MD5");
    		} catch (NoSuchAlgorithmException e) {
    			log.error(e.getMessage(), e);
    			return null;
    		}
    		md.update(k_ipad);
    		md.update(value);
    		byte dg[] = md.digest();
    		md.reset();
    		md.update(k_opad);
    		md.update(dg, 0, 16);
    		dg = md.digest();
    		return ConvertUtils.toHex(dg);
    	}
    
    	public static String hmacSHASign(String aValue, String aKey, String encoding) {
    		byte k_ipad[] = new byte[64];
    		byte k_opad[] = new byte[64];
    		byte keyb[];
    		byte value[];
    		try {
    			keyb = aKey.getBytes(encoding);
    			value = aValue.getBytes(encoding);
    		} catch (UnsupportedEncodingException e) {
    			keyb = aKey.getBytes();
    			value = aValue.getBytes();
    		}
    		Arrays.fill(k_ipad, keyb.length, 64, (byte)54);
    		Arrays.fill(k_opad, keyb.length, 64, (byte)92);
    		for ( int i = 0; i < keyb.length; i++ ) {
    			k_ipad[i] = (byte)(keyb[i] ^ 0x36);
    			k_opad[i] = (byte)(keyb[i] ^ 0x5c);
    		}
    
    		MessageDigest md = null;
    		try {
    			md = MessageDigest.getInstance("SHA");
    		} catch (NoSuchAlgorithmException e) {
    			log.error(e.getMessage(), e);
    			return null;
    		}
    		md.update(k_ipad);
    		md.update(value);
    		byte dg[] = md.digest();
    		md.reset();
    		md.update(k_opad);
    		md.update(dg, 0, 20);
    		dg = md.digest();
    		return ConvertUtils.toHex(dg);
    	}
    
    	public static String digest(String aValue) {
    		return digest(aValue, ENCODE);
    
    	}
    
    	public static String digest(String aValue, String encoding) {
    		aValue = aValue.trim();
    		byte value[];
    		try {
    			value = aValue.getBytes(encoding);
    		} catch (UnsupportedEncodingException e) {
    			value = aValue.getBytes();
    		}
    		MessageDigest md = null;
    		try {
    			md = MessageDigest.getInstance("SHA");
    		} catch (NoSuchAlgorithmException e) {
    			log.error(e.getMessage(), e);
    			return null;
    		}
    		return ConvertUtils.toHex(md.digest(value));
    	}
    
    
    	public static String digest(String aValue, String alg, String encoding) {
    		aValue = aValue.trim();
    		byte value[];
    		try {
    			value = aValue.getBytes(encoding);
    		} catch (UnsupportedEncodingException e) {
    			value = aValue.getBytes();
    		}
    		MessageDigest md = null;
    		try {
    			md = MessageDigest.getInstance(alg);
    		} catch (NoSuchAlgorithmException e) {
    			log.error(e.getMessage(), e);
    			return null;
    		}
    		return ConvertUtils.toHex(md.digest(value));
    	}
    
    	public static String udpSign(String aValue) {
    		try {
    			byte[] input = aValue.getBytes("UTF-8");
    			MessageDigest md = MessageDigest.getInstance("SHA1");
    			return new String(Base64.encode(md.digest(input)), ENCODE);
    		} catch (Exception e) {
    			return null;
    		}
    	}
    
    }

### VariableConfigure（变量配置工具类）： ###

//package 配置文件路径
    
    public class VariableConfigure  {
    	//UTF-8字符编码格式（可识别中英文，全球通用）
    	public static final String UTF8_CHAR_ENCODING = "UTF-8";
    	//AES算法
    	public static final String AES_ALGORITHM = "AES/CBC/PKCS5Padding";
    	//RSA算法
    	public static final String RSA_ALGORITHM = "RSA/ECB/PKCS1Padding";
    }

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjU4NTM4Ng_size_16_color_FFFFFF_t_70 1][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjU4NTM4Ng_size_16_color_FFFFFF_t_70]: /images/20221023/58cdd69ebdac4ff58669f0986148fec7.png
[https_blog.csdn.net_gulang03_article_details_81175854]: https://blog.csdn.net/gulang03/article/details/81175854
[https_blog.csdn.net_gulang03_article_details_81176133]: https://blog.csdn.net/gulang03/article/details/81176133
[https_blog.csdn.net_gulang03_article_details_81771341]: https://blog.csdn.net/gulang03/article/details/81771341
[https_blog.csdn.net_gulang03_article_details_82230408]: https://blog.csdn.net/gulang03/article/details/82230408
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjU4NTM4Ng_size_16_color_FFFFFF_t_70 1]: /images/20221023/43e70424d49b4c40934dcbed0cc20f15.png