java 密码手稿一（RSA MD5​ SM4 ）

已于 2023-06-20 18:37:43 修改
阅读量409 收藏
点赞数
文章标签： java 密码
于 2023-04-18 14:44:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxp199741/article/details/130221336
版权

SM4

package demo;

import com.alibaba.fastjson2.JSONObject;

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

/**
 * 国密算法SM4
 * SM3是签名算法，和MD5一样（对于应用层来说）。
 * SM4是对称加密算法，和AES一样（对于应用层来说）
 *
 * 更优参考：https://blog.csdn.net/qq78442761/article/details/120009887
 */
public class SM4 {
    protected static final int SM4_ENCRYPT = 1;
    protected static final int SM4_DECRYPT = 0;
    protected 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};
    protected static final int[] FK = new int[]{-1548633402, 1453994832, 1736282519, -1301273892};
    protected 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() {
    }

    /**
     * 测试
     * @param args
     */
    public static void main(String[] args) {
        JSONObject parms = new JSONObject();
        parms.put("custName", "张三");
        parms.put("certNum", "411322000000000000");
        String str = parms.toJSONString();
        System.out.println("参数:" + str);
        //key必须是16位
        String key ="TAxH5p1vs3ePYABC";
        String ncECBData = SecuritySM4.EncryptStr(str, key);
        System.out.println("加密:"+ncECBData);
        String plainTextEncripted = SecuritySM4.DecryptStr(ncECBData,key);
        System.out.println("解密:"+plainTextEncripted);
    }

    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 if (input.length % 16 == 0) {
            return input;
        } 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] = 0;
                }
            } else {
                int p = input[input.length - 1];
                ret = new byte[input.length - p];
                System.arraycopy(input, 0, ret, 0, input.length - p);
            }

            return ret;
        }
    }

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

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

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

        } else {
            throw new Exception("key error!");
        }
    }

    protected 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;
        }
    }

    protected byte[] sm4_crypt_cbc(SM4_Context ctx, byte[] iv, byte[] input) throws Exception {
        if (iv != null && iv.length == 16) {
            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) {
//                    int var10000 = ctx.mode;
//                }

                bins.close();
                bous.close();
                return temp;
            }
        } else {
            throw new Exception("iv error!");
        }
    }
}

RSA

package demo;
import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
/**
 * RSA非对称加密算法
 * 对称加密算法常用：AES DES
 *
 * 对称加密 VS 对称加密
 * 	对称加密与解密
 * 		使用的是同样的密钥 但由于需要将密钥在网络传输 所以安全性不高
 * 	非对称加密
 * 		使用了一对密钥 公钥与私钥 把以安全性高 但加密与解密速度慢
 */
public class RSA {
    public static void main(String[] args) throws Exception {
        //获取RSA算法的密钥生成器对象
        KeyPairGenerator keyPairGen =KeyPairGenerator.getInstance("RSA");
        //设定密钥长度为1024位
        keyPairGen.initialize(1024);
        //生成"密钥对"对象
        KeyPair keyPair = keyPairGen.generateKeyPair();

        //分别获取私钥和公钥对象
        RSAPrivateKey rsaPrivateKey =(RSAPrivateKey) keyPair.getPrivate();
        RSAPublicKey rsapublicKey =(RSAPublicKey) keyPair.getPublic();

        //执行加密和解密过程
        RSA encrypt=new RSA();
        String encryptText="这是要加密的内容";

        //得到要加密内容的数组
        byte[] srcData =encryptText.getBytes();

        //用公钥加密
        byte e[]= encrypt.encrypt(rsapublicKey,srcData);
        System.out.println("encrypt:"+new String(e));

        //用私钥解密
        byte []de =encrypt.decrypt(rsaPrivateKey,e);
        System.out.println("decrypt："+new String(de));
    }

    protected  byte[] encrypt(RSAPublicKey publicKey,byte[] obj) throws Exception {
        Cipher cipher =Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE,publicKey);

        //返回加密后的内容
        return cipher.doFinal(obj);
    }

    protected  byte[] decrypt(RSAPrivateKey privateKey,byte[] obj)throws Exception{
        Cipher cipher =Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE,privateKey);
        //返回解密后的数组
        return cipher.doFinal(obj);
    }
}

MD5

public class MD5 {
    public static void main(String[] args) {
        String password = "用户密码";
        System.out.println(encryptToMD5(password));
        System.out.println(encrypt2ToMD5(password));
        System.out.println(encrypt3ToMD5(password));
    }

    public static String encryptToMD5(String str) {
        return DigestUtils.md5Hex(str);
    }

    public static String encrypt2ToMD5(String str) {
        // 加密后的16进制字符串
        String hexStr = "";
        try {
            // 此 MessageDigest 类为应用程序提供信息摘要算法的功能
            MessageDigest md5 = MessageDigest.getInstance("MD5");
            // 转换为MD5码
            byte[] digest = md5.digest(str.getBytes("utf-8"));
            hexStr = Hex.encodeHexString(digest);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return hexStr;
    }

    public static String encrypt3ToMD5(String str) {
        String md5 = "";
        try {
            md5 = DigestUtils.md5Hex(str.getBytes("utf-8"));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return md5;
    }

}
DigestUtils.md5DigestAsHex((salt + rawPassword).getBytes())

PHP(Mr. Hamster)
关注
MD5和RSA加密算法Java完成实现
09-16
在给定的资源中，可能包含了实现这些功能所需的jar包和其他辅助材料，如`yanzi1225627-7382263-MD5和RSA加密算法Java完成实现_1600255815`文件。这个文件可能包含了完整的示例代码或者库文件，用于帮助初学者更方便...
java实现国密SM4加密
qq_55961709的博客
02-28 5271
最近世界政治影响，我国也开始要求算法的使用，以避免来自外国的黑客入侵。我们在使用加密算法时，有必要选择使用国密算法进行加密SymmetricCrypto 类方法返回类型byte[]byte[]Stringbyte[]byte[]byte[]StringStringStringStringStringStringStringStringStringSymmetricCrypto类的构造方法非常灵活，可以灵活根据自己需要的方式进行构造。
数据加密算法之国密SM4、SM3、SM2研究及Java实现
gaozhenzhai的博客
09-05 1万+
国密加密算法研究
密码算法（SM1、SM2、SM3、SM4、同态加密、密态计算、隐私计算和安全多方计算）
最新发布
dzqxwzoe的博客
08-12 1448
最后给椭圆曲线上密钥对的生成以及公钥的验证，用户的密钥对为（s，sP），其中s为用户的私钥，sP为用户的公钥，由于离散对数问题从sP难以得到s，并针对素域和二元扩域给出了密钥对生成细节和验证方式。数据存储在云端服务器，出于合规要求，需要对数据分级并加密，用户在查询数据时，使用安全多方计算技术，保证数据查询方用户仅能得到自己需要的信息，密文状态下实现查询，本地用户解密，并且服务器端对于用户的查询的具体内容不知情，该类技术可以实现数据的安全查询，保障查询方用户与服务器的两方隐私。在SM2，SM9标准中使用。
国密算法 SM4 加解密 java 工具类
李嘉城的博客
07-12 8813
我国国家密码管理局陆续发布了一系列国产加密算法，这其中就包括 SM1、SM2、SM3 、SM4、SM7、SM9、ZUC（祖冲之加密算法）等，SM 代表商密，即商业密码，是指用于商业的、不涉及国家秘密的密码技术。SM1 和 SM7 的算法不公开，其余算法都已成为 ISO/IEC 国际标准
JAVA集成国密SM4
qq_38254635的博客
07-19 5137
JAVA集成国密SM4加解密
使用 Java Bouncy Castle实现国密算法SM4、SM3以及SM2的加密
Rm_mR的博客
06-19 9515
国密算法SM2、SM3、SM4的实现 借助Java库函数 Bouncy Castle
SM4 SM3 RSA MD5等加密结果验证工具.rar
08-20
SM4 SM3 AES DES RSA MD5等加密结果验证工具。用于对比程序实现的算法与标准加解密结果。支持各种padding 和对称AES DES加密和非对称RSA。
密码学中AES\DES\MD5\SHA1\RSA加密流程的JAVA实现
01-07
本文将详细解析标题所提及的AES、DES、MD5、SHA1和RSA加密流程，并结合给定的Java实现进行讨论。 1. **AES（Advanced Encryption Standard）**：AES是一种对称加密算法，广泛用于保护大量数据的安全。它基于替换和...
Java 信息摘要加密MD2、MD4、MD5实现详解
08-25
示例代码展示了如何在Java中使用标准的jdk以及使用Bouncy Castle库来实现MD2、MD4、MD5散列算法。Bouncy Castle是一个提供了丰富的加密算法的开源Java加密库，能够提供Java标准库中不直接支持的加密算法的实现。 ...
java加密算法分享(rsa解密、对称加密、md5加密)
09-04
本文将深入探讨其中的三种主要加密方式：RSA非对称加密、对称加密以及MD5哈希加密。 1. RSA非对称加密 RSA是一种非对称加密算法，其核心特点是拥有两个密钥：公钥和私钥。公钥可以公开给任何人，用于加密数据；而...
国密SM4对称加密Java加解密
wcuu的博客
01-10 8987
SM4.0（原名SMS4.0）是中华人民共和国政府采用的一种分组密码标准，由国家密码管理局于2012年3月21日发布。相关标准为“GM/T 0002-2012《SM4分组密码算法》（原SMS4分组密码算法）”。在密码学中，分组加密（英语：Block cipher），又称分块加密或块密码，是一种对称密钥算法。它将明文分成多个等长的模块（block），使用确定的算法和对称密钥对每组分别加密解密。
国密SM4加解密--Java实现
怪只怪满眼尽是人间烟火
07-26 3747
【代码】国密SM4加解密--Java实现。
SM4加密算法原理和简单实现（java）
热门推荐
weixin_39055614的博客
03-24 2万+
SM4加密算法原理和简单实现（java）
【Java加解密系列】- SM4加解密
Kevin_zhai的博客
05-26 3021
之前文章介绍过SM2生成密钥和加解密的代码实现过程，这篇文章主要介绍下SM4对称加密算法的代码实现，依然还是引用的BC库。
Java之SM4解密与解密
weixin_43968720的博客
09-01 7759
在线SM4国密加密/解密—LZL在线工具。pom.xml引入一下jar包。实现SM4加密和解密代码部分。根据项目选择相应数据格式。在线SM4国密加密/解密。
Java封装实现国密SM4对称加解密运算
一切有为法，如梦亦如幻，如露亦如电，应作如是观。
03-11 3129
SM4密码算法是我国自主设计的分组对称密码算法，用于实现数据的加密/解密运算，以保证数据和信息的机密性。 该算法的分组长度为128比特，密钥长度为128比特。（十六进制表示则为32位，明文和密钥等长） 加密算法与密钥扩展算法都采用32轮非线性迭代结构。 密钥扩展算法：将加密密钥变换为轮密钥的运算单元。 数据解密和数据加密的算法结构相同，只是轮密钥的使用顺序相反，解密轮密钥是加密轮密钥的逆序。
sm4加密Java实现参考代码
Lyh_2015的博客
08-09 5296
来源博客： https://blog.csdn.net/CREATE_17/article/details/89067193 package com.demo.utils; import java.util.Arrays; public class Sms4 { /** * @description: ENCRYPT与DECRYPT为加解密的判断依据 */ private static final int ENCRYPT = 1; private .
国密算法SM2/3/4简单比较，以及基于Java的SM4（ECB模式，CBC模式）对称加解密实现
Arvin Rong's Space
01-20 1万+
可使用的大量标准加密算法实现，其中包含了SM2，SM3，SM4。注意： 此版本我在JDK1.8环境下，不同版本JDK需要找到匹配的依赖版本1.8及以上可以使用bcprov-jdk18on。简单说明：加密算法依赖了groupId:org.bouncycastle中的bcprov-jdk15to18，Bouncy Castle (方式二：依赖bcprov-jdk15to18（以CBC模式为例），代码根据GPT-4生成修改调试，可运行。方式一：依赖bcprov-jdk15to18（以ECB模式为例）
Java加解密详解：DES、RSA与MD5
"本文将介绍Java中常用的三种加密解密算法：DES，RSA以及MD5。这些算法在信息安全领域有着广泛的应用，对于保护数据的安全性和完整性至关重要。" DES（Data Encryption Standard）算法是一种对称加密算法，其核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

PHP(Mr. Hamster)

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值