SM4国密算法Utils

最新推荐文章于 2024-04-27 09:13:51 发布
最新推荐文章于 2024-04-27 09:13:51 发布
阅读量6.6k 收藏 12
点赞数
分类专栏： 加密算法 文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jimmy12581/article/details/106468148
版权

 SM4Utils 工具类代码


import java.util.regex.Matcher;
import java.util.regex.Pattern;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class SM4Utils {
    private String secretKey = "86C63180C2806ED1F47B859DE501215B";
    private boolean hexString = false;
    private String iv = "";

    public String getSecretKey() {
        return this.secretKey;
    }

    public void setSecretKey(String secretKey) {
        this.secretKey = secretKey;
    }

    public String getIv() {
        return this.iv;
    }

    public void setIv(String iv) {
        this.iv = iv;
    }

    public boolean isHexString() {
        return this.hexString;
    }

    public void setHexString(boolean hexString) {
        this.hexString = hexString;
    }

    public SM4Utils() {
    }

    public String encryptData_ECB(String plainText) {
        try {
            SM4_Context ctx = new SM4_Context();
            ctx.isPadding = true;
            ctx.mode = 1;
            byte[] keyBytes;
            if (this.hexString) {
                keyBytes = ByteUtil.hexStringToBytes(this.secretKey);
            } else {
                keyBytes = this.secretKey.getBytes();
            }

            SM4 sm4 = new SM4();
            sm4.sm4_setkey_enc(ctx, keyBytes);
            byte[] encrypted = sm4.sm4_crypt_ecb(ctx, plainText.getBytes("GBK"));
            String cipherText = (new BASE64Encoder()).encode(encrypted);
            if (cipherText != null && cipherText.trim().length() > 0) {
                Pattern p = Pattern.compile("\\s*|\t|\r|\n");
                Matcher m = p.matcher(cipherText);
                cipherText = m.replaceAll("");
            }

            return cipherText;
        } catch (Exception var9) {
            var9.printStackTrace();
            return null;
        }
    }

    public byte[] encryptData_ECB(byte[] plainText) {
        try {
            SM4_Context ctx = new SM4_Context();
            ctx.isPadding = true;
            ctx.mode = 1;
            byte[] keyBytes;
            if (this.hexString) {
                keyBytes = ByteUtil.hexStringToBytes(this.secretKey);
            } else {
                keyBytes = this.secretKey.getBytes();
            }

            SM4 sm4 = new SM4();
            sm4.sm4_setkey_enc(ctx, keyBytes);
            return sm4.sm4_crypt_ecb(ctx, plainText);
        } catch (Exception var5) {
            var5.printStackTrace();
            return null;
        }
    }

    public String decryptData_ECB(String cipherText) {
        try {
            SM4_Context ctx = new SM4_Context();
            ctx.isPadding = true;
            ctx.mode = 0;
            byte[] keyBytes;
            if (this.hexString) {
                keyBytes = ByteUtil.hexStringToBytes(this.secretKey);
            } else {
                keyBytes = this.secretKey.getBytes();
            }

            SM4 sm4 = new SM4();
            sm4.sm4_setkey_dec(ctx, keyBytes);
            byte[] decrypted = sm4.sm4_crypt_ecb(ctx, (new BASE64Decoder()).decodeBuffer(cipherText));
            return new String(decrypted, "GBK");
        } catch (Exception var6) {
            var6.printStackTrace();
            return null;
        }
    }

    public byte[] decryptData_ECB(byte[] cipherText) {
        try {
            SM4_Context ctx = new SM4_Context();
            ctx.isPadding = true;
            ctx.mode = 0;
            byte[] keyBytes;
            if (this.hexString) {
                keyBytes = ByteUtil.hexStringToBytes(this.secretKey);
            } else {
                keyBytes = this.secretKey.getBytes();
            }

            SM4 sm4 = new SM4();
            sm4.sm4_setkey_dec(ctx, keyBytes);
            return sm4.sm4_crypt_ecb(ctx, cipherText);
        } catch (Exception var5) {
            var5.printStackTrace();
            return null;
        }
    }

    public String encryptData_CBC(String plainText) {
        try {
            SM4_Context ctx = new SM4_Context();
            ctx.isPadding = true;
            ctx.mode = 1;
            byte[] keyBytes;
            byte[] ivBytes;
            if (this.hexString) {
                keyBytes = ByteUtil.hexStringToBytes(this.secretKey);
                ivBytes = ByteUtil.hexStringToBytes(this.iv);
            } else {
                keyBytes = this.secretKey.getBytes();
                ivBytes = this.iv.getBytes();
            }

            SM4 sm4 = new SM4();
            sm4.sm4_setkey_enc(ctx, keyBytes);
            byte[] encrypted = sm4.sm4_crypt_cbc(ctx, ivBytes, plainText.getBytes("GBK"));
            String cipherText = (new BASE64Encoder()).encode(encrypted);
            if (cipherText != null && cipherText.trim().length() > 0) {
                Pattern p = Pattern.compile("\\s*|\t|\r|\n");
                Matcher m = p.matcher(cipherText);
                cipherText = m.replaceAll("");
            }

            return cipherText;
        } catch (Exception var10) {
            var10.printStackTrace();
            return null;
        }
    }

    public byte[] encryptData_CBC(byte[] plainText) {
        try {
            SM4_Context ctx = new SM4_Context();
            ctx.isPadding = true;
            ctx.mode = 1;
            byte[] keyBytes;
            byte[] ivBytes;
            if (this.hexString) {
                keyBytes = ByteUtil.hexStringToBytes(this.secretKey);
                ivBytes = ByteUtil.hexStringToBytes(this.iv);
            } else {
                keyBytes = this.secretKey.getBytes();
                ivBytes = this.iv.getBytes();
            }

            SM4 sm4 = new SM4();
            sm4.sm4_setkey_enc(ctx, keyBytes);
            return sm4.sm4_crypt_cbc(ctx, ivBytes, plainText);
        } catch (Exception var6) {
            var6.printStackTrace();
            return null;
        }
    }

    public String decryptData_CBC(String cipherText) {
        try {
            SM4_Context ctx = new SM4_Context();
            ctx.isPadding = true;
            ctx.mode = 0;
            byte[] keyBytes;
            byte[] ivBytes;
            if (this.hexString) {
                keyBytes = ByteUtil.hexStringToBytes(this.secretKey);
                ivBytes = ByteUtil.hexStringToBytes(this.iv);
            } else {
                keyBytes = this.secretKey.getBytes();
                ivBytes = this.iv.getBytes();
            }

            SM4 sm4 = new SM4();
            sm4.sm4_setkey_dec(ctx, keyBytes);
            byte[] decrypted = sm4.sm4_crypt_cbc(ctx, ivBytes, (new BASE64Decoder()).decodeBuffer(cipherText));
            return new String(decrypted, "GBK");
        } catch (Exception var7) {
            var7.printStackTrace();
            return null;
        }
    }

    public byte[] decryptData_CBC(byte[] cipherText) {
        try {
            SM4_Context ctx = new SM4_Context();
            ctx.isPadding = true;
            ctx.mode = 0;
            byte[] keyBytes;
            byte[] ivBytes;
            if (this.hexString) {
                keyBytes = ByteUtil.hexStringToBytes(this.secretKey);
                ivBytes = ByteUtil.hexStringToBytes(this.iv);
            } else {
                keyBytes = this.secretKey.getBytes();
                ivBytes = this.iv.getBytes();
            }

            SM4 sm4 = new SM4();
            sm4.sm4_setkey_dec(ctx, keyBytes);
            return sm4.sm4_crypt_cbc(ctx, ivBytes, cipherText);
        } catch (Exception var6) {
            var6.printStackTrace();
            return null;
        }
    }
}

 其他相关配置

public class SM4_Context {
    public int mode = 1;
    public long[] sk = new long[32];
    public boolean isPadding = true;

    public SM4_Context() {
    }
}


import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

public class SM4 {
    public static final int SM4_ENCRYPT = 1;
    public static final int SM4_DECRYPT = 0;
    public static final byte[] SboxTable = new byte[]{-42, -112, -23, -2, -52, -31, 61, -73, 22, -74, 20, -62, 40, -5, 44, 5, 43, 103, -102, 118, 42, -66, 4, -61, -86, 68, 19, 38, 73, -122, 6, -103, -100, 66, 80, -12, -111, -17, -104, 122, 51, 84, 11, 67, -19, -49, -84, 98, -28, -77, 28, -87, -55, 8, -24, -107, -128, -33, -108, -6, 117, -113, 63, -90, 71, 7, -89, -4, -13, 115, 23, -70, -125, 89, 60, 25, -26, -123, 79, -88, 104, 107, -127, -78, 113, 100, -38, -117, -8, -21, 15, 75, 112, 86, -99, 53, 30, 36, 14, 94, 99, 88, -47, -94, 37, 34, 124, 59, 1, 33, 120, -121, -44, 0, 70, 87, -97, -45, 39, 82, 76, 54, 2, -25, -96, -60, -56, -98, -22, -65, -118, -46, 64, -57, 56, -75, -93, -9, -14, -50, -7, 97, 21, -95, -32, -82, 93, -92, -101, 52, 26, 85, -83, -109, 50, 48, -11, -116, -79, -29, 29, -10, -30, 46, -126, 102, -54, 96, -64, 41, 35, -85, 13, 83, 78, 111, -43, -37, 55, 69, -34, -3, -114, 47, 3, -1, 106, 114, 109, 108, 91, 81, -115, 27, -81, -110, -69, -35, -68, 127, 17, -39, 92, 65, 31, 16, 90, -40, 10, -63, 49, -120, -91, -51, 123, -67, 45, 116, -48, 18, -72, -27, -76, -80, -119, 105, -105, 74, 12, -106, 119, 126, 101, -71, -15, 9, -59, 110, -58, -124, 24, -16, 125, -20, 58, -36, 77, 32, 121, -18, 95, 62, -41, -53, 57, 72};
    public static final int[] FK = new int[]{-1548633402, 1453994832, 1736282519, -1301273892};
    public static final int[] CK = new int[]{462357, 472066609, 943670861, 1415275113, 1886879365, -1936483679, -1464879427, -993275175, -521670923, -66909679, 404694573, 876298825, 1347903077, 1819507329, -2003855715, -1532251463, -1060647211, -589042959, -117504499, 337322537, 808926789, 1280531041, 1752135293, -2071227751, -1599623499, -1128019247, -656414995, -184876535, 269950501, 741554753, 1213159005, 1684763257};

    public SM4() {
    }

    private long GET_ULONG_BE(byte[] b, int i) {
        long n = (long)(b[i] & 255) << 24 | (long)((b[i + 1] & 255) << 16) | (long)((b[i + 2] & 255) << 8) | (long)(b[i + 3] & 255) & 4294967295L;
        return n;
    }

    private void PUT_ULONG_BE(long n, byte[] b, int i) {
        b[i] = (byte)((int)(255L & n >> 24));
        b[i + 1] = (byte)((int)(255L & n >> 16));
        b[i + 2] = (byte)((int)(255L & n >> 8));
        b[i + 3] = (byte)((int)(255L & n));
    }

    private long SHL(long x, int n) {
        return (x & -1L) << n;
    }

    private long ROTL(long x, int n) {
        return this.SHL(x, n) | x >> 32 - n;
    }

    private void SWAP(long[] sk, int i) {
        long t = sk[i];
        sk[i] = sk[31 - i];
        sk[31 - i] = t;
    }

    private byte sm4Sbox(byte inch) {
        int i = inch & 255;
        byte retVal = SboxTable[i];
        return retVal;
    }

    private long sm4Lt(long ka) {
        long bb = 0L;
        long c = 0L;
        byte[] a = new byte[4];
        byte[] b = new byte[4];
        this.PUT_ULONG_BE(ka, a, 0);
        b[0] = this.sm4Sbox(a[0]);
        b[1] = this.sm4Sbox(a[1]);
        b[2] = this.sm4Sbox(a[2]);
        b[3] = this.sm4Sbox(a[3]);
        bb = this.GET_ULONG_BE(b, 0);
        c = bb ^ this.ROTL(bb, 2) ^ this.ROTL(bb, 10) ^ this.ROTL(bb, 18) ^ this.ROTL(bb, 24);
        return c;
    }

    private long sm4F(long x0, long x1, long x2, long x3, long rk) {
        return x0 ^ this.sm4Lt(x1 ^ x2 ^ x3 ^ rk);
    }

    private long sm4CalciRK(long ka) {
        long bb = 0L;
        long rk = 0L;
        byte[] a = new byte[4];
        byte[] b = new byte[4];
        this.PUT_ULONG_BE(ka, a, 0);
        b[0] = this.sm4Sbox(a[0]);
        b[1] = this.sm4Sbox(a[1]);
        b[2] = this.sm4Sbox(a[2]);
        b[3] = this.sm4Sbox(a[3]);
        bb = this.GET_ULONG_BE(b, 0);
        rk = bb ^ this.ROTL(bb, 13) ^ this.ROTL(bb, 23);
        return rk;
    }

    private void sm4_setkey(long[] SK, byte[] key) {
        long[] MK = new long[4];
        long[] k = new long[36];
        int i = 0;
        MK[0] = this.GET_ULONG_BE(key, 0);
        MK[1] = this.GET_ULONG_BE(key, 4);
        MK[2] = this.GET_ULONG_BE(key, 8);
        MK[3] = this.GET_ULONG_BE(key, 12);
        k[0] = MK[0] ^ (long)FK[0];
        k[1] = MK[1] ^ (long)FK[1];
        k[2] = MK[2] ^ (long)FK[2];

        for(k[3] = MK[3] ^ (long)FK[3]; i < 32; ++i) {
            k[i + 4] = k[i] ^ this.sm4CalciRK(k[i + 1] ^ k[i + 2] ^ k[i + 3] ^ (long)CK[i]);
            SK[i] = k[i + 4];
        }

    }

    private void sm4_one_round(long[] sk, byte[] input, byte[] output) {
        int i = 0;
        long[] ulbuf = new long[36];
        ulbuf[0] = this.GET_ULONG_BE(input, 0);
        ulbuf[1] = this.GET_ULONG_BE(input, 4);
        ulbuf[2] = this.GET_ULONG_BE(input, 8);

        for(ulbuf[3] = this.GET_ULONG_BE(input, 12); i < 32; ++i) {
            ulbuf[i + 4] = this.sm4F(ulbuf[i], ulbuf[i + 1], ulbuf[i + 2], ulbuf[i + 3], sk[i]);
        }

        this.PUT_ULONG_BE(ulbuf[35], output, 0);
        this.PUT_ULONG_BE(ulbuf[34], output, 4);
        this.PUT_ULONG_BE(ulbuf[33], output, 8);
        this.PUT_ULONG_BE(ulbuf[32], output, 12);
    }

    private byte[] padding(byte[] input, int mode) {
        if (input == null) {
            return null;
        } else {
            byte[] ret = (byte[])null;
            if (mode == 1) {
                int p = 16 - input.length % 16;
                ret = new byte[input.length + p];
                System.arraycopy(input, 0, ret, 0, input.length);

                for(int i = 0; i < p; ++i) {
                    ret[input.length + i] = (byte)p;
                }
            } else {
                int p = input[input.length - 1];
                ret = new byte[input.length - p];
                System.arraycopy(input, 0, ret, 0, input.length - p);
            }

            return ret;
        }
    }

    public void sm4_setkey_enc(SM4_Context ctx, byte[] key) throws Exception {
        if (ctx == null) {
            throw new Exception("ctx is null!");
        } else if (key == null) {
            throw new Exception("key error!");
        } else {
            ctx.mode = 1;
            this.sm4_setkey(ctx.sk, key);
        }
    }

    public void sm4_setkey_dec(SM4_Context ctx, byte[] key) throws Exception {
        if (ctx == null) {
            throw new Exception("ctx is null!");
        } else if (key == null) {
            throw new Exception("key error!");
        } else {
            ctx.mode = 0;
            this.sm4_setkey(ctx.sk, key);

            for(int i = 0; i < 16; ++i) {
                this.SWAP(ctx.sk, i);
            }

        }
    }

    public byte[] sm4_crypt_ecb(SM4_Context ctx, byte[] input) throws Exception {
        if (input == null) {
            throw new Exception("input is null!");
        } else {
            if (ctx.isPadding && ctx.mode == 1) {
                input = this.padding(input, 1);
            }

            int length = input.length;
            ByteArrayInputStream bins = new ByteArrayInputStream(input);

            ByteArrayOutputStream bous;
            byte[] output;
            for(bous = new ByteArrayOutputStream(); length > 0; length -= 16) {
                output = new byte[16];
                byte[] out = new byte[16];
                bins.read(output);
                this.sm4_one_round(ctx.sk, output, out);
                bous.write(out);
            }

            output = bous.toByteArray();
            if (ctx.isPadding && ctx.mode == 0) {
                output = this.padding(output, 0);
            }

            bins.close();
            bous.close();
            return output;
        }
    }

    public byte[] sm4_crypt_cbc(SM4_Context ctx, byte[] iv, byte[] input) throws Exception {
        if (iv == null) {
            throw new Exception("iv error!");
        } else if (input == null) {
            throw new Exception("input is null!");
        } else {
            if (ctx.isPadding && ctx.mode == 1) {
                input = this.padding(input, 1);
            }

            int length = input.length;
            ByteArrayInputStream bins = new ByteArrayInputStream(input);
            ByteArrayOutputStream bous = new ByteArrayOutputStream();
            byte[] temp;
            byte[] out;
            int i;
            if (ctx.mode != 1) {
                for(temp = new byte[16]; length > 0; length -= 16) {
                    out = new byte[16];
                    out = new byte[16];
                    byte[] out1 = new byte[16];
                    bins.read(out);
                    System.arraycopy(out, 0, temp, 0, 16);
                    this.sm4_one_round(ctx.sk, out, out);

                    for(i = 0; i < 16; ++i) {
                        out1[i] = (byte)(out[i] ^ iv[i]);
                    }

                    System.arraycopy(temp, 0, iv, 0, 16);
                    bous.write(out1);
                }
            } else {
                while(length > 0) {
                    temp = new byte[16];
                    out = new byte[16];
                    out = new byte[16];
                    bins.read(temp);

                    for(i = 0; i < 16; ++i) {
                        out[i] = (byte)(temp[i] ^ iv[i]);
                    }

                    this.sm4_one_round(ctx.sk, out, out);
                    System.arraycopy(out, 0, iv, 0, 16);
                    bous.write(out);
                    length -= 16;
                }
            }

            temp = bous.toByteArray();
            if (ctx.isPadding && ctx.mode == 0) {
                temp = this.padding(temp, 0);
            }

            bins.close();
            bous.close();
            return temp;
        }
    }
}

iuw...
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
SM4Util.java
04-30
一种加密方式，国密方式加密，是一种可逆的加密方式，一般这样就够用，如果级别不够，还可以在当前基础对该加密方式增强，该工具类可直接粘贴到项目里使用。
【Java】SM4Utils（国密 SM4 工具类）
XKIND'S 博客
08-25 921
基于 bouncycastle 实现 国密 SM4 对称加密
使用SM4国密加密算法对Spring Boot项目数据库连接信息以及yaml文件配置属性进行加密配置（读取时自动解密）
聆听
03-26 661
针对加密的数据库配置信息，需要自定义解密，所以需要自定义一个DataSource对象@Override// 对用户名进行解密@Override// 对密码进行解密。
对称加密算法之Java SM4算法应用 附可用工具类
键盘上流淌的日子
08-24 9436
欢迎大家关注本博，同时欢迎大家评论交流，可以给个赞哦！！！   SM4算法简介   与DES和AES密码算法实现类似，SM4是一种分组密码算法。SM4分组密码算法用于无线局域网和可信计算系统的专用分组密码算法，该算法的分组长度为128比特，密码长度为128比特。SM4算法是我国制定WAPI标准的组成部分，同时也可以用于其它环境下的数据加密保护。   加密算法与密钥扩展算法均采用32轮非线性迭代结构，以字（32位）为单位进行加密运算，每一次迭代运算均为一轮变换函数F。SM4算法加/解密算法的结构相同，只是.
sm2 国密加解密算法，SmCryptoUtil 工具类
01-12
https://blog.csdn.net/qq_32848943/article/details/118670448 这个网址下的 import sviolet.smcrypto.SmCryptoUtil; 在这个jar包下，maven仓库中找不到
java实现sm2、sm3、sm4国密算法，完美实现，轻松调用
10-15
国密是咱大中国的国家密码局认定和颁发的密码算法标准，SM 是一个系列，常用的包括SM1、SM2、SM3、SM4。 一般说商密是指商用密码。更多是我们更加耳熟能详的的密码学标准。诸如AES、DAS、RSA、ECC椭圆曲线系列等加密算法。 为什么有了商密还要国密。主要原因可能包括： 1、一部分商密的设计中涉及到的一些具体步骤主要是老美的一些强力部门负责的。里面是不是有个什么漏洞啊、后门啊什么的不清楚。 2、国密是自己人弄的，对于原理和实现细节一清二楚。用起来放心。 目前国密主要是对国内的产品，有些特殊的产品国家会强制使用。
前端使用国密SM4进行加密、解密
热门推荐
工作中遇到问题记录
04-19 1万+
前端使用国密SM4进行 加密/解密 的三种办法，报错 Uncaught RangeError: Invalid array length
SM4Utils加解密
xiyangyang8110的博客
11-30 1106
【代码】SM4Utils加解密。
一文带你学会国产加密算法SM4的java实现方案
经典鸡翅
05-21 8636
前言 今天给大家带来一个国产SM4加密解密算法的java后端解决方案，代码完整，可以直接使用，希望给大家带来帮助，尤其是做政府系统的开发人员，可以直接应用到项目中进行加密解密。 画重点！是SM4哦，不是SM。哈哈，各位要在知识里遨游，不要想歪。正文开始~ 国产SM4加密解密算法概念介绍 SMS4算法是在国内广泛使用的WAPI无线网络标准中使用的加密算法，是一种32轮的迭代非平衡Feistel结构的分组加密算法，其密钥长度和分组长度均为128。SMS4算法的加解密过程中使用的算法是完全相同的，唯一不同点在于
sm4util国密加密
爱吃猫的鱼
09-20 389
【代码】sm4util国密加密。
Vue和Springboot实现SM4加密和解密（前端可加密，后端可加解密，MD5同理）
m0_54853420的博客
03-09 5769
Vue和Springboot实现SM4加密和解密（前端可加密，后端可加解密，MD5同理） 前言 一、前端加密输入的密码 前置检测 粘贴我的 SM4.js 代码 在组件中调用 加密结果 二、Springboot 后端进行 SM4 的解密和加密 引入库 复制我的 SM4 加解密代码 调用方法 总结 前言 网站配置 https 比较麻烦，所以为了我们的用户账户安全，密码在从前端传输到后端的过程中，最好加密一下，选用 SM4 有两个原因，一是国产加密算法，二是这个国密算法是对称的，只要加密和解
Sm4Utils.java
03-26
对程序安全性有要求的企业和个人，研发，测试等
SM2、SM3、SM4国密算法软实现
10-26
SM2、SM3、SM4国密算法软实现，已经通过国家标准预设定参数进行测试，可直接使用。
sm2、sm4国密加密算法java实现(真实可用)
05-14
sm2、sm4国密加密算法java实现(真实可用)
C# 国密算法 SM2
12-15
SM2Utils.GenerateKeyPair(out publicKey, out privateKey); System.Console.Out.WriteLine("公钥: " + Encoding.Default.GetString(Hex.Encode(publicKey.GetEncoded())).ToUpper()); System.Console.O
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 780
都是符合我们的预期的。
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 852
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1782
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 1045
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
java com.pfpj.sm.sm4utils;
07-01
### 回答1： java com.pfpj.sm.sm4utils; 是一个Java中的包路径，其中的"com.pfpj.sm.sm4utils"指的是该包的全名。 在这个包中，可能包含着一些与SM4算法相关的Java类和工具。SM4算法是一种对称加密算法，主要用于数据的加密和解密操作。它是中国自主设计的密码算法，根据国际密码界的评估，具有安全可靠的特性。 这个包中可能包含着一些用于实现SM4算法的Java类，例如加密和解密方法等。通过这些类，我们可以方便地在Java环境中使用SM4算法进行数据的加密和解密操作。 当我们需要在Java项目中使用SM4算法时，可以通过导入和使用这个包中的相关类，快速地实现SM4算法的功能。通过调用这些类中的方法，我们可以实现数据的加密和解密，保护数据的安全性。 总之，java com.pfpj.sm.sm4utils;是一个表示Java中的一个包路径，可能包含了一些与SM4算法相关的Java类和工具，用于实现数据的加密和解密操作。 ### 回答2： `java com.pfpj.sm.sm4utils;` 是一个 Java 程序中的包路径。 这个包路径 `com.pfpj.sm.sm4utils` 可以表示一个 Java 程序中的一个包。在Java中，包（Package）是用来组织和管理类（Class）的一种机制。通过将类放在不同的包中，可以更好地对类进行分类和管理。 `com.pfpj.sm.sm4utils` 可以被分解为三个部分，`com` 是第一级包，表示这个包属于一个组织或者公司。`pfpj` 是第二级包，表示这个包属于`com`包下的一个子包。`sm` 和 `sm4utils` 是第三级包，表示这个包属于`pfpj`包下的一个子包。 包名的选择要根据实际情况来定，一般会根据程序的功能和功能所属的领域来命名。包名的起名最好符合一定的规范，比如使用全小写字母，使用英文单词或者单词的缩写，不使用特殊字符等。 在程序中，如果要使用这个包中的类，可以使用`import`语句来引入这个包，然后就可以使用这个包中的类了。 总之，`java com.pfpj.sm.sm4utils;` 可以表示一个 Java 程序中的一个包路径，用于分类和管理一些相关的类。 ### 回答3： Java com.pfpj.sm.sm4utils是一个Java程序包的路径，其中包含了关于SM4对称加密算法的工具类。 SM4是一种对称加密算法，也称为国密算法，由中国密码学家提出。它是一种基于分组密码的算法，用于保护数据的机密性和完整性。SM4算法采用128位的分组长度和128位的密钥长度。 com.pfpj是该工具类的包名，用于组织和管理相关的类文件。sm4utils是包名中的子包，用于区分和分类不同的工具类。 该工具类的作用是提供了一些与SM4算法相关的功能，例如加密、解密、生成密钥等等。通过调用这些工具类的方法，可以方便地进行SM4算法的实现和应用。 使用该工具类，可以实现对敏感信息的加密和解密，从而保护数据的安全性。在进行网络传输或者数据存储时，使用SM4算法进行加密可以有效防止数据被未授权的用户窃取或篡改。 总之，Java com.pfpj.sm.sm4utils是一个用于实现SM4对称加密算法的工具类包，能够提供基于SM4算法的加密、解密和密钥生成等功能，用于保护数据的机密性和完整性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值