.net SM4国密算法实现与JavaJavascript互通

最新推荐文章于 2024-06-13 13:41:07 发布
最新推荐文章于 2024-06-13 13:41:07 发布
阅读量1.4k 收藏 1
点赞数 2
文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Elvis_lq/article/details/110475289
版权

sm4.cs 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CountNet.Interface.InsurerSystem.VehicleInsurance.Components
{
    public class Sm4
    {
        public const int SM4_ENCRYPT = 1;
        public const int SM4_DECRYPT = 0;

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

        public int ArrayConversionInt(byte e) 
        {
            int aa = e;
            if (e > 128)
            {
                aa = aa - 256;
            }
            else 
            {

            }
            return aa;
        }
        private void PUT_ULONG_BE(long n, byte[] b, int i)
        {
            b[i] = (byte)(int)(0xFF & n >> 24);
            b[i + 1] = (byte)(int)(0xFF & n >> 16);
            b[i + 2] = (byte)(int)(0xFF & n >> 8);
            b[i + 3] = (byte)(int)(0xFF & n);
        }
        
        private long SHL(long x, int n)
        {
            return ArrayConversion((x & 0xFFFFFFFF) << n);
        }

        private long ROTL(long x, int n)
        {
            return ArrayConversion(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;
        }

        public byte[] SboxTable = new byte[] { (byte) 0xd6, (byte) 0x90, (byte) 0xe9, (byte) 0xfe,
            (byte) 0xcc, (byte) 0xe1, 0x3d, (byte) 0xb7, 0x16, (byte) 0xb6,
            0x14, (byte) 0xc2, 0x28, (byte) 0xfb, 0x2c, 0x05, 0x2b, 0x67,
            (byte) 0x9a, 0x76, 0x2a, (byte) 0xbe, 0x04, (byte) 0xc3,
            (byte) 0xaa, 0x44, 0x13, 0x26, 0x49, (byte) 0x86, 0x06,
            (byte) 0x99, (byte) 0x9c, 0x42, 0x50, (byte) 0xf4, (byte) 0x91,
            (byte) 0xef, (byte) 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43,
            (byte) 0xed, (byte) 0xcf, (byte) 0xac, 0x62, (byte) 0xe4,
            (byte) 0xb3, 0x1c, (byte) 0xa9, (byte) 0xc9, 0x08, (byte) 0xe8,
            (byte) 0x95, (byte) 0x80, (byte) 0xdf, (byte) 0x94, (byte) 0xfa,
            0x75, (byte) 0x8f, 0x3f, (byte) 0xa6, 0x47, 0x07, (byte) 0xa7,
            (byte) 0xfc, (byte) 0xf3, 0x73, 0x17, (byte) 0xba, (byte) 0x83,
            0x59, 0x3c, 0x19, (byte) 0xe6, (byte) 0x85, 0x4f, (byte) 0xa8,
            0x68, 0x6b, (byte) 0x81, (byte) 0xb2, 0x71, 0x64, (byte) 0xda,
            (byte) 0x8b, (byte) 0xf8, (byte) 0xeb, 0x0f, 0x4b, 0x70, 0x56,
            (byte) 0x9d, 0x35, 0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, (byte) 0xd1,
            (byte) 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, (byte) 0x87,
            (byte) 0xd4, 0x00, 0x46, 0x57, (byte) 0x9f, (byte) 0xd3, 0x27,
            0x52, 0x4c, 0x36, 0x02, (byte) 0xe7, (byte) 0xa0, (byte) 0xc4,
            (byte) 0xc8, (byte) 0x9e, (byte) 0xea, (byte) 0xbf, (byte) 0x8a,
            (byte) 0xd2, 0x40, (byte) 0xc7, 0x38, (byte) 0xb5, (byte) 0xa3,
            (byte) 0xf7, (byte) 0xf2, (byte) 0xce, (byte) 0xf9, 0x61, 0x15,
            (byte) 0xa1, (byte) 0xe0, (byte) 0xae, 0x5d, (byte) 0xa4,
            (byte) 0x9b, 0x34, 0x1a, 0x55, (byte) 0xad, (byte) 0x93, 0x32,
            0x30, (byte) 0xf5, (byte) 0x8c, (byte) 0xb1, (byte) 0xe3, 0x1d,
            (byte) 0xf6, (byte) 0xe2, 0x2e, (byte) 0x82, 0x66, (byte) 0xca,
            0x60, (byte) 0xc0, 0x29, 0x23, (byte) 0xab, 0x0d, 0x53, 0x4e, 0x6f,
            (byte) 0xd5, (byte) 0xdb, 0x37, 0x45, (byte) 0xde, (byte) 0xfd,
            (byte) 0x8e, 0x2f, 0x03, (byte) 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b,
            0x51, (byte) 0x8d, 0x1b, (byte) 0xaf, (byte) 0x92, (byte) 0xbb,
            (byte) 0xdd, (byte) 0xbc, 0x7f, 0x11, (byte) 0xd9, 0x5c, 0x41,
            0x1f, 0x10, 0x5a, (byte) 0xd8, 0x0a, (byte) 0xc1, 0x31,
            (byte) 0x88, (byte) 0xa5, (byte) 0xcd, 0x7b, (byte) 0xbd, 0x2d,
            0x74, (byte) 0xd0, 0x12, (byte) 0xb8, (byte) 0xe5, (byte) 0xb4,
            (byte) 0xb0, (byte) 0x89, 0x69, (byte) 0x97, 0x4a, 0x0c,
            (byte) 0x96, 0x77, 0x7e, 0x65, (byte) 0xb9, (byte) 0xf1, 0x09,
            (byte) 0xc5, 0x6e, (byte) 0xc6, (byte) 0x84, 0x18, (byte) 0xf0,
            0x7d, (byte) 0xec, 0x3a, (byte) 0xdc, 0x4d, 0x20, 0x79,
            (byte) 0xee, 0x5f, 0x3e, (byte) 0xd7, (byte) 0xcb, 0x39, 0x48 };
        public uint[] FK = { 0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc };
        public uint[] CK = { 0x00070e15,0x1c232a31,0x383f464d,0x545b6269,
                                        0x70777e85,0x8c939aa1,0xa8afb6bd,0xc4cbd2d9,
                                        0xe0e7eef5,0xfc030a11,0x181f262d,0x343b4249,
                                        0x50575e65,0x6c737a81,0x888f969d,0xa4abb2b9,
                                        0xc0c7ced5,0xdce3eaf1,0xf8ff060d,0x141b2229,
                                        0x30373e45,0x4c535a61,0x686f767d,0x848b9299,
                                        0xa0a7aeb5,0xbcc3cad1,0xd8dfe6ed,0xf4fb0209,
                                        0x10171e25,0x2c333a41,0x484f565d,0x646b7279 };
        private byte sm4Sbox(byte inch)
        {
            int i = inch & 0xFF;
            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];
            PUT_ULONG_BE(ka, a, 0);
            b[0] = sm4Sbox(a[0]);
            b[1] = sm4Sbox(a[1]);
            b[2] = sm4Sbox(a[2]);
            b[3] = sm4Sbox(a[3]);
            bb = GET_ULONG_BE(b, 0);
            c = bb ^ ROTL(bb, 2) ^ ROTL(bb, 10) ^ ROTL(bb, 18) ^ ROTL(bb, 24);
            return c;
        }
        private long sm4F(long x0, long x1, long x2, long x3, long rk)
        {
            return x0 ^ 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];
            PUT_ULONG_BE(ka, a, 0);
            b[0] = sm4Sbox(a[0]);
            b[1] = sm4Sbox(a[1]);
            b[2] = sm4Sbox(a[2]);
            b[3] = sm4Sbox(a[3]);
            bb = GET_ULONG_BE(b, 0);
            long cc = ROTL(bb, 13);
            long dd = ROTL(bb, 23);
            rk = bb ^ cc ^ dd;
            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] = GET_ULONG_BE(key, 0);
            MK[1] = GET_ULONG_BE(key, 4);
            MK[2] = GET_ULONG_BE(key, 8);
            MK[3] = GET_ULONG_BE(key, 12);
            k[0] = ArrayConversion(MK[0] ^ (long)FK[0]);
            k[1] = ArrayConversion(MK[1] ^ (long)FK[1]);
            k[2] = ArrayConversion(MK[2] ^ (long)FK[2]);
            k[3] = ArrayConversion(MK[3] ^ (long)FK[3]);
            for (; i < 32; i++)
            {
                k[(i + 4)] = k[i] ^ sm4CalciRK(k[(i + 1)] ^ k[(i + 2)] ^ k[(i + 3)] ^ (long)CK[i]);
                SK[i] = k[(i + 4)];
            }
        }

        public long ArrayConversion(long k) 
        {
            long kr = 0;
            if (k > 2147483648)
            {
                kr = k - 4294967296;
            }
            else 
            {
                kr = k;
            }
            return kr;
        }

        private void sm4_one_round(long[] sk, byte[] input, byte[] output)
        {
            int i = 0;
            long[] ulbuf = new long[36];
            ulbuf[0] = GET_ULONG_BE(input, 0);
            ulbuf[1] = GET_ULONG_BE(input, 4);
            ulbuf[2] = GET_ULONG_BE(input, 8);
            ulbuf[3] = GET_ULONG_BE(input, 12);
            while (i < 32)
            {
                ulbuf[(i + 4)] = sm4F(ulbuf[i], ulbuf[(i + 1)], ulbuf[(i + 2)], ulbuf[(i + 3)], sk[i]);
                i++;
            }
            PUT_ULONG_BE(ulbuf[35], output, 0);
            PUT_ULONG_BE(ulbuf[34], output, 4);
            PUT_ULONG_BE(ulbuf[33], output, 8);
            PUT_ULONG_BE(ulbuf[32], output, 12);
        }

        private byte[] padding(byte[] input, int mode)
        {
            if (input == null)
            {
                return null;
            }

            byte[] ret = (byte[])null;
            if (mode == SM4_ENCRYPT)
            {
                int p = 16 - input.Length % 16;
                ret = new byte[input.Length + p];
                Array.Copy(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];
                Array.Copy(input, 0, ret, 0, input.Length - p);
            }
            return ret;
        }

        public void sm4_setkey_enc(Sm4Context ctx, byte[] key)
        {
            ctx.mode = SM4_ENCRYPT;
            sm4_setkey(ctx.sk, key);
        }

        public void sm4_setkey_dec(Sm4Context ctx, byte[] key)
        {
            int i = 0;
            ctx.mode = SM4_DECRYPT;
            sm4_setkey(ctx.sk, key);
            for (i = 0; i < 16; i++)
            {
                SWAP(ctx.sk, i);
            }
        }

        public byte[] sm4_crypt_ecb(Sm4Context ctx, byte[] input)
        {
            if ((ctx.isPadding) && (ctx.mode == SM4_ENCRYPT))
            {
                input = padding(input, SM4_ENCRYPT);
            }

            int length = input.Length;
            byte[] bins = new byte[length];
            Array.Copy(input, 0, bins, 0, length);
            byte[] bous = new byte[length];
            for (int i = 0; length > 0; length -= 16, i++)
            {
                byte[] inBytes = new byte[16];
                byte[] outBytes = new byte[16];
                Array.Copy(bins, i * 16, inBytes, 0, length > 16 ? 16 : length);
                sm4_one_round(ctx.sk, inBytes, outBytes);
                Array.Copy(outBytes, 0, bous, i * 16, length > 16 ? 16 : length);
            }

            if (ctx.isPadding && ctx.mode == SM4_DECRYPT)
            {
                bous = padding(bous, SM4_DECRYPT);
            }
            return bous;
        }

        public byte[] sm4_crypt_cbc(Sm4Context ctx, byte[] iv, byte[] input)
        {
            if (ctx.isPadding && ctx.mode == SM4_ENCRYPT)
            {
                input = padding(input, SM4_ENCRYPT);
            }

            int i = 0;
            int length = input.Length;
            byte[] bins = new byte[length];
            Array.Copy(input, 0, bins, 0, length);
            byte[] bous = null;
            List<byte> bousList = new List<byte>();
            if (ctx.mode == SM4_ENCRYPT)
            {
                int j = 0;
                for (; length > 0; length -= 16)
                {
                    byte[] inBytes = new byte[16];
                    byte[] outBytes = new byte[16];
                    byte[] out1 = new byte[16];
                    Array.Copy(bins, j * 16, inBytes, 0, length > 16 ? 16 : length);
                    for (i = 0; i < 16; i++)
                    {
                        outBytes[i] = ((byte)(inBytes[i] ^ iv[i]));
                    }
                    sm4_one_round(ctx.sk, outBytes, out1);
                    Array.Copy(out1, 0, iv, 0, 16);
                    for (int k = 0; k < 16; k++)
                    {
                        bousList.Add(out1[k]);
                    }
                    j++;
                }
            }
            else
            {
                byte[] temp = new byte[16];
                for (int j = 0; length > 0; length -= 16, j++)
                {
                    byte[] inBytes = new byte[16];
                    byte[] outBytes = new byte[16];
                    byte[] out1 = new byte[16];


                    Array.Copy(bins, i * 16, inBytes, 0, length > 16 ? 16 : length);
                    Array.Copy(inBytes, 0, temp, 0, 16);
                    sm4_one_round(ctx.sk, inBytes, outBytes);
                    for (i = 0; i < 16; i++)
                    {
                        out1[i] = ((byte)(outBytes[i] ^ iv[i]));
                    }
                    Array.Copy(temp, 0, iv, 0, 16);
                    for (int k = 0; k < 16; k++)
                    {
                        bousList.Add(out1[k]);
                    }
                }
            }

            if (ctx.isPadding && ctx.mode == SM4_DECRYPT)
            {
                bous = padding(bousList.ToArray(), SM4_DECRYPT);
                return bous;
            }
            else
            {
                return bousList.ToArray();
            }
        }
    }
}
 

 Sm4Context.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CountNet.Interface.InsurerSystem.VehicleInsurance.Components
{
    public class Sm4Context
    {
        public int mode;
        public long[] sk;
        public bool isPadding;
        public Sm4Context()
        {
            this.mode = 1;
            this.isPadding = true;
            this.sk = new long[32];
        }
    }
}

 SM4Encrypt.cs

 

using Org.BouncyCastle.Utilities.Encoders;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace CountNet.Interface.InsurerSystem.VehicleInsurance.Components
{
    public class SM4Encrypt
    {
        /// <summary>
        /// 加密ECB模式
        /// </summary>
        /// <param name="secretKey">密钥</param>
        /// <param name="hexString">明文是否是十六进制</param>
        /// <param name="plainText">明文</param>
        /// <returns>返回密文</returns>
        public static string Encrypt_ECB(String secretKey, bool hexString, String plainText)
        {
            Sm4Context ctx = new Sm4Context();
            ctx.isPadding = true;
            ctx.mode = Sm4.SM4_ENCRYPT;
            byte[] keyBytes;
            if (hexString)
            {
                keyBytes = Hex.Decode(secretKey);
            }
            else
            {
                keyBytes = Encoding.Default.GetBytes(secretKey);
            }
            Sm4 sm4 = new Sm4();
            sm4.sm4_setkey_enc(ctx, keyBytes);
            byte[] encrypted = sm4.sm4_crypt_ecb(ctx, Encoding.Default.GetBytes(plainText));
            String cipherText = Encoding.Default.GetString(Hex.Encode(encrypted));
            return cipherText;
        }

        /// <summary>
        /// 解密ECB模式
        /// </summary>
        /// <param name="secretKey">密钥</param>
        /// <param name="hexString">明文是否是十六进制</param>
        /// <param name="cipherText">密文</param>
        /// <returns>返回明文</returns>
        public static String Decrypt_ECB(String secretKey, bool hexString, String cipherText)
        {
            Sm4Context ctx = new Sm4Context();
            ctx.isPadding = true;
            ctx.mode = Sm4.SM4_DECRYPT;

            byte[] keyBytes;
            if (hexString)
            {
                keyBytes = Hex.Decode(secretKey);
            }
            else
            {
                keyBytes = Encoding.Default.GetBytes(secretKey);
            }

            Sm4 sm4 = new Sm4();
            sm4.sm4_setkey_dec(ctx, keyBytes);
            byte[] decrypted = sm4.sm4_crypt_ecb(ctx, Hex.Decode(cipherText));
            return Encoding.Default.GetString(decrypted);
        }

        /// <summary>
        /// 加密CBC模式
        /// </summary>
        /// <param name="secretKey">密钥</param>
        /// <param name="hexString">明文是否是十六进制</param>
        /// <param name="iv"></param>
        /// <param name="plainText">明文</param>
        /// <returns>返回密文</returns>
        public static String Encrypt_CBC(String secretKey, bool hexString, string iv, String plainText)
        {
            Sm4Context ctx = new Sm4Context();
            ctx.isPadding = true;
            ctx.mode = Sm4.SM4_ENCRYPT;
            byte[] keyBytes;
            byte[] ivBytes;
            if (hexString)
            {
                keyBytes = Hex.Decode(secretKey);
                ivBytes = Hex.Decode(iv);
            }
            else
            {
                keyBytes = Convert.FromBase64String(secretKey);
                ivBytes = Convert.FromBase64String(iv);
            }
            Sm4 sm4 = new Sm4();
            sm4.sm4_setkey_enc(ctx, keyBytes);
            byte[] encrypted = sm4.sm4_crypt_cbc(ctx, ivBytes, Encoding.UTF8.GetBytes(plainText));
            String cipherText = Convert.ToBase64String(encrypted);
            if (cipherText != null && cipherText.Length > 0) {
                cipherText = Regex.Replace(cipherText, @"/(\s*|\t|\r|\n)/g","");
            }
            return cipherText;
        }

        

        /// <summary>
        /// 解密CBC模式
        /// </summary>
        /// <param name="secretKey">密钥</param>
        /// <param name="hexString">明文是否是十六进制</param>
        /// <param name="iv"></param>
        /// <param name="cipherText">密文</param>
        /// <returns>返回明文</returns>
        public static String Decrypt_CBC(String secretKey, bool hexString, string iv, String cipherText)
        {
            Sm4Context ctx = new Sm4Context();
            ctx.isPadding = true;
            ctx.mode = Sm4.SM4_DECRYPT;
            byte[] keyBytes;
            byte[] ivBytes;
            if (hexString)
            {
                keyBytes = Hex.Decode(secretKey);
                ivBytes = Hex.Decode(iv);
            }
            else
            {
                keyBytes = Encoding.Default.GetBytes(secretKey);
                ivBytes = Encoding.Default.GetBytes(iv);
            }
            Sm4 sm4 = new Sm4();
            sm4.sm4_setkey_dec(ctx, keyBytes);
            byte[] decrypted = sm4.sm4_crypt_cbc(ctx, ivBytes, Hex.Decode(cipherText));
            return Encoding.Default.GetString(decrypted);
        }
    }
}

Elvis_lq
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
国密SM4，layui前端 和.net core后台 加密解密 .net加密解密
03-22
前端JS，后台用到的类
SM4加密算法实现Java和C#相互加密解密
lutan20的博客
10-12 2387
SM4加密算法实现Java和C#相互加密解密     近期由于项目需要使用SM4对数据进行加密，然后传给Java后台，Java后台使用的也是SM4的加密算法但是就是解密不正确，经过一步步调试发现Java中好多数据类型与C#的相同的数据类型是存在不同的比如：byte在Java中范围是-127~128，而C#中的范围是0~255，这就导致使用C#的加密的明文产生的密文到Java中解...
.NET C# 实现国密算法加解密
最新发布
小小程序猿
06-13 1167
国密算法（SM算法）是中国国家密码管理局制定的一系列密码算法标准。这些算法被广泛应用于各种信息安全领域，包括通信、电子商务、金融等。
csharp用BouncyCastle进行国密签名&加解密
pridas的博客
10-19 5236
using System; using System.Collections.Generic; using System.Linq; using System.Web; using Org.BouncyCastle.Asn1.X9; using Org.BouncyCastle.Asn1.GM; using Org.BouncyCastle.Crypto.Parameters; using Org.BouncyCastle.Crypto; using Org.BouncyCastle.Security; u
【进阶之路】SM4国密算法与实现
runshui27的博客
03-04 408
https://blog.csdn.net/ryc1995/article/details/106364122?spm=1001.2101.3001.6650.16&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7ERate-16.queryctrv4&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7
C#实现 国密SM4/ECB/PKCS5Padding对称加密Java加解密
qq_41197516的博客
08-04 2637
16进制的加密字符串（忽略大小写）// PKCS5Padding-以8个字节为一组进行分组加密。// 定义分组加密模式使用：PKCS5Padding。// 128-32位16进制；* 16进制加密后的字符串。// 自定义的32位16进制密钥。* @explain sm4加密、解密与加密结果验证。* @return 返回16进制的加密字符串。// 16进制字符串-->byte[]// 加密算法/分组加密模式/分组填充方式。// 将原字符串转换成byte[]
算法：用Javajavascript解决的算法-acmicpcprogrammers
02-11
本资源“算法：用Java和JavaScript解决的算法-acmicpcprogrammers”聚焦于通过这两种编程语言来理解和实现各种算法。Seongwoon Jeong显然是一个专注于算法解决的开发者，他可能在该资源中分享了他的解决方案和经验。...
data-structures-and-algorithms:使用C ++ JavaJavaScript实现数据结构和算法
04-30
该存储库包含与数据结构和用JavaScript / Node.js / C ++编写的算法有关的计算机程序。 请点击顶部的星号按钮以使其更易访问。 前进。 安装 Nodejs的 只需在计算机上安装Node.js。 安装Node.js。 克隆/下载文件夹。...
ljs：使用CC ++ JavaJavascript语法的Lua
02-03
标题 "ljs：使用CC++ JavaJavascript语法的Lua" 提示我们关注的是一个名为"Ljs"的项目，它扩展了Lua语言，使其支持类似于CC++、Java和JavaScript的语法特性。这个项目可能旨在提高Lua的易用性和兼容性，使得熟悉这些...
UglifyJS-java:适用于JavaJavaScript解析器mangler压缩器美化库
05-18
### UglifyJS-java-JavaJavaScript解析器/ mangler /压缩器/美化器库###关于：原始的基于 ，但是很难与ant或maven自动集成，因此我将UglifyJS从node.js移到了Java平台上。 ###用法：java -jar uglifyjs-java.jar ...
client-api-gwt:捆绑有用的工具，用于使用GWT构建混合JavaJavaScript应用程序
05-18
【标题】"client-api-gwt:捆绑有用的工具，用于使用GWT构建混合JavaJavaScript应用程序" 在GWT（Google Web Toolkit）开发中，`client-api-gwt`是一个重要的资源，它提供了一系列工具，帮助开发者更有效地构建Java...
SM4国密算法（.net），适用于邮政EMS加密
weixin_40704848的博客
04-29 417
适用于.net环境下的国密加密方法，此方法可以拥有对接EMS新版本的加密鉴权
c# 基于BouncyCastle.Crypto的国密sm2，sm4封装，与java版本兼容
冻死的企鹅
08-19 5596
c# 基于BouncyCastle.Crypto的国密sm2，sm4封装，与java版本兼容。
java sm4国密算法 CBC模式 加解密工具类
热门推荐
not_say的博客
02-25 1万+
java sm4国密算法 CBC模式 加解密工具类说明maven依赖生成密钥加密解密测试完整代码最后 说明 工具类最开始是参考这篇博客java sm4国密算法加密、解密，但是该篇博客使用的是EBC模式，所以参考其他文章改成了CBC模式。由于本人并不专于算法和密码学，所以如果发现工具类存在问题或者可优化地方，欢迎评论处提出。 maven依赖 <!-- https://mvnrepository.com/artifact/org.bouncycastle/bcprov-jdk15on -->
国密算法（SM4）在C#里面的简单封装
wangkun998的博客
05-04 4458
基础需要第三方Nuget包：Portable.BouncyCastle；添加方法：右击项目名称，选择“管理Nuget程序包”，在搜索栏搜索Portable.BouncyCastle，选择安装。
C# 实现国密SM4加解密封装
谁念西风独自凉
12-28 3006
1.Portable.BouncyCastle 引入 右键解决方案的引用，选择管理NuGet程序包 在浏览的搜索框中搜索：“Portable.BouncyCastle” 选择第一个，在右侧点击安装即可完成程序包的引入。 2.SM4 2.1.SM4Context public class SM4Context { public int mode; public long[] sk; public bool isPadding..
SM4对称加密算法及Java实现
Brave_heart4pzj的博客
04-25 2120
https://blog.csdn.net/sunxmwebstudy/article/details/114699704
JavaScript学习 -- SM4算法应用实例
weixin_41489908的博客
08-02 3689
本文提供了一个实际的案例，展示了如何使用SM4算法对字符串进行加密和解密。根据您的实际需求，您可以选择更强大的密钥和更复杂的加密模式和填充方式，以增强数据的安全性和保护您的隐私。通过使用CryptoJS.SM4.encrypt方法对字符串进行加密，我们可以指定加密模式和填充方式来确保加密的安全性。在JavaScript中，我们可以通过使用CryptoJS库来实现SM4算法的加密和解密。请注意，在实际应用中，您应该选择更加强大的密钥，并根据需求使用更复杂的加密模式和填充方式，以增强加密和解密的安全性。
.net url参数全站加密_一次sm4参数加密下的sql盲注
weixin_33600376的博客
01-15 492
本文转自公众号：https://xz.aliyun.com/t/80710x00 前言  在一次授权渗透测试中，应用在前端使用sql语句拼接方式传送参数，很明显存在sql注入，提交漏洞后，用户大概不想重构项目，于是将前端参数传输前均进行加密，但是通过JS找到加密密钥后，结合py脚本还是注入了；后续用户再次升级将设计加密的JS也加密混淆了，不过还有办法找到密钥，借此分享，过程中踩坑绕弯，欢...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值