.NET使用OpenSSL生成的pem密钥文件

最新推荐文章于 2021-10-22 14:33:22 发布
最新推荐文章于 2021-10-22 14:33:22 发布
阅读量291 收藏
点赞数 
    using System;  
    using System.Security.Cryptography;  
      
    /// <summary>  
    /// 作者：http://thinhunan.cnblogs.com  
    /// 名称：RsaUtility.cs  
    /// 时间：2014-11-04 16:48:42  
    /// 描述：将pem格式的1024位或2048位的公钥和私钥转换为RSAParameters  
    /// </summary>  
    public class PemConverter  
    {  
        /// <summary>  
        /// 将pem格式公钥(1024 or 2048)转换为RSAParameters  
        /// </summary>  
        /// <param name="pemFileConent">pem公钥内容</param>  
        /// <returns>转换得到的RSAParamenters</returns>  
        public static RSAParameters ConvertFromPemPublicKey(string pemFileConent)  
        {  
            if (string.IsNullOrEmpty(pemFileConent))  
            {  
                throw new ArgumentNullException("pemFileConent", "This arg cann't be empty.");  
            }  
            pemFileConent = pemFileConent.Replace("-----BEGIN PUBLIC KEY-----", "").Replace("-----END PUBLIC KEY-----", "").Replace("\n", "").Replace("\r", "");  
            byte[] keyData = Convert.FromBase64String(pemFileConent);  
            bool keySize1024 = (keyData.Length == 162);  
            bool keySize2048 = (keyData.Length == 294);  
            if (!(keySize1024 || keySize2048))  
            {  
                throw new ArgumentException("pem file content is incorrect, Only support the key size is 1024 or 2048");  
            }  
            byte[] pemModulus = (keySize1024 ? new byte[128] : new byte[256]);  
            var pemPublicExponent = new byte[3];  
            Array.Copy(keyData, (keySize1024 ? 29 : 33), pemModulus, 0, (keySize1024 ? 128 : 256));  
            Array.Copy(keyData, (keySize1024 ? 159 : 291), pemPublicExponent, 0, 3);  
            var para = new RSAParameters { Modulus = pemModulus, Exponent = pemPublicExponent };  
            return para;  
        }  
      
        /// <summary>  
        /// 将pem格式私钥(1024 or 2048)转换为RSAParameters  
        /// </summary>  
        /// <param name="pemFileConent">pem私钥内容</param>  
        /// <returns>转换得到的RSAParamenters</returns>  
        public static RSAParameters ConvertFromPemPrivateKey(string pemFileConent)  
        {  
            if (string.IsNullOrEmpty(pemFileConent))  
            {  
                throw new ArgumentNullException("pemFileConent", "This arg cann't be empty.");  
            }  
            //pemFileConent = pemFileConent.Replace("-----BEGIN RSA PRIVATE KEY-----", "").Replace("-----END RSA PRIVATE KEY-----", "").Replace("\n", "").Replace("\r", "");  
            pemFileConent = pemFileConent.Replace("-----BEGIN PRIVATE KEY-----", "").Replace("-----END PRIVATE KEY-----", "").Replace("\n", "").Replace("\r", "");  
            byte[] keyData = Convert.FromBase64String(pemFileConent);  
            //byte[] keyData = System.Text.Encoding.Default.GetBytes(pemFileConent);  
            bool keySize1024 = (keyData.Length == 609 || keyData.Length == 610);  
            bool keySize2048 = (keyData.Length == 1190 || keyData.Length == 1192);  
      
            if (!(keySize1024 || keySize2048))  
            {  
                throw new ArgumentException("pem file content is incorrect, Only support the key size is 1024 or 2048");  
            }  
      
            int index = (keySize1024 ? 11 : 12);  
            byte[] pemModulus = (keySize1024 ? new byte[128] : new byte[256]);  
            Array.Copy(keyData, index, pemModulus, 0, pemModulus.Length);  
      
            index += pemModulus.Length;  
            index += 2;  
            var pemPublicExponent = new byte[3];  
            Array.Copy(keyData, index, pemPublicExponent, 0, 3);  
      
            index += 3;  
            index += 4;  
            if (keyData[index] == 0)  
            {  
                index++;  
            }  
            byte[] pemPrivateExponent = (keySize1024 ? new byte[128] : new byte[256]);  
            Array.Copy(keyData, index, pemPrivateExponent, 0, pemPrivateExponent.Length);  
      
            index += pemPrivateExponent.Length;  
            index += (keySize1024 ? ((int)keyData[index + 1] == 64 ? 2 : 3) : ((int)keyData[index + 2] == 128 ? 3 : 4));  
            byte[] pemPrime1 = (keySize1024 ? new byte[64] : new byte[128]);  
            Array.Copy(keyData, index, pemPrime1, 0, pemPrime1.Length);  
      
            index += pemPrime1.Length;  
            index += (keySize1024 ? ((int)keyData[index + 1] == 64 ? 2 : 3) : ((int)keyData[index + 2] == 128 ? 3 : 4));  
            byte[] pemPrime2 = (keySize1024 ? new byte[64] : new byte[128]);  
            Array.Copy(keyData, index, pemPrime2, 0, pemPrime2.Length);  
      
            index += pemPrime2.Length;  
            index += (keySize1024 ? ((int)keyData[index + 1] == 64 ? 2 : 3) : ((int)keyData[index + 2] == 128 ? 3 : 4));  
            byte[] pemExponent1 = (keySize1024 ? new byte[64] : new byte[128]);  
            Array.Copy(keyData, index, pemExponent1, 0, pemExponent1.Length);  
      
            index += pemExponent1.Length;  
            index += (keySize1024 ? ((int)keyData[index + 1] == 64 ? 2 : 3) : ((int)keyData[index + 2] == 128 ? 3 : 4));  
            byte[] pemExponent2 = (keySize1024 ? new byte[64] : new byte[128]);  
            Array.Copy(keyData, index, pemExponent2, 0, pemExponent2.Length);  
      
            index += pemExponent2.Length;  
            index += (keySize1024 ? ((int)keyData[index + 1] == 64 ? 2 : 3) : ((int)keyData[index + 2] == 128 ? 3 : 4));  
            byte[] pemCoefficient = (keySize1024 ? new byte[64] : new byte[128]);  
            Array.Copy(keyData, index, pemCoefficient, 0, pemCoefficient.Length);  
      
            var para = new RSAParameters  
                {  
                    Modulus = pemModulus,  
                    Exponent = pemPublicExponent,  
                    D = pemPrivateExponent,  
                    P = pemPrime1,  
                    Q = pemPrime2,  
                    DP = pemExponent1,  
                    DQ = pemExponent2,  
                    InverseQ = pemCoefficient  
                };  
            return para;  
        }  
      
        /// <summary>  
        /// 将pem格式公钥转换为RSAParameters  
        /// </summary>  
        /// <param name="pemFileConent">pem公钥内容</param>  
        /// <returns>转换得到的RSAParamenters</returns>  
        public static RSAParameters ConvertFromPemNormalPublicKey(string pemFileConent)  
        {  
            if (string.IsNullOrEmpty(pemFileConent))  
            {  
                throw new ArgumentNullException("pemFileConent", "This arg cann't be empty.");  
            }  
            pemFileConent = pemFileConent.Replace("-----BEGIN PUBLIC KEY-----", "").Replace("-----END PUBLIC KEY-----", "").Replace("\n", "").Replace("\r", "");  
            byte[] keyData = Convert.FromBase64String(pemFileConent);  
            if (keyData.Length < 162)  
            {  
                throw new ArgumentException("pem file content is incorrect.");  
            }  
            byte[] pemModulus = new byte[128];  
            byte[] pemPublicExponent = new byte[3];  
            Array.Copy(keyData, 29, pemModulus, 0, 128);  
            Array.Copy(keyData, 159, pemPublicExponent, 0, 3);  
            RSAParameters para = new RSAParameters();  
            para.Modulus = pemModulus;  
            para.Exponent = pemPublicExponent;  
            return para;  
        }  
      
        /// <summary>  
        /// 将pem格式私钥转换为RSAParameters  
        /// </summary>  
        /// <param name="pemFileConent">pem私钥内容</param>  
        /// <returns>转换得到的RSAParamenters</returns>  
        public static RSAParameters ConvertFromPemNormalPrivateKey(string pemFileConent)  
        {  
            if (string.IsNullOrEmpty(pemFileConent))  
            {  
                throw new ArgumentNullException("pemFileConent", "This arg cann't be empty.");  
            }  
            //pemFileConent = pemFileConent.Replace("-----BEGIN RSA PRIVATE KEY-----", "").Replace("-----END RSA PRIVATE KEY-----", "").Replace("\n", "").Replace("\r", "");  
            pemFileConent = pemFileConent.Replace("-----BEGIN PRIVATE KEY-----", "").Replace("-----END PRIVATE KEY-----", "").Replace("\n", "").Replace("\r", "");  
            byte[] keyData = Convert.FromBase64String(pemFileConent);  
            if (keyData.Length < 609)  
            {  
                throw new ArgumentException("pem file content is incorrect.");  
            }  
      
            int index = 11;  
            byte[] pemModulus = new byte[128];  
            Array.Copy(keyData, index, pemModulus, 0, 128);  
      
            index += 128;  
            index += 2;//141  
            byte[] pemPublicExponent = new byte[3];  
            Array.Copy(keyData, index, pemPublicExponent, 0, 3);  
      
            index += 3;  
            index += 4;//148  
            byte[] pemPrivateExponent = new byte[128];  
            Array.Copy(keyData, index, pemPrivateExponent, 0, 128);  
      
            index += 128;  
            index += ((int)keyData[index + 1] == 64 ? 2 : 3);//279  
            byte[] pemPrime1 = new byte[64];  
            Array.Copy(keyData, index, pemPrime1, 0, 64);  
      
            index += 64;  
            index += ((int)keyData[index + 1] == 64 ? 2 : 3);//346  
            byte[] pemPrime2 = new byte[64];  
            Array.Copy(keyData, index, pemPrime2, 0, 64);  
      
            index += 64;  
            index += ((int)keyData[index + 1] == 64 ? 2 : 3);//412/413  
            byte[] pemExponent1 = new byte[64];  
            Array.Copy(keyData, index, pemExponent1, 0, 64);  
      
            index += 64;  
            index += ((int)keyData[index + 1] == 64 ? 2 : 3);//479/480  
            byte[] pemExponent2 = new byte[64];  
            Array.Copy(keyData, index, pemExponent2, 0, 64);  
      
            index += 64;  
            index += ((int)keyData[index + 1] == 64 ? 2 : 3);//545/546  
            byte[] pemCoefficient = new byte[64];  
            Array.Copy(keyData, index, pemCoefficient, 0, 64);  
      
            RSAParameters para = new RSAParameters();  
            para.Modulus = pemModulus;  
            para.Exponent = pemPublicExponent;  
            para.D = pemPrivateExponent;  
            para.P = pemPrime1;  
            para.Q = pemPrime2;  
            para.DP = pemExponent1;  
            para.DQ = pemExponent2;  
            para.InverseQ = pemCoefficient;  
            return para;  
        }  
    }
转自：ttp://www.2cto.com/kf/201202/121307.html
v_最初
关注
转换java keytools的keystore证书到OPENSSL的PEM格式文件
隔壁老瓦的专栏
08-17 994
转换java keytools的keystore证书到OPENSSL的PEM格式文件 背景：原先业务使用的前端为haproxy，直接端口转发至tomcat，后端进行ssl连接，所以当时生成的步骤如下 1 2 •生成密钥对：keytool -genkey -alias tomcat-server -keyalg RSA -keypass xxxxxxx -s...
NET使用OpenSSL生成的pem密钥文件
06-07
.net使用 pem格式的RSA公钥，私钥 加解密 ，NET使用OpenSSL生成的pem密钥文件,
.NET使用OpenSSL生成的pem密钥文件[1024位]
diaoshanwai2368的博客
08-24 277
using System; using System.Text; using System.Security.Cryptography; using System.Web; using System.IO; namespace Thinhunan.Cnblogs.Com.RSAUtility { public class PemConverter ...
.NET使用OpenSSL生成的pem密钥文件(增加size为2048的密钥转换)
cuoban的学习空间
05-04 814
using System; using System.Text; using System.Security.Cryptography; using System.Web; using System.IO; namespace Thinhunan.Cnblogs.Com.RSAUtility {     ///      /// Author http://thinhunan.
OpenSSL.Net使用随记
weixin_30813225的博客
04-30 913
　　最近在工作中遇到需要对数据传输进行加密解密，一开始是.Net与.Net环境间进行交互，使用.Net下的【System.Security.Cryptography】完全没有问题，但后来要与Java，Android，IOS进行交互，结果是怎么都对不上，在查看后得知三者平台都使用的OpenSSL进行的加解密，于是就翻出了OpenSSL.Net... OpenSSL.Net是什么 ...
使用OpenSSL生成证书 pem文件的生成 celery Security
0x8g1T9E-
04-16 1万+
找了很久，找到了一篇生成pem文件的文章（找了很多篇，有些生成的pem文件不对，当时被误导了很久）。（前面也花了好一些时间，才意识到自己要百度的内容：openssl如何生成pem公私钥），文章连接为：https://blog.csdn.net/m0_38080126/article/details/77609304 celery Securityhttps://docs.celeryproject.org/en/stable/userguide/security.html#id6 https://...
.net DSA加密（C#读取OPENSSL生成的DSA的pem文件的秘钥）
08-23
在本资源中，我们关注的是如何使用C#来处理OpenSSL生成的PEM格式的DSA密钥。PEM（Privacy Enhanced Mail）是一种文本编码格式，通常用于存储证书和密钥，它使用Base64编码将二进制数据转化为可读的ASCII字符。 首先...
C#使用pem格式的密钥对文件来做RSA加解密接签名和验证签名
05-06
C#使用pem格式的密钥对文件来做RSA加解密接签名和验证签名，这里的pem文件是openssl命令生成的密钥对文件，其中私钥pem文件需要用openssl命令转换成pkcs8格式的pem文件。如果已有pem文件，也可以通过openssl命令转换...
全面解决.Net与Java互通时的RSA加解密问题，使用PEM格式的密钥文件
weixin_33901641的博客
02-13 1016
作者： zyl910 一、缘由 RSA是一种常用的非对称加密算法。所以有时需要在不用编程语言中分别使用RSA的加密、解密。例如用Java做后台服务端，用C#开发桌面的客户端软件时。 由于 .Net、Java 的RSA类库存在很多细节区别，尤其是它们支持的密钥格式不同。导致容易出现“我加密的数据对方不能解密，对方加密的数据我不能解密，但是自身是可以正常加密解密”等情况。 虽然网上已经有很多文章讨论 ...
pem文件的生成
热门推荐
LLLLEE 的博客
07-02 5万+
秘钥pem文件的生成
【加密与解密】C#如何读取pem的KEY文件
Walter的专栏
08-01 2万+
1、第一步先用openssl将pem的key转换为der的key //E:\01Doc\bin>openssl.exe rsa -in rsakeydec.pem -outform der -out pri.der 2、调用下面的程序直接读取der转换为c#所需要的xml Key，之后进行密文解密 3、openssl下载地址 http://download.csdn.net/d
asp.net RSA密钥之C#格式与Java格式转换（PEM格式）
XLaws的博客
11-30 1222
//商户私钥（Java格式），公钥已上传         private static string PrivateKey = "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDETH1ziFZ70KCIqTjZvzWs/MIjrcbFptR748voH8fXDsuG2XHU+ds4f8tbuqgp4d4pW7bgwtyJOOYTuRHxh2Q...
.Net c# RSA xml公钥密钥转pem格式
weixin_34270606的博客
05-09 2148
2019独角兽企业重金招聘Python工程师标准>>> ...
windows下VS2017使用openssl库
liudongdong_jlu
11-19 7097
OpenSSL开发环境配置教程分享给大家，具体内容如下 【环境信息】 Windows 10 Enterprise Version 10.0.15063  下载地址：http://www.itellyou.cn/）  Visual Studio Enterprise 2017 Version 15.2(26430.12)  下载地址：https://www.visualstudio.com...
.Net 通过OpenSSL来生成.Net Core WebApi使用的pfx
シ❤゛甜虾的个人博客
10-22 591
1、生成.key文件 openssl genrsa -des3 -out server.key 2048 中间会提示输入密码(重复输入两次)，要记住这个密码； 这时会在C:\OpenSSL-Win64\bin目录下生成server.key文件。 2、生成.crt文件 openssl req -new -x509 -key server.key -out server.crt -days 3650 会提示输入server.key的密码 开始输入Country Name：CN State or
使用openSSL制作SSL证书
u013630932的专栏
08-07 1万+
1.将openSSL的bin目录设置为环境变量 2.set OPENSSL_CONF=E:\OpenSSL-Win32\bin\openssl.cfg 3.以管理员身份运行命令窗口 4.参考文章 https://blog.csdn.net/zhanggnol/article/details/24292507 以下内容均截取于这篇文章 新建文件夹用于存放证书，如“D:\keystore...
如何使用openssl生成RSA pem格式的密钥对
最新发布
06-10
您可以按照以下步骤使用openssl生成RSA pem格式的密钥对： 1. 打开终端或命令行窗口，并进入希望存储密钥的目录。 2. 输入以下命令以生成私钥：`openssl genrsa -out private.pem 2048`。 3. 输入以下命令以生成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值