SM3代码（Java&&TS)

最新推荐文章于 2024-08-11 22:13:15 发布
最新推荐文章于 2024-08-11 22:13:15 发布
阅读量172 收藏
点赞数 2
分类专栏： 代码 文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengshamgwuji/article/details/136996119
版权

java

public class SM3Util {

    // 常量
    private static final int[] Tj = { 0x79cc4519, 0x7a879d8a };

    private SM3Util() {

    }

    /**
     * 左移函数
     * 
     * @param x
     * @param n
     * @return
     */
    private static int rotateLeft(int x, int n, int k) {
        return (x << n) | (x >>> k);
    }

    /**
     * P1(X) = X ⊕ (X ≪ 15) ⊕ (X ≪ 23)
     * 
     * @param X
     * @return
     */
    private static int p1(int X) {
        return X ^ rotateLeft(X, 15, 17) ^ rotateLeft(X, 23, 9);
    }

    /**
     * 数据填充
     * 
     * @param entity
     */
    private static byte[] padding(byte[] message) {

        int length = message.length;
        // 数据长度*8 得到实际的数据长度
        long datalength = length << 3;
        // 获取数据偏移
        int l = length & 63;

        // 补0的大小 k ≡ 448 - l - 1
        int padd = l > 55 ? 128 - l : 64 - l;

        // (64 - length) （二进制）
        byte[] paddArr = new byte[padd];
        paddArr[0] = (byte) 0x80;
        int k = padd - 8;
        for (int i = 1; i < k; i++) {
            paddArr[i] = 0x0;
        }
        for (int i = 0; i < 8; i++) {
            paddArr[i + k] = (byte) ((datalength >>> ((7 - i) << 3)) & 0xff);
        }
        byte[] result = new byte[length + padd];

        System.arraycopy(message, 0, result, 0, length);
        System.arraycopy(paddArr, 0, result, length, padd);

        return result;
    }

    /**
     * 处理数据
     * 
     * @param entity
     * @return
     */
    public static byte[] hash(byte[] message) {
        // 初始化参数
        int[] IV = { 0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600, 0xa96f30bc, 0x163138aa, 0xe38dee4d,
                0xb0fb0e4e };

        // 遍历的长度
        long forlength = message.length >> 6;
        byte[] handByte = new byte[64];
        int[] groupbyA = new int[68];

        for (int index = 0; index < forlength; index++) {

            // 数组复制
            System.arraycopy(message, index << 6, handByte, 0, 64);

            // 处理数据
            // a)将消息分组B(i)划分为16个字W0, W1, · · · , W15。
            for (int i = 0; i < 64; i += 4) {
                groupbyA[i >> 2] = (handByte[i] & 0xff) << 24 | (handByte[i + 1] & 0xff) << 16
                        | (handByte[i + 2] & 0xff) << 8 | handByte[i + 3] & 0xff;
            }

            int a = IV[0];
            int b = IV[1];
            int c = IV[2];
            int d = IV[3];
            int e = IV[4];
            int f = IV[5];
            int g = IV[6];
            int h = IV[7];
            int ss1;
            int ss2;
            int tt1;
            int tt2;
            int j = 0;
            for (; j < 52; j++) {
                groupbyA[j + 16] = p1(groupbyA[j] ^ groupbyA[j + 7] ^ rotateLeft(groupbyA[j + 13], 15, 17))
                        ^ rotateLeft(groupbyA[j + 3], 7, 25) ^ groupbyA[j + 10];

                ss1 = rotateLeft((rotateLeft(a, 12, 20) + e + rotateLeft(Tj[j < 16 ? 0 : 1], j, 32 - j)), 7, 25);
                ss2 = ss1 ^ rotateLeft(a, 12, 20);

                if (j < 16) {
                    tt1 = (a ^ b ^ c) + d + ss2 + (groupbyA[j] ^ groupbyA[j + 4]);
                    tt2 = (e ^ f ^ g) + h + ss1 + groupbyA[j];
                } else {
                    tt1 = ((a & b) | (a & c) | (b & c)) + d + ss2 + (groupbyA[j] ^ groupbyA[j + 4]);
                    tt2 = ((e & f) | (~e & g)) + h + ss1 + groupbyA[j];
                }

                d = c;
                c = rotateLeft(b, 9, 23);
                b = a;
                a = tt1;
                h = g;
                g = rotateLeft(f, 19, 13);
                f = e;
                e = tt2 ^ rotateLeft(tt2, 9, 23) ^ rotateLeft(tt2, 17, 15);

            }

            for (; j < 64; j++) {

                ss1 = rotateLeft((rotateLeft(a, 12, 20) + e + rotateLeft(Tj[j < 16 ? 0 : 1], j, 32 - j)), 7, 25);
                ss2 = ss1 ^ rotateLeft(a, 12, 20);
                tt1 = ((a & b) | (a & c) | (b & c)) + d + ss2 + (groupbyA[j] ^ groupbyA[j + 4]);
                tt2 = ((e & f) | (~e & g)) + h + ss1 + groupbyA[j];

                d = c;
                c = rotateLeft(b, 9, 23);
                b = a;
                a = tt1;
                h = g;
                g = rotateLeft(f, 19, 13);
                f = e;
                e = tt2 ^ rotateLeft(tt2, 9, 23) ^ rotateLeft(tt2, 17, 15);

            }

            IV[0] ^= a;
            IV[1] ^= b;
            IV[2] ^= c;
            IV[3] ^= d;
            IV[4] ^= e;
            IV[5] ^= f;
            IV[6] ^= g;
            IV[7] ^= h;

        }

        byte[] result = new byte[32];
        for (int i = 0; i < 8; i++) {
            intToByteArray(IV[i], result, i << 2);
        }
        return result;
    }

    /**
     * int转byte数组
     * 
     * @param n      数字
     * @param b      byte数组
     * @param offset 偏移量
     */
    private static void intToByteArray(int n, byte[] b, int offset) {
        b[offset] = (byte) (n >>> 24);
        b[offset + 1] = (byte) (n >>> 16);
        b[offset + 2] = (byte) (n >>> 8);
        b[offset + 3] = (byte) n;
    }

    /**
     * 加密
     *
     * @return
     */
    public static String encryption(Object object) {

        byte[] byteArray = null;
        if (object instanceof Number) {
            byteArray = object.toString().getBytes(StandardCharsets.UTF_8);

        } else if (object instanceof File) {

            try {
                byteArray = Files.readAllBytes(((File) object).toPath());
            } catch (IOException e) {
                e.printStackTrace();
            }

        } else if (object instanceof byte[]) {
            byteArray = (byte[]) object;
        } else if (object instanceof String) {
            byteArray = ((String) object).getBytes(StandardCharsets.UTF_8);

        }
        return encryption(byteArray);

    }

    /**
     * 加密数据
     * 
     * @param byteArray
     * @return
     */
    public static String encryption(String byteArray) {
        return encryption(byteArray.getBytes(StandardCharsets.UTF_8));
    }

    /**
     * 加密数据
     * 
     * @param byteArray
     * @return
     */
    public static String encryption(byte[] byteArray) {

        try {
            if (byteArray != null) {
                return ArrayUtils.bytesToHex(hash(padding(byteArray)));
            }
        } catch (Exception e) {
            e.printStackTrace();

        }
        return "";

    }

    public static void main(String[] args) {
        System.err.println(SM3Util.encryption("1234567"));
    }
}

TS

export class SM3Utils {


    /**
   * @param workerId
   *                     工作机器ID
   * @param datacenterId
   *                     序列号
   */
    constructor() {
    }

    // 常量
    private static Tj: number[] = [0x79cc4519, 0x7a879d8a];


    /**
     * 左移函数
     * 
     * @param x
     * @param n
     * @return
     */
    private static rotateLeft(x: number, n: number, k: number): number {
        return (x << n) | (x >>> k);
    }

    /**
     * P1(X) = X ⊕ (X ≪ 15) ⊕ (X ≪ 23)
     * 
     * @param X
     * @return
     */
    private static p1(X: number): number {
        return X ^ this.rotateLeft(X, 15, 17) ^ this.rotateLeft(X, 23, 9);
    }


    /**
     * 数据填充
     * 
     * @param entity
     */
    private static padding(message: Int8Array): Int8Array {
        const length: number = message.length;
        // 数据长度*8 得到实际的数据长度
        const datalength: bigint = BigInt(length) << BigInt(3);
        // 获取数据偏移
        const l: number = length & 63;

        // 补0的大小 k ≡ 448 - l - 1
        const padd: number = l > 55 ? 128 - l : 64 - l;

        // (64 - length) （二进制）
        const paddArr: Int8Array = new Int8Array(padd);
        paddArr[0] = 0x80;
        const k: number = padd - 8;
        for (let i = 1; i < k; i++) {
            paddArr[i] = 0x0;
        }
        for (let i = 0; i < 8; i++) {
            paddArr[i + k] = Number((datalength >> BigInt((7 - i) << 3)) & BigInt(0xff));
        }
        const result: Int8Array = new Int8Array(length + padd);

        result.set(message);
        result.set(paddArr, length);

        return result;
    }

    /**
     * 处理数据
     * 
     * @param entity
     * @return
     */
    public static hash(message: Int8Array): Int8Array {
        const IV: number[] = [0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600, 0xa96f30bc, 0x163138aa, 0xe38dee4d, 0xb0fb0e4e];

        const forlength: bigint = BigInt(message.length) >> BigInt(6);
        const handByte: Int8Array = new Int8Array(64);
        const groupbyA: number[] = new Array(68);



        for (let index = 0n; index < forlength; index++) {

            handByte.set(message.subarray(Number(index << BigInt(6)), Number(index << BigInt(6)) + 64));


            for (let i = 0; i < 64; i += 4) {

                groupbyA[i >> 2] = (handByte[i] & 0xff) << 24 | (handByte[i + 1] & 0xff) << 16
                    | (handByte[i + 2] & 0xff) << 8 | handByte[i + 3] & 0xff;
            }

            let a: number = IV[0];
            let b: number = IV[1];
            let c: number = IV[2];
            let d: number = IV[3];
            let e: number = IV[4];
            let f: number = IV[5];
            let g: number = IV[6];
            let h: number = IV[7];

            let ss1: number, ss2: number, tt1: number, tt2: number;
            let j: number = 0;
            for (; j < 52; j++) {
                groupbyA[j + 16] = this.p1(groupbyA[j] ^ groupbyA[j + 7] ^ this.rotateLeft(groupbyA[j + 13], 15, 17)) ^ this.rotateLeft(groupbyA[j + 3], 7, 25) ^ groupbyA[j + 10];

                ss1 = this.rotateLeft((this.rotateLeft(a, 12, 20) + e + this.rotateLeft(this.Tj[j < 16 ? 0 : 1], j, 32 - j)), 7, 25);
                ss2 = ss1 ^ this.rotateLeft(a, 12, 20);

                if (j < 16) {
                    tt1 = (a ^ b ^ c) + d + ss2 + (groupbyA[j] ^ groupbyA[j + 4]);
                    tt2 = (e ^ f ^ g) + h + ss1 + groupbyA[j];
                } else {
                    tt1 = ((a & b) | (a & c) | (b & c)) + d + ss2 + (groupbyA[j] ^ groupbyA[j + 4]);
                    tt2 = ((e & f) | (~e & g)) + h + ss1 + groupbyA[j];
                }

                d = c;
                c = this.rotateLeft(b, 9, 23);
                b = a;
                a = tt1;
                h = g;
                g = this.rotateLeft(f, 19, 13);
                f = e;
                e = tt2 ^ this.rotateLeft(tt2, 9, 23) ^ this.rotateLeft(tt2, 17, 15);
            }

            for (; j < 64; j++) {
                ss1 = this.rotateLeft((this.rotateLeft(a, 12, 20) + e + this.rotateLeft(this.Tj[j < 16 ? 0 : 1], j, 32 - j)), 7, 25);
                ss2 = ss1 ^ this.rotateLeft(a, 12, 20);
                tt1 = ((a & b) | (a & c) | (b & c)) + d + ss2 + (groupbyA[j] ^ groupbyA[j + 4]);
                tt2 = ((e & f) | (~e & g)) + h + ss1 + groupbyA[j];

                d = c;
                c = this.rotateLeft(b, 9, 23);
                b = a;
                a = tt1;
                h = g;
                g = this.rotateLeft(f, 19, 13);
                f = e;
                e = tt2 ^ this.rotateLeft(tt2, 9, 23) ^ this.rotateLeft(tt2, 17, 15);
            }

            IV[0] ^= a;
            IV[1] ^= b;
            IV[2] ^= c;
            IV[3] ^= d;
            IV[4] ^= e;
            IV[5] ^= f;
            IV[6] ^= g;
            IV[7] ^= h;


        }



        const result: Int8Array = new Int8Array(32);
        for (let i = 0; i < 8; i++) {
            this.intToByteArray(IV[i], result, i << 2);
        }
        return result;
    }

    /**
     * 转数据
     * @param value 
     * @param byteArray 
     * @param offset 
     */
    private static intToByteArray(value: number, byteArray: Int8Array, offset: number) {
        byteArray[offset] = (value >>> 24) & 0xff;
        byteArray[offset + 1] = (value >>> 16) & 0xff;
        byteArray[offset + 2] = (value >>> 8) & 0xff;
        byteArray[offset + 3] = value & 0xff;
    }


    /**
     * 加密
     * @param object 
     * @returns 
     */
    public static encryption(object: any): string {

        let byteArray: Int8Array | null = null;

        if (typeof object === 'number' || typeof object === 'string') {
            byteArray = new Int8Array(new TextEncoder().encode(object.toString()));
        } else if (object instanceof File) {


            const reader = new FileReader();
            reader.readAsArrayBuffer(object);
            byteArray = new Int8Array(reader.result as ArrayBuffer);

        } else if (Array.isArray(object) && object.every((el) => typeof el === 'number')) {
            byteArray = new Int8Array(object);
        }

        if (byteArray) {

            return ArrayUtils.bytesToHex(this.hash(this.padding(byteArray)));
        }

        return '';
    }
}
风殇无极
关注
专栏目录
国密 sm系列 java实现_国密标准SM3算法，java实现
weixin_29463881的博客
02-27 1824
SM3算法对标国际标准MD5和SHA1算法，算法更安全下面直接上代码：/*** SM3杂凑算法* @author Administrator**/public class SM3 {//hash值byte长度private static final int HASH_LENGTH_BYTE = 32;//hash值WORD长度private static final int HASH_LENGTH...
国密SM3算法实现源代码（只适合JAVA）
01-11
国密SM3算法的Java实现，可以与bc很好的结合，实现国密算法扩展。已经用SM3算法标准中的示例数据进行验证，两组示例数据对比测试完全正确。 附带工具类实现方式,费了两天的时候搞出来的,100%对比正确.
Java实现常用加密算法 —— SM3
最新发布
m0_46713218的博客
08-11 1996
在商用密码体系中，SM3主要用于数字签名及验证、消息认证码生成及验证、随机数生成等，其算法公开。据国家密码管理局表示，其安全性及效率与SHA-256相当。本篇主要介绍SM3算法在Java（JDK1.8）中如何实现，借助Java标准库或第三方库，非原始实现，较为基础。一、SM3是什么？SM3算法是一种密码散列函数标准，‌由国家密码管理局发布，‌其安全性和SHA-256相当。‌这种算法主要用于商用密码应用中的数字签名和验证、‌消息认证码生成和验证、‌随机数生成等。
Java实现的SM3算法(java源代码)
07-16
Java实现的SM3算法(java源代码),详细内容见java类
SM3算法C语言源码
01-09
国家密码管理局的SM3算法标准的C语言源码，此代码的计算结果经过国家密码管理局商用密码检测中心的测试，代码简洁，易用性强。
SM3 python代码
mandiheyanyu的博客
04-26 1090
实际上sm3是一个哈希加密算法，也就是能加密，但是不能解密，不管多长的串扔进去都是64位十六进制数，相同的内容加密后得到的结果必然相同。（所以说看到文心一言说到对称加密就可以判定它在胡说八道了）问了问文心一言SM3是什么，我觉得它在胡说八道，贴出来给大家看看（放图片是怕污染大家的搜索）
SM3 Verilog代码
09-27
编译成功且优化过的SM3代码。Verilog 硬件描述语言编写，modelsim仿真验证过的代码。
Java体系知识之Echarts&跨域访问&Vue脚手架
qq_45464872的博客
12-01 473
Java体系知识之Echarts&跨域访问&Vue脚手架 1 Echarts 1.1 技术简介 1.2 案例 2 跨域访问（重点） 2.1 错误信息 2.2 跨域访问 2.3 省市区案例-改造 2.3
python实现RsaWithSHA256签名以及国密Sm3WithSm2签名
weixin_45005677的博客
01-10 2867
【代码】python实现RsaWithSHA256签名以及国密Sm3WithSm2签名。
区块链中的数学（四十五）---国密sm2公钥恢复
w_vc_love的专栏
10-19 1225
写在前面 上一节说了基于椭圆曲线的VRF证明验证过程，有朋友反映有些跳跃，说明前面椭圆曲线基础文章还需要在看看，空中楼阁，镜花水月都会给人一种不踏实的感觉。基础打好，才能稳定提升！ 之前的文章详细说明了secp256k1公钥恢复和sm2相关内容，依然有很多朋友在咨询sm2的公钥恢复，本来不打算写这方面了，因为有了之前的文章，sm2公钥恢复基本可以照搬，只是一些细节上的不同，这是因为sm2签名过程与secp256k1略有区别造成的。 鉴于很多人关心，本节详细说说！ sm2签名恢复过程 首先sm2可恢复公钥
Java基础篇二 视频来源:https://www.bilibili.com/video/BV12J41137hu?p=33&spm_id_from=pageDriver
xuruhua的博客
06-24 4494
一、Java流程控制 1、scanner 二、Java方法详解 三、类和对象 1、类和对象的关系 2、构造函数:(1)、使用new关键字必须使用构造器,否则会报错;new一个对象本质是在调用构造器 (2)一旦定义了又参构造,无参就必须显示定义 (3)构造器一般用来初始化值(alt+inser自动生成构造器) 构造器:1、和类名相同;2、没有返回值 作用:1、new本质在调用构造方法 注意点:定义有参构造后,如果想使用无参构造,显示的
国密SM3算法实现源代码（JAVA版）
10-18
国密SM3杂凑算法的Java实现，基于bouncycastle的中定义的ExtendedDigest接口，依赖于bc的GeneralDigest抽象类，可以与bc很好的结合，实现国密算法扩展。已经用SM3算法标准中的示例数据进行验证，两组示例数据对比测试完全正确。 依赖bouncycastle，自己去下载bouncycastle的jar包。
国密SM3算法VC6工程代码
11-15
国密SM3算法的VC6工程C代码，仅供参考 SM3 消息摘要。可以用MD5作为对比理解。该算法已公开。校验结果为256位。
java实现国密sm3算法程序
04-24
用java实现的国密sm3算法程序，经过大量的测试，结果完全正确。程序里面有测试程序。
国密Sm3验证工具纯JAVA方法编辑（附带源码）
12-27
验证工具使用方法点击运行 status.bat 文件即可运行该验证工具，若无法运行请首先确定是否配置好Java所需的环境变量，并安装好java虚拟机
省市二级联动数据库生成代码（JAVA）
热门推荐
张旭乾 - 全栈工程师/海归
08-27 6万+
最近在给一客户做网站，用的是php，现在需要有一个下拉框选择省市，并且需要保存省市的简拼，如“河北 HB”。我在网上找了半天，发现基本没有符合要求的代码，于是自己顶着浪费巨大时间的风险，动手写了一个自动生成省市二级联动insert语句的代码。由于时间仓促，自己的水平也有限，所以写的代码基本谈不上是合理的，可维护，可扩展的。我在此仅提供一个具体的思路，想把它写的漂亮点，还请广大朋友们跟据自己的需要进
C/C++ SM3算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-09 2910
SM3算法是中国国家密码管理局（National Cryptographic Authority）于2010年发布的一种哈希函数算法。它是一种基于Merkle-Damgård结构的密码杂凑算法，适用于数字签名、认证协议、密钥交换协议等安全协议中的消息完整性检测。SM3算法的输入和输出都是256位长的比特串。它将输入分为512位的消息块，并通过迭代进行处理。主要包括预处理、压缩函数和迭代执行三个步骤。
国密算法 SM3 消息摘要 杂凑算法 哈希函数 散列函数 python实现完整代码
qq_43339242的博客
03-24 1万+
国密算法 SM2 公钥加密 非对称加密 数字签名 密钥协商 python实现完整代码 依次分享完SM2和SM4的python实现代码，今天分享SM3
java实现sm3
weixin_43706224的博客
02-15 399
【代码】java实现sm3。
sm2&sm3&sm4国密算法c语言实现
07-04
SM2是一种国家密码算法标准，由中国国家密码管理局研发。它是一种非对称密码算法，用于数字签名和密钥交换。SM2基于椭圆曲线密码学，采用了比较高的安全性等级，能够满足各种密码应用的需求。 SM2具有以下特点： 1. 安全性：SM2采用了256位的椭圆曲线，具有较高的安全性。它能够抵抗常见的密码攻击，如穷举搜索和离散对数攻击。 2. 效率高：相比于其他非对称密码算法，SM2的计算效率较高。它能够在较短的时间内完成签名和验证操作，适合大规模的应用场景。 3. 自主知识产权：SM2是中国自主研发的密码算法，拥有完全的自主知识产权。这对于确保国家信息安全非常重要，也能够为其他国家提供可信的密码技术解决方案。 4. 兼容性：SM2被广泛应用于各种密码应用中，如电子身份验证、电子支付和电子合同等。它与其他国际公认的密码算法标准兼容性良好，可以与其他系统进行互操作。 总之，SM2是一种安全、高效、自主知识产权的非对称密码算法，具有广泛的应用前景。在当前信息安全形势严峻的背景下，SM2的发展和应用对于保护国家和个人的隐私和安全至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

风殇无极

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

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

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

打赏作者

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

抵扣说明：

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

余额充值