C# Org.BouncyCastle.Crypto 把jwt 加密

最新推荐文章于 2024-04-25 11:48:52 发布
最新推荐文章于 2024-04-25 11:48:52 发布
阅读量431 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Accpdaiyekun/article/details/132574204
版权 
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Crypto.Signers;
using Org.BouncyCastle.OpenSsl;
using Org.BouncyCastle.Security;
using System.Text;
using System.Text.RegularExpressions;

namespace SpaceNation.Game.Common.Jwt
{

    /// <summary>
    /// jwt Ed25519验证
    /// 具体程序使用这个验证
    /// </summary>
    public class JwtEd25519Verifier
    {
        /// <summary>
        /// 公钥key
        /// </summary>
        private static string sPublicKeyString =
            @"-----BEGIN PUBLIC KEY-----
            MCowBQYDK2VwAyEAr6Jb/03OVQNE2Mqq/kZVTPSQhPEst+qYbJpMgAQUwoA=
            -----END PUBLIC KEY-----
            ";

        #region 方法一

        public static bool VerifyJwtSignature(string jwt)
        {
            PemReader pemReader = new PemReader(new StringReader(sPublicKeyString));
            Ed25519PublicKeyParameters publicKeyParameters = (Ed25519PublicKeyParameters)pemReader.ReadObject();
            ISigner verifier = new Ed25519Signer();
            verifier.Init(false, publicKeyParameters);

            var parts = jwt.Split('.');
            string encodedHeader = parts[0];
            string encodedPayload = parts[1];
            string encodedSignature = parts[2];

            byte[] headerBytes = Base64UrlDecode(encodedHeader);
            byte[] payloadBytes = Base64UrlDecode(encodedPayload);
            byte[] signatureBytes = Base64UrlDecode(encodedSignature);

            byte[] data = Encoding.UTF8.GetBytes(encodedHeader + "." + encodedPayload);

            verifier.BlockUpdate(data, 0, data.Length);
            bool isValidSignature = verifier.VerifySignature(signatureBytes);

            return isValidSignature;
        }

        private static byte[] Base64UrlDecode(string input)
        {
            string base64 = input.Replace('-', '+').Replace('_', '/');

            while (base64.Length % 4 != 0)
            {
                base64 += '=';
            }

            return Convert.FromBase64String(base64);
        }

        #endregion

        #region 方法二
        private static string ClearStr2(string str)
        {
            // string base64PublicKey = Regex.Match(publicKey, @"-----BEGIN PUBLIC KEY-----(.*?)-----END PUBLIC KEY-----", RegexOptions.Singleline)?.Groups[1].Value.Trim();
            string base64PublicKey = str.Replace("-----BEGIN PUBLIC KEY-----", "").Replace("-----END PUBLIC KEY-----", "").Replace("\r", "").Replace("\n", "").Trim();
            return base64PublicKey;
        }
        private static byte[] Base64UrlDecode4(string input)
        {
            string base64 = input.Replace("\n", "").Replace("\r", "").Replace('-', '+').Replace('_', '/');

            while (base64.Length % 4 != 0)
            {
                base64 += '=';
            }

            return Convert.FromBase64String(base64);
        }
        public static bool VerifyJwtSignature22(string jwt)
        {
            try
            {
                var publicKeyBytes = Convert.FromBase64String(ClearStr2(sPublicKeyString));
                var parts = jwt.Split('.');
                string encodedHeader = ClearStr2(parts[0]);
                string encodedPayload = ClearStr2(parts[1]);
                byte[] signature = Base64UrlDecode4(parts[2]);
                byte[] data = Encoding.UTF8.GetBytes(encodedHeader + "." + encodedPayload);
                var publicKeyParams = new Ed25519PublicKeyParameters(publicKeyBytes, 0);
                var verifier = new Ed25519Signer();
                verifier.Init(false, publicKeyParams);
                verifier.BlockUpdate(data, 0, data.Length);
                return verifier.VerifySignature(signature);
            }
            catch (Exception ex)
            {
                return false;
            }
        }
        private static string ClearStr(string str)
        {
            string base64PublicKey = Regex.Match(sPublicKeyString, @"-----BEGIN PUBLIC KEY-----(.*?)-----END PUBLIC KEY-----", RegexOptions.Singleline)?.Groups[1].Value.Trim();
            base64PublicKey = base64PublicKey.Replace("-----BEGIN PUBLIC KEY-----", "").Replace("-----END PUBLIC KEY-----", "").Replace("\r", "").Replace("\n", "").Trim();
            return base64PublicKey;
        }
        public static bool IsVerfier(string jwt)
        {
            //string cleanedJwt = ExtractPublicKey(jwt); // 清理 JWT 字符串
            //string publicKeyString = ExtractPublicKey(sPublicKeyString); // 提取公钥字符串
            //byte[] publicKeyBytes = Encoding.UTF8.GetBytes(publicKeyString); // 使用公钥字符串转换为字节数组
            //var verifier = new JwtEd25519Verifier();
            //bool isValidSignature = verifier.VerifyJwtSignature(cleanedJwt, publicKeyBytes);
            PemReader pemReaderPublic = new PemReader(new StringReader(sPublicKeyString));
            Ed25519PublicKeyParameters ed25519x509Parameters = (Ed25519PublicKeyParameters)pemReaderPublic.ReadObject();
            ISigner verifier = new Ed25519Signer();
            verifier.Init(false, ed25519x509Parameters);
            var parts = jwt.Split('.');
            string encodedHeader = parts[0];
            string encodedPayload = parts[1];
            byte[] signature = Encoding.UTF8.GetBytes(parts[2]);
            byte[] data = Encoding.UTF8.GetBytes(encodedHeader + "." + encodedPayload);
            verifier.BlockUpdate(data, 0, data.Length);
            //verifier.BlockUpdate(dataToSign, 0, dataToSign.Length);
            bool isValidSignature = verifier.VerifySignature(signature);
            return isValidSignature;
        }

        private static string ExtractPublicKey(string publicKeyString)
        {
            string trimmedKey = publicKeyString
                .Replace("-----BEGIN PUBLIC KEY-----", "")
                .Replace("-----END PUBLIC KEY-----", "")
                .Replace("\n", "")
                .Replace("\r", "")
                .Replace(" ", "").Trim();
            return trimmedKey;
        }
        /// <summary>
        /// 验证调用方法
        /// 调用主函数
        /// </summary>
        /// <param name="jwt"></param>
        /// <returns></returns>
        //public static bool IsVerfier(string jwt)
        //{
        //    string cleanedJwt = ClearStr(jwt); // 清理 JWT 字符串
        //    byte[] publicKeyBytes = Convert.FromBase64String(sPublicKeyString); // 使用公钥字符串转换为字节数组
        //    var verifier = new JwtEd25519Verifier();
        //    bool isValidSignature = verifier.VerifyJwtSignature(cleanedJwt, publicKeyBytes);
        //    return isValidSignature;
        //}
        #endregion

        /// <summary>
        /// 获取jwt重要信息
        /// </summary>
        /// <param name="jwt">jwt</param>
        /// <returns></returns>
        public static Dictionary<string, object> ParseJwtPayload(string jwt)
        {
            var parts = jwt.Split('.');
            string encodedPayload = parts[1];
            byte[] payloadBytes = Convert.FromBase64String(encodedPayload);
            string payloadJson = Encoding.UTF8.GetString(payloadBytes);
            return JsonUtility.DeserializeObject<Dictionary<string, object>>(payloadJson);
        }
        /// <summary>
        /// 验证加解析
        /// 解析jwt
        /// </summary>
        /// <param name="jwt">jwt</param>
        /// <returns></returns>
        public static bool GetTryVerfierPayload(string jwt, out Dictionary<string, object>? payload)
        {
            bool isValidSignature = IsVerfier(jwt);
            if (isValidSignature)
            {
                payload = ParseJwtPayload(jwt);
                return true;
            }
            else
            {
                payload = null;
                return false;
            }
        }



    }
    /// <summary>
    /// Ed25519 验证
    /// 
    /// 测试而已
    /// </summary>
    public class Ed25519222
    {


        public void Example()
        {
            // 生成密钥对
            var keyPair = GenerateKeyPair();
            // 要签名的数据
            byte[] data = Encoding.UTF8.GetBytes("Hello, World!");
            // 使用私钥进行签名
            byte[] signature = SignData(data, keyPair.Private);
            // 使用公钥验证签名
            bool isValid = VerifySignature(data, signature, keyPair.Public);

        }
        private static AsymmetricCipherKeyPair GenerateKeyPair()
        {
            var keyPairGenerator = new Ed25519KeyPairGenerator();
            keyPairGenerator.Init(new Ed25519KeyGenerationParameters(new SecureRandom()));
            return keyPairGenerator.GenerateKeyPair();
        }

        private static byte[] SignData(byte[] data, AsymmetricKeyParameter privateKey)
        {
            var signer = new Ed25519Signer();
            signer.Init(true, privateKey);
            signer.BlockUpdate(data, 0, data.Length);
            return signer.GenerateSignature();
        }

        private static bool VerifySignature(byte[] data, byte[] signature, AsymmetricKeyParameter publicKey)
        {
            var verifier = new Ed25519Signer();
            verifier.Init(false, publicKey);
            verifier.BlockUpdate(data, 0, data.Length);
            return verifier.VerifySignature(signature);
        }

    }

    public static class JwtUtil
    {
        private static string publicKey = @"-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAr6Jb/03OVQNE2Mqq/kZVTPSQhPEst+qYbJpMgAQUwoA=
-----END PUBLIC KEY-----";

        public static bool VerifyJwtSignature(string jwt)
        {
            try
            {
                var parts = jwt.Split('.');
                if (parts.Length != 3)
                {
                    // Invalid JWT format
                    return false;
                }

                string encodedHeader = parts[0];
                string encodedPayload = parts[1];
                byte[] signature = Base64UrlDecode(parts[2]);

                string decodedHeader = Encoding.UTF8.GetString(Base64UrlDecode(encodedHeader));
                string decodedPayload = Encoding.UTF8.GetString(Base64UrlDecode(encodedPayload));

                using (TextReader reader = new StringReader(publicKey))
                {
                    var pemReader = new PemReader(reader);
                    var pemObject = pemReader.ReadObject();
                    var publicKeyParams = (Ed25519PublicKeyParameters)pemObject;

                    var verifier = new Ed25519Signer();
                    verifier.Init(false, publicKeyParams);

                    verifier.BlockUpdate(Encoding.UTF8.GetBytes(encodedHeader + "." + encodedPayload), 0, encodedHeader.Length + encodedPayload.Length);

                    bool isValidSignature = verifier.VerifySignature(signature);

                    return isValidSignature;
                }
            }
            catch (Exception)
            {
                return false;
            }
        }

        private static byte[] Base64UrlDecode(string input)
        {
            string base64 = input.Replace("\n", "").Replace("\r", "").Replace('-', '+').Replace('_', '/');

            while (base64.Length % 4 != 0)
            {
                base64 += '=';
            }

            return Convert.FromBase64String(base64);
        }

        public static bool isyq(string jwt)
        {
            string ed25519x509 = @"-----BEGIN PUBLIC KEY-----
                      MCowBQYDK2VwAyEA3mcwgf2DrWLR3mQ6l2d59bGU6qUStwQrln2+rKlKxoA=
                      -----END PUBLIC KEY-----";

            var parts = jwt.Split('.');

            if (parts.Length != 3)
            {
                // Invalid JWT format
                return false;
            }

            string encodedHeader = parts[0];
            string encodedPayload = parts[1];
            byte[] signature = Base64UrlDecode(parts[2]);
            var dataToSign = Encoding.UTF8.GetBytes(encodedHeader + "." + encodedPayload);

            using (TextReader reader = new StringReader(ed25519x509))
            {
                PemReader pemReaderPublic = new PemReader(reader);
                Ed25519PublicKeyParameters ed25519x509Parameters = (Ed25519PublicKeyParameters)pemReaderPublic.ReadObject();

                // Verify
                ISigner verifier = new Ed25519Signer();
                verifier.Init(false, ed25519x509Parameters);
                verifier.BlockUpdate(dataToSign, 0, dataToSign.Length);
                bool verified = verifier.VerifySignature(signature);
                return verified;
            }
        }
    }
    public static class JwtUtil2
    {
        private static string publicKey = @"-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAr6Jb/03OVQNE2Mqq/kZVTPSQhPEst+qYbJpMgAQUwoA=
-----END PUBLIC KEY-----";

        public static bool VerifyJwtSignature(string jwt)
        {
            try
            {
                var parts = jwt.Split('.');
                if (parts.Length != 3)
                {
                    // Invalid JWT format
                    return false;
                }

                string encodedHeader = parts[0];
                string encodedPayload = parts[1];
                byte[] signature = Base64UrlDecode2(parts[2]);

                string decodedHeader = Encoding.UTF8.GetString(Base64UrlDecode2(encodedHeader));
                string decodedPayload = Encoding.UTF8.GetString(Base64UrlDecode2(encodedPayload));

                using (TextReader reader = new StringReader(publicKey))
                {
                    var pemReader = new PemReader(reader);
                    var pemObject = pemReader.ReadObject();
                    var publicKeyParams = (Ed25519PublicKeyParameters)pemObject;

                    var verifier = new Ed25519Signer();
                    verifier.Init(false, publicKeyParams);

                    verifier.BlockUpdate(Encoding.UTF8.GetBytes(encodedHeader + "." + encodedPayload), 0, encodedHeader.Length + encodedPayload.Length);

                    bool isValidSignature = verifier.VerifySignature(signature);

                    return isValidSignature;
                }
            }
            catch (Exception)
            {
                return false;
            }
        }

        private static byte[] Base64UrlDecode2(string input)
        {
            string base64 = input.Replace("\n", "").Replace("\r", "").Replace('-', '+').Replace('_', '/');

            while (base64.Length % 4 != 0)
            {
                base64 += '=';
            }

            return Convert.FromBase64String(base64);
        }
    }

    public static class JwtUtil3
    {
        private static string publicKey = @"-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAr6Jb/03OVQNE2Mqq/kZVTPSQhPEst+qYbJpMgAQUwoA=
-----END PUBLIC KEY-----";

        public static bool VerifyJwtSignature3(string jwt)
        {
            try
            {
                var parts = jwt.Split('.');
                if (parts.Length != 3)
                {
                    // Invalid JWT format
                    return false;
                }

                string encodedHeader = parts[0];
                string encodedPayload = parts[1];
                byte[] signature = Base64UrlDecode3(parts[2]);

                string decodedHeader = Encoding.UTF8.GetString(Base64UrlDecode3(encodedHeader));
                string decodedPayload = Encoding.UTF8.GetString(Base64UrlDecode3(encodedPayload));

                using (TextReader reader = new StringReader(publicKey))
                {
                    var pemReader = new PemReader(reader);
                    var pemObject = pemReader.ReadObject();
                    var publicKeyParams = (Ed25519PublicKeyParameters)pemObject;

                    var verifier = new Ed25519Signer();
                    verifier.Init(false, publicKeyParams);

                    verifier.BlockUpdate(Encoding.UTF8.GetBytes(encodedHeader + "." + encodedPayload), 0, encodedHeader.Length + encodedPayload.Length);

                    bool isValidSignature = verifier.VerifySignature(signature);

                    return isValidSignature;
                }
            }
            catch (Exception)
            {
                return false;
            }
        }

        private static byte[] Base64UrlDecode3(string input)
        {
            string base64 = input.Replace("\n", "").Replace("\r", "").Replace('-', '+').Replace('_', '/');

            while (base64.Length % 4 != 0)
            {
                base64 += '=';
            }

            return Convert.FromBase64String(base64);
        }
    }

    public class wooEd255190
    {
        private static string publicKey = @"-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAr6Jb/03OVQNE2Mqq/kZVTPSQhPEst+qYbJpMgAQUwoA=
-----END PUBLIC KEY-----";
        public static bool checkv(string jwt)
        {
            var parts = jwt.Split('.');
            if (parts.Length != 3)
            {
                // Invalid JWT format
                return false;
            }
            byte[] publicKeyarr = Convert.FromBase64String(publicKey);
            string encodedHeader = parts[0];
            string encodedPayload = parts[1];
            //byte[] signature = Base64UrlDecode3(parts[2]);
            byte[] signature = Encoding.UTF8.GetBytes(parts[2]);
            string decodedHeader = Encoding.UTF8.GetString(Base64UrlDecode4(encodedHeader));
            string decodedPayload = Encoding.UTF8.GetString(Base64UrlDecode4(encodedPayload));
            var message = Encoding.UTF8.GetBytes(encodedHeader + "." + encodedPayload);
            ISigner verifier = SignerUtilities.GetSigner("ED25519");
            //verifier.Init(false, publicKeyarr);
            verifier.BlockUpdate(message, 0, message.Length);
            bool isValid = verifier.VerifySignature(signature);
            return isValid;
        }
        private static byte[] Base64UrlDecode4(string input)
        {
            string base64 = input.Replace("\n", "").Replace("\r", "").Replace('-', '+').Replace('_', '/');

            while (base64.Length % 4 != 0)
            {
                base64 += '=';
            }

            return Convert.FromBase64String(base64);
        }
        private static string ClearStr2()
        {
            string base64PublicKey = Regex.Match(publicKey, @"-----BEGIN PUBLIC KEY-----(.*?)-----END PUBLIC KEY-----", RegexOptions.Singleline)?.Groups[1].Value.Trim();
            base64PublicKey = base64PublicKey.Replace("-----BEGIN PUBLIC KEY-----", "").Replace("-----END PUBLIC KEY-----", "").Replace("\r", "").Replace("\n", "").Trim();
            return base64PublicKey;
        }

        public static bool testval(string jwt)
        {
            var parts = jwt.Split('.');
            if (parts.Length != 3)
            {
                // Invalid JWT format
                return false;
            }
            string encodedHeader = parts[0];
            string encodedPayload = parts[1];
            byte[] publicKeya = Base64UrlDecode4(ClearStr2()); // 替换为实际的公钥字节数组
            //byte[] message = Encoding.UTF8.GetBytes("Hello, World!");
            string decodedHeader = Encoding.UTF8.GetString(Base64UrlDecode4(encodedHeader));
            string decodedPayload = Encoding.UTF8.GetString(Base64UrlDecode4(encodedPayload));
            var message = Encoding.UTF8.GetBytes(encodedHeader + "." + encodedPayload);
            byte[] signature = Base64UrlDecode4(parts[2]);
            bool isValid = Ed25519.Signer.Validate(signature, message, publicKeya);
            return isValid;


        }
    }



    public class TestYq
    {
        public static void TestVail()
        {
            //    string ed25519pkcs8 = @"-----BEGIN PRIVATE KEY-----
            //                MC4CAQAwBQYDK2VwBCIEIAYIsKL0xkTkAXDhUN6eDheqODEOGyFZ04jsgFNCFxZf
            //                -----END PRIVATE KEY-----";
            string ed25519pkcs8 = @"-----BEGIN PRIVATE KEY-----
MC4CAQAwBLsSAl9Pxjj/IiYCG0
-----END PRIVATE KEY-----";
            PemReader pemReaderPrivate = new PemReader(new StringReader(ed25519pkcs8));
            Ed25519PrivateKeyParameters ed25519pkcs8Parameters = (Ed25519PrivateKeyParameters)pemReaderPrivate.ReadObject();
            string str = """
                {
                  "alg": "HS256",
                  "typ": "JWT"
                }
                """;
            string data = """
                  {
                  "sub": "1234567890",
                  "name": "John Doe",
                  "iat": 1516239022
                }
                """;
            var data1 = Convert.ToBase64String(Encoding.UTF8.GetBytes(str));
            var data2 = Convert.ToBase64String(Encoding.UTF8.GetBytes(data));
            // Sign
            byte[] dataToSign = Encoding.UTF8.GetBytes(data1 + "." + data2);
            ISigner signer = new Ed25519Signer();
            signer.Init(true, ed25519pkcs8Parameters);
            signer.BlockUpdate(dataToSign, 0, dataToSign.Length);
            byte[] signature = signer.GenerateSignature();
            Console.WriteLine("Signature: " + Convert.ToBase64String(signature));
            string strdata = @"eyJhbGciOiJFZERTQSIsInR5cCI6IkpXVCJ9.eyJvaWQiOiJTTk84MzEzNTAxNjAxMjgwNSIsInRpZCI6NjIxMzU0MzY4NDM1NiwiaWF0IjoxNjkzMzI4NjQwLCJleHAiOjE2OTM5MzM0NDB9.BhjEHzRHlWfXu_v2us08UGEjeYXpwUxIpFlnNkn1teohGboK5o5SsXHxjqtSckFS0OSQjMOX6HWFGeIFJ1ZCCw";
            var parts = strdata.Split('.');
            var sing = Encoding.UTF8.GetBytes(parts[2]);
            //
            // Verifying
            //

            // Import public key
            //string ed25519x509 = @"-----BEGIN PUBLIC KEY-----
            //          MCowBQYDK2VwAyEA3mcwgf2DrWLR3mQ6l2d59bGU6qUStwQrln2+rKlKxoA=
            //          -----END PUBLIC KEY-----";
            string ed25519x509 = @"-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAr6Jb/03OVQNE2Mqq/kwoA=
-----END PUBLIC KEY-----";
            PemReader pemReaderPublic = new PemReader(new StringReader(ed25519x509));
            Ed25519PublicKeyParameters ed25519x509Parameters = (Ed25519PublicKeyParameters)pemReaderPublic.ReadObject();

            // Verify
            ISigner verifier = new Ed25519Signer();
            verifier.Init(false, ed25519x509Parameters);
            verifier.BlockUpdate(dataToSign, 0, dataToSign.Length);
            //bool verified = verifier.VerifySignature(signature);
            bool verified = verifier.VerifySignature(sing);
            Console.WriteLine("Verification: " + verified); // Verification: True
        }

    }

}

Accpdaiyekun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
web3j智能合约错误：java.lang.ArrayIndexOutOfBoundsException
mongo_node的专栏
07-20 856
web3j:智能合约写操作时总是抛出java.lang.ArrayIndexOutOfBoundsException错误，不知道什么问题。 我的代码如下： String hexPrivateKey = String.format(&amp;quot;%040x&amp;quot;, new BigInteger(1, Config.privateKey.getBytes())); String hexPublicKey = ...
org.bouncycastle 加密算法包 最新1.69版
07-15
** org.bouncycastle 加密算法包详解 ** `org.bouncycastle` 是一个开源的 Java 库，专门用于实现各种加密算法和相关的安全服务。它提供了广泛的加密功能，包括对称和非对称加密、数字签名、哈希函数、证书管理、...
BouncyCastle.Crypto.dll
12-19
BouncyCastle.Crypto.dll BouncyCastle加密工具类，net版本的。一套轻量级的加密API.
hutool国密sm2算法使用， 正确的秘钥生成签名及验签，签名为64字节
热门推荐
qq_33140565的博客
02-15 2万+
hutool工具类： 在糊涂提供的国密算法，需要通过椭圆曲线生成秘钥，且当前业内私钥长度为固定32字节，公用固定长度为64字节。在参考hutool官方文档中的国密算法的例子，发现生成的秘钥非常长，远大于32字节和64字节，生成的签名长度也不是64字节。 问题描述： 官方提供如下例子，用于演示签名和验签 String content = "我是Hanley."; KeyPair pair = SecureUtil.generateKeyPair("SM2"); final SM2 sm2 = new SM2(
API 签名算法以及 EdDSA 的 Ed25519 签名算法的使用
最新发布
m0_61591135的博客
04-25 1076
API 签名算法以及 EdDSA 的 Ed25519 签名算法的使用
java使用bouncycastle加解密
gsls200808的专栏
11-06 6858
jdk默认带了一些常见的加解密方式，当我们常见的加解密不能满足时，就需要用到一些第三方的库了，bouncycastle就是其中一种。但是bouncycastle文档比较少。简单介绍一下写法。
java基于BouncyCastle实现RSA算法的加密、解密
z69183787的专栏
02-14 2926
Bouncy Castle Crypto是一个Java实现的加密包，同时也有C#版本。它包含一套轻量级的API可以在包括J2ME在内的绝大多数环境中运行。部分手机不支持JSR177也可使用该加密包实现加密功能。Bouncy Castle加密包包含了大多数流行的加密实现（如：AES、DES、Blowfish等）、散列算法（如：MD5、SHA等）、字节字符编码（如：Base64）等。 ...
使用AES加解密异常
JavaEE菜鸟
02-09 1567
3.AES加解密时，会使用到Java.security.*包，即jdk security，其中使用的jar包%JAVA_HOME%/jre/lib/security/local_policy.jar和%JAVA_HOME%/jre/lib/security/US_export_policy.jar有对技术出口的限制（因为美国的出口限制，Sun通过权限文件local_policy.jar、US_export_policy.jar做了相关限制），加密只有128bit，而没有限制的则有256bit。
org.bouncycastle完整资源包
10-20
《深入解析org.bouncycastle：Java安全加密与证书权威库》 在Java开发中，安全性是不可或缺的一部分，尤其是在处理敏感数据、网络通信以及数字签名时。`org.bouncycastle`库是一个强大的开源加密库，为Java开发者...
Org.BouncyCastle.Utilities.Encoders 等命名空间所需库
11-03
主要用于加解密,我是在使用解密SM4 时接触到的,在网上代码引用了Org.BouncyCastle.Utilities.Encoders,找不到库 自己在网上找了好久找到了,没有积分的可以去http://www.bouncycastle.org/csharp/ 下载
org.bouncycastle jar包
08-13
The Bouncy Castle Crypto package is a Java implementation of cryptographic algorithms. This jar contains JCE provider and lightweight API for the Bouncy Castle Cryptography APIs for JDK 1.6.
C# 基于BouncyCastle.Crypto 1.8.10 实现国密算法，SM2，SM3，SM4（加签解签，加密解密）
07-23
C# 基于BouncyCastle.Crypto 1.8.10 实现国密算法，SM2，SM3，SM4（加签解签，加密解密）
BouncyCastle.Crypto.dllC#下的BouncyCastle
09-13
BouncyCastle是JAVA专属库，但出来了C#的库。这个非常实用。仅仅一个dll文件
C# BouncyCastle.Crypto.dll用于SM4、SM2加密
05-27
C# BouncyCastle.Crypto.dll用于SM4、SM2加密
ED25519签名
qq_45043627的博客
03-11 661
Ed25519签名系统；椭圆曲线加密；hash算法
C# SM2
.NET 人工智能实践
12-15 2748
C# SM2
关于JWT
qq_45891099的博客
06-07 1036
数据加密的基本过程，就是对原来为明文的文件或者数据按某种算法进行处理，使其成为不可读的一段代码。通常称为密文，通过这样的处理，来达到保护数据不被非法人窃取的目的。加密算法分为对称加密和非对称加密，其中对称加密算法的加密和解密的密钥相同，非对称加密算法的密钥不同，常见的 对称加密 算法主要有 、、 等，常见的非对称算法主要有 、 等.对称加密算法又称为共享密钥加密算法，在对称加密算法中，使用的密钥是同一个，发送和接收双方用这个密钥对数据进行加密和解密，这就要求双方事先都知道这个密钥。数据加密过程：在对称加密算
org.bouncycastle.crypto
05-14
org.bouncycastle.crypto是一个Java加密库，提供了密码算法、密钥生成和管理、消息认证代码、随机数生成器和其他加密工具。它是Bouncy Castle项目的一部分，该项目是一个由开发者自愿参与的开源项目，旨在为Java和C#提供安全和加密库。Bouncy Castle项目的目标是提供一个全面的加密库，以帮助开发人员构建更安全的应用程序。org.bouncycastle.crypto包中的类提供了各种密码算法的实现，包括AES、Blowfish、DES、RSA等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值