c# 实现RSA非对称加密算法

目录
  •   公钥与私钥
  •   C#实现

  公钥与私钥

  公钥与私钥是成对的,一般的,我们认为的是公钥加密、私钥解密、私钥签名、公钥验证,有人说成私钥加密,公钥解密时不对的。

  公钥与私钥的生成有多种方式,可以通过程序生成(下文具体实现),可以通过openssl工具:  

    # 生成一个私钥,推荐使用1024位的秘钥,秘钥以pem格式保存到-out参数指定的文件中,采用PKCS1格式
    openssl genrsa -out rsa.pem 1024
    # 生成与私钥对应的公钥,生成的是Subject Public Key,一般配合PKCS8格式私钥使用
    openssl rsa -in rsa.pem -pubout -out rsa.pub  

  RSA生成公钥与私钥一般有两种格式:PKCS1和PKCS8,上面的命令生成的秘钥是PKCS1格式的,而公钥是Subject Public Key,一般配合PKCS8格式私钥使用,所以就可能会涉及到PKCS1和PKCS8之间的转换:

    # PKCS1格式私钥转换为PKCS8格式私钥,私钥直接输出到-out参数指定的文件中
    openssl pkcs8 -topk8 -inform PEM -in rsa.pem -outform pem -nocrypt -out rsa_pkcs8.pem
    # PKCS8格式私钥转换为PKCS1格式私钥,私钥直接输出到-out参数指定的文件中
    openssl rsa -in rsa_pkcs8.pem -out rsa_pkcs1.pem

    # PKCS1格式公钥转换为PKCS8格式公钥,转换后的内容直接输出
    openssl rsa -pubin -in rsa.pub -RSAPublicKey_out
    # PKCS8格式公钥转换为PKCS1格式公钥,转换后的内容直接输出
    openssl rsa -RSAPublicKey_in -pubout -in rsa.pub

  现实中,我们往往从pem、crt、pfx文件获取公私和私钥,crt、pfx的制作可以参考:简单的制作ssl证书,并在nginx和IIS中使用,或者使用现成的:https://pan.baidu.com/s/1MJ5YmuZiLBnf-DfNR_6D7A (提取码:c6tj),密码都是:123456

  C#实现

  为了方便读取pem、crt、pfx文件中的公私和私钥,这里我使用了第三方的包:Portable.BouncyCastle,可以使用NuGet安装:Install-Package Portable.BouncyCastle

  接着,这里我封装了一个RsaHelper辅助类来实现各种RSA加密的过程: 

using Org.BouncyCastle.Utilities.IO.Pem;
using System;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Text;

namespace ConsoleApp1
{
    public class RsaHelper
    {

        #region key
        /// <summary>
        /// 将秘钥保存到Pem文件
        /// </summary>
        /// <param name="isPrivateKey"></param>
        /// <param name="buffer"></param>
        /// <param name="pemFileName"></param>
        /// <returns></returns>
        public static void WriteToPem(byte[] buffer, bool isPrivateKey, string pemFileName)
        {
            PemObject pemObject = new PemObject(isPrivateKey ? "RSA PRIVATE KEY" : "RSA PUBLIC KEY", buffer);
            if (File.Exists(pemFileName))
            {
                File.Delete(pemFileName);
            }
            using (var fileStream = new FileStream(pemFileName, FileMode.OpenOrCreate, FileAccess.Write))
            {
                using (var sw = new StreamWriter(fileStream))
                {
                    var writer = new PemWriter(sw);
                    writer.WriteObject(pemObject);
                    sw.Flush();
                }
            }
        }
        /// <summary>
        /// 从Pem文件中读取秘钥
        /// </summary>
        /// <param name="pemFileName"></param>
        /// <returns></returns>
        public static byte[] ReadFromPem(string pemFileName)
        {
            using (var fileStream = new FileStream(pemFileName, FileMode.Open, FileAccess.Read))
            {
                using (var sw = new StreamReader(fileStream))
                {
                    var writer = new PemReader(sw);
                    return writer.ReadPemObject().Content;
                }
            }
        }

        /// <summary>
        /// 从xml中读取秘钥
        /// </summary>
        /// <param name="xml"></param>
        /// <param name="isPrivateKey"></param>
        /// <param name="usePkcs8"></param>
        /// <returns></returns>
        public static byte[] ReadFromXml(string xml, bool isPrivateKey, bool usePkcs8)
        {
            using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.FromXmlString(xml);
                if (isPrivateKey)
                {
                    return usePkcs8 ? rsa.ExportPkcs8PrivateKey() : rsa.ExportRSAPrivateKey();
                }
                return usePkcs8 ? rsa.ExportSubjectPublicKeyInfo() : rsa.ExportRSAPublicKey();
            }
        }
        /// <summary>
        /// 将秘钥保存到xml中
        /// </summary>
        /// <param name="buffer"></param>
        /// <param name="isPrivateKey"></param>
        /// <param name="usePkcs8"></param>
        /// <returns></returns>
        public static string WriteToXml(byte[] buffer, bool isPrivateKey, bool usePkcs8)
        {
            using (var rsa = CreateRSACryptoServiceProvider(buffer, isPrivateKey, usePkcs8))
            {
                return rsa.ToXmlString(isPrivateKey);
            }
        }

        /// <summary>
        /// 获取RSA非对称加密的Key
        /// </summary>
        /// <param name="publicKey"></param>
        /// <param name="privateKey"></param>
        public static void GenerateRsaKey(bool usePKCS8, out byte[] publicKey, out byte[] privateKey)
        {
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
                rsa.KeySize = 1024;//1024位
                if (usePKCS8)
                {
                    //使用pkcs8填充方式导出
                    publicKey = rsa.ExportSubjectPublicKeyInfo();//公钥
                    privateKey = rsa.ExportPkcs8PrivateKey();//私钥
                }
                else
                {
                    //使用pkcs1填充方式导出
                    publicKey = rsa.ExportRSAPublicKey();//公钥
                    privateKey = rsa.ExportRSAPrivateKey();//私钥
                }
            }
        }
        /// <summary>
        /// 从Pfx文件获取RSA非对称加密的Key
        /// </summary>
        /// <param name="pfxFileName"></param>
        /// <param name="publicKey"></param>
        /// <param name="privateKey"></param>
        public static void ReadFromPfx(string pfxFileName, string password, out byte[] publicKey, out byte[] privateKey)
        {
            X509Certificate2 x509Certificate2 = new X509Certificate2(pfxFileName, password, X509KeyStorageFlags.Exportable);
            publicKey = x509Certificate2.GetRSAPublicKey().ExportRSAPublicKey();
            privateKey = x509Certificate2.GetRSAPrivateKey().ExportRSAPrivateKey();
        }
        /// <summary>
        /// 从Crt文件中读取公钥
        /// </summary>
        /// <param name="crtFileName"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        public static byte[] ReadPublicKeyFromCrt(string crtFileName, string password)
        {
            X509Certificate2 x509Certificate2 = new X509Certificate2(crtFileName, password, X509KeyStorageFlags.Exportable);
            var publicKey = x509Certificate2.GetRSAPublicKey().ExportRSAPublicKey();
            return publicKey;
        }
        #endregion

        #region Pkcs1 and Pkcs8

        /// <summary>
        /// Pkcs1转Pkcs8
        /// </summary>
        /// <param name="isPrivateKey"></param>
        /// <param name="buffer"></param>
        /// <returns></returns>
        public static byte[] Pkcs1ToPkcs8(bool isPrivateKey, byte[] buffer)
        {
            using (var rsa = new RSACryptoServiceProvider())
            {
                if (isPrivateKey)
                {
                    rsa.ImportRSAPrivateKey(buffer, out _);
                    return rsa.ExportPkcs8PrivateKey();
                }
                else
                {
                    rsa.ImportRSAPublicKey(buffer, out _);
                    return rsa.ExportSubjectPublicKeyInfo();
                }
            }
        }
        /// <summary>
        /// Pkcs8转Pkcs1
        /// </summary>
        /// <param name="isPrivateKey"></param>
        /// <param name="buffer"></param>
        /// <returns></returns>
        public static byte[] Pkcs8ToPkcs1(bool isPrivateKey, byte[] buffer)
        {
            using (var rsa = new RSACryptoServiceProvider())
            {
                if (isPrivateKey)
                {
                    rsa.ImportPkcs8PrivateKey(buffer, out _);
                    return rsa.ExportRSAPrivateKey();
                }
                else
                {
                    rsa.ImportSubjectPublicKeyInfo(buffer, out _);
                    return rsa.ExportRSAPublicKey();
                }
            }
        }

        #endregion

        #region RSA

        /// <summary>
        /// 获取一个RSACryptoServiceProvider
        /// </summary>
        /// <param name="isPrivateKey"></param>
        /// <param name="buffer"></param>
        /// <param name="usePkcs8"></param>
        /// <returns></returns>
        public static RSACryptoServiceProvider CreateRSACryptoServiceProvider(byte[] buffer, bool isPrivateKey, bool usePkcs8 = false)
        {
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            if (isPrivateKey)
            {
                if (usePkcs8)
                    rsa.ImportPkcs8PrivateKey(buffer, out _);
                else
                    rsa.ImportRSAPrivateKey(buffer, out _);
            }
            else
            {
                if (usePkcs8)
                    rsa.ImportSubjectPublicKeyInfo(buffer, out _);
                else
                    rsa.ImportRSAPublicKey(buffer, out _);
            }
            return rsa;
        }

        /// <summary>
        /// RSA公钥加密
        /// </summary>
        /// <param name="value">待加密的明文</param>
        /// <param name="publicKey">公钥</param>
        /// <param name="usePkcs8">是否使用pkcs8填充</param>
        /// <returns></returns>
        public static string RsaEncrypt(string value, byte[] publicKey, bool usePkcs8 = false)
        {
            if (string.IsNullOrEmpty(value)) return value;

            using (RSACryptoServiceProvider rsa = CreateRSACryptoServiceProvider(publicKey, false, usePkcs8))
            {
                var buffer = Encoding.UTF8.GetBytes(value);
                buffer = rsa.Encrypt(buffer, false);

                //使用hex格式输出数据
                StringBuilder result = new StringBuilder();
                foreach (byte b in buffer)
                {
                    result.AppendFormat("{0:x2}", b);
                }
                return result.ToString();
                //或者使用下面的输出
                //return BitConverter.ToString(buffer).Replace("-", "").ToLower();
            }
        }
        /// <summary>
        /// RSA私钥解密
        /// </summary>
        /// <param name="value">密文</param>
        /// <param name="privateKey">私钥</param>
        /// <param name="usePkcs8">是否使用pkcs8填充</param>
        /// <returns></returns>
        public static string RsaDecrypt(string value, byte[] privateKey, bool usePkcs8 = false)
        {
            if (string.IsNullOrEmpty(value)) return value;

            using (RSACryptoServiceProvider rsa = CreateRSACryptoServiceProvider(privateKey, true, usePkcs8))
            {
                //转换hex格式数据为byte数组
                var buffer = new byte[value.Length / 2];
                for (var i = 0; i < buffer.Length; i++)
                {
                    buffer[i] = (byte)Convert.ToInt32(value.Substring(i * 2, 2), 16);
                }
                buffer = rsa.Decrypt(buffer, false);
                return Encoding.UTF8.GetString(buffer);
            }
        }
        /// <summary>
        /// RSA私钥生成签名
        /// </summary>
        /// <param name="value">原始值</param>
        /// <param name="publicKey">公钥</param>
        /// <param name="halg">签名hash算法:SHA,SHA1,MD5,SHA256,SHA384,SHA512</param>
        /// <param name="usePkcs8">是否使用pkcs8填充</param>
        /// <returns></returns>
        public static string Sign(string value, byte[] privateKey, string halg = "MD5", bool usePkcs8 = false)
        {
            if (string.IsNullOrEmpty(value)) return value;

            using (RSACryptoServiceProvider rsa = CreateRSACryptoServiceProvider(privateKey, true, usePkcs8))
            {
                byte[] buffer = Encoding.UTF8.GetBytes(value);
                buffer = rsa.SignData(buffer, HashAlgorithm.Create(halg));

                //使用hex格式输出数据
                StringBuilder result = new StringBuilder();
                foreach (byte b in buffer)
                {
                    result.AppendFormat("{0:x2}", b);
                }
                return result.ToString();
                //或者使用下面的输出
                //return BitConverter.ToString(buffer).Replace("-", "").ToLower();
            }
        }
        /// <summary>
        /// RSA公钥验证签名
        /// </summary>
        /// <param name="value">原始值</param>
        /// <param name="publicKey">公钥</param>
        /// <param name="signature">签名</param>
        /// <param name="halg">签名hash算法:SHA,SHA1,MD5,SHA256,SHA384,SHA512</param>
        /// <param name="usePkcs8">是否使用pkcs8填充</param>
        /// <returns></returns>
        public static bool Verify(string value, byte[] publicKey, string signature, string halg = "MD5", bool usePkcs8 = false)
        {
            if (string.IsNullOrEmpty(value)) return false;

            using (RSACryptoServiceProvider rsa = CreateRSACryptoServiceProvider(publicKey, false, usePkcs8))
            {
                //转换hex格式数据为byte数组
                var buffer = new byte[signature.Length / 2];
                for (var i = 0; i < buffer.Length; i++)
                {
                    buffer[i] = (byte)Convert.ToInt32(signature.Substring(i * 2, 2), 16);
                }
                return rsa.VerifyData(Encoding.UTF8.GetBytes(value), HashAlgorithm.Create(halg), buffer);
            }
        }
        #endregion
    }
}

  可以使用生成RSA的公私秘钥:  

    //通过程序生成
    RsaHelper.GenerateRsaKey(usePKCS8, out publicKey, out privateKey);

  生成秘钥后,需要保存,一般保存到pem文件中:  

    //保存到Pem文件,filePath是文件目录
    RsaHelper.WriteToPem(publicKey, false, Path.Combine(filePath, "rsa.pub"));
    RsaHelper.WriteToPem(privateKey, true, Path.Combine(filePath, "rsa.pem"));

  还以将公钥和私钥输出为xml格式:  

    //保存到xml中
    string publicKeyXml = RsaHelper.WriteToXml(publicKey, false, usePKCS8);
    string privateKeyXml = RsaHelper.WriteToXml(privateKey, true, usePKCS8);

  保存到pem文件和xml中后,也可以从中读取:  

    //从Pem文件获取,filePath是文件目录
    publicKey = RsaHelper.ReadFromPem(Path.Combine(filePath, "rsa.pub"));
    privateKey = RsaHelper.ReadFromPem(Path.Combine(filePath, "rsa.pem"));

    //从xml中读取
    publicKey = RsaHelper.ReadFromXml(publicKeyXml, false, usePKCS8);
    privateKey = RsaHelper.ReadFromXml(privateKeyXml, true, usePKCS8);

  还可以从crt证书中读取公钥,而crt文件不包含私钥,因此需要单独获取私钥:

    //从crt文件读取,filePath是文件目录
    publicKey = RsaHelper.ReadPublicKeyFromCrt(Path.Combine(filePath, "demo.crt"), "");
    privateKey = RsaHelper.ReadFromPem(Path.Combine(filePath, "demo.key"));

  pfx文件中包含了公钥和私钥,可以很方便就读取到:  

    //从demo.pfx文件读取(demo.pfx采用的是pkcs1),filePath是文件目录
    RsaHelper.ReadFromPfx(Path.Combine(filePath, "demo.pfx"), "123456", out publicKey, out privateKey);

  有时候我们还可能需要进行秘钥的转换:  

    // Pkcs8格式公钥转换为Pkcs1格式公钥
    publicKey = RsaHelper.Pkcs8ToPkcs1(false, publicKey);
    // Pkcs8格式私钥转换为Pkcs1格式私钥
    privateKey = RsaHelper.Pkcs8ToPkcs1(true, privateKey);
    // Pkcs1格式公钥转换为Pkcs8格式公钥
    publicKey = RsaHelper.Pkcs1ToPkcs8(false, publicKey);
    // Pkcs1格式私钥转换为Pkcs8格式私钥
    privateKey = RsaHelper.Pkcs1ToPkcs8(true, privateKey);

  有了公钥和私钥,接下就就能实现加密、解密、签名、验证签名等操作了:  

    string encryptText = RsaHelper.RsaEncrypt(text, publicKey, usePKCS8);
    Console.WriteLine($"【{text}】经过【RSA】加密后:{encryptText}");

    string decryptText = RsaHelper.RsaDecrypt(encryptText, privateKey, usePKCS8);
    Console.WriteLine($"【{encryptText}】经过【RSA】解密后:{decryptText}");

    string signature = RsaHelper.Sign(text, privateKey, "MD5", usePKCS8);
    Console.WriteLine($"【{text}】经过【RSA】签名后:{signature}");

    bool result = RsaHelper.Verify(text, publicKey, signature, "MD5", usePKCS8);
    Console.WriteLine($"【{text}】的签名【{signature}】经过【RSA】验证后结果是:{result}");

  完整的demo代码:  

    using System;
    using System.IO;

    namespace ConsoleApp1
    {
        class Program
        {
            static void Main(string[] args)
            {
                string text = "上山打老虎";
                bool usePKCS8 = true;// usePKCS8=true表示是否成PKCS8格式的公私秘钥,否则乘车PKCS1格式的公私秘钥
                string filePath = Directory.GetCurrentDirectory();
                Console.WriteLine($"文件路径:{filePath}");// 存放pem,crt,pfx等文件的目录
                byte[] publicKey, privateKey;// 公钥和私钥

                //通过程序生成
                RsaHelper.GenerateRsaKey(usePKCS8, out publicKey, out privateKey);
                //从Pem文件获取,filePath是文件目录
                //publicKey = RsaHelper.ReadFromPem(Path.Combine(filePath, "rsa.pub"));
                //privateKey = RsaHelper.ReadFromPem(Path.Combine(filePath, "rsa.pem"));

                //从demo.pfx文件读取(demo.pfx采用的是pkcs1),filePath是文件目录
                //RsaHelper.ReadFromPfx(Path.Combine(filePath, "demo.pfx"), "123456", out publicKey, out privateKey);
                //从crt文件读取,filePath是文件目录
                //publicKey = RsaHelper.ReadPublicKeyFromCrt(Path.Combine(filePath, "demo.crt"), "");
                //privateKey = RsaHelper.ReadFromPem(Path.Combine(filePath, "demo.key"));

                //保存到Pem文件,filePath是文件目录
                RsaHelper.WriteToPem(publicKey, false, Path.Combine(filePath, "rsa.pub"));
                RsaHelper.WriteToPem(privateKey, true, Path.Combine(filePath, "rsa.pem"));

                //保存到xml中
                string publicKeyXml = RsaHelper.WriteToXml(publicKey, false, usePKCS8);
                string privateKeyXml = RsaHelper.WriteToXml(privateKey, true, usePKCS8);

                //从xml中读取
                publicKey = RsaHelper.ReadFromXml(publicKeyXml, false, usePKCS8);
                privateKey = RsaHelper.ReadFromXml(privateKeyXml, true, usePKCS8);

                // Pkcs8格式公钥转换为Pkcs1格式公钥
                publicKey = RsaHelper.Pkcs8ToPkcs1(false, publicKey);
                // Pkcs8格式私钥转换为Pkcs1格式私钥
                privateKey = RsaHelper.Pkcs8ToPkcs1(true, privateKey);
                // Pkcs1格式公钥转换为Pkcs8格式公钥
                publicKey = RsaHelper.Pkcs1ToPkcs8(false, publicKey);
                // Pkcs1格式私钥转换为Pkcs8格式私钥
                privateKey = RsaHelper.Pkcs1ToPkcs8(true, privateKey);

                string encryptText = RsaHelper.RsaEncrypt(text, publicKey, usePKCS8);
                Console.WriteLine($"【{text}】经过【RSA】加密后:{encryptText}");

                string decryptText = RsaHelper.RsaDecrypt(encryptText, privateKey, usePKCS8);
                Console.WriteLine($"【{encryptText}】经过【RSA】解密后:{decryptText}");

                string signature = RsaHelper.Sign(text, privateKey, "MD5", usePKCS8);
                Console.WriteLine($"【{text}】经过【RSA】签名后:{signature}");

                bool result = RsaHelper.Verify(text, publicKey, signature, "MD5", usePKCS8);
                Console.WriteLine($"【{text}】的签名【{signature}】经过【RSA】验证后结果是:{result}");
            }
        }
    }

以上就是c# 实现RSA非对称加密算法的详细内容,更多关于c# RSA非对称加密算法的资料请关注我们其它相关文章!

(0)

相关推荐

  • 详解c#与js的rsa加密互通

    ASN.1 抽象语法表示(标记)ASN.1(Abstract Syntax Notation One )一种数据定义语言,描述了对数据进行表示.编码.传输和解码的数据格式.网络管理系统中的管理信息库(MIB).应用程序的数据结构.协议数据单元(PDU)都是用ASN.1定义的. 可以理解为ASN.1是对密钥结构定义的一种规范 密钥结构类型 PKCS#1 RSAPublicKey ::= SEQUENCE { modulus INTEGER, -- n publicExponent INTEGER

  • RSA密钥--JAVA和C#的区别及联系

    目录 1.RSA语法介绍 1.1 C#转JAVA 1.2 JAVA转C# 首先感谢:http://www.codeproject.com/Articles/25487/Cryptographic-Interoperability-Keys的文章. 由于公司同时使用.NET和JAVA,而且各个服务集使用接口来进行通信,因此某些例如清算系统.收银台之类的安全性比较高的系统会使用RSA进行加密.因此会涉及到密钥的转换.所以大概看了下C#的秘钥跟JAVA的密钥区别. RSA对于程序本身是没有区别的,其格

  • Java 实现RSA非对称加密算法

    目录 公钥与私钥 Java实现 公钥与私钥 公钥与私钥是成对的,一般的,我们认为的是公钥加密.私钥解密.私钥签名.公钥验证,有人说成私钥加密,公钥解密时不对的. 公钥与私钥的生成有多种方式,可以通过程序生成(下文具体实现),可以通过openssl工具: # 生成一个私钥,推荐使用1024位的秘钥,秘钥以pem格式保存到-out参数指定的文件中,采用PKCS1格式 openssl genrsa -out rsa.pem 1024 # 生成与私钥对应的公钥,生成的是Subject Public Ke

  • 教你用Java实现RSA非对称加密算法

    一.非对称加密 非对称加密算法是一种密钥的保密方法. 非对称加密算法需要两个密钥:公开密钥(publickey:简称公钥)和私有密钥(privatekey:简称私钥).公钥与私钥是一对,如果用公钥对数据进行加密,只有用对应的私钥才能解密.因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法. 非对称加密算法实现机密信息交换的基本过程是:甲方生成一对密钥并将公钥公开,需要向甲方发送信息的其他角色(乙方)使用该密钥(甲方的公钥)对机密信息进行加密后再发送给甲方:甲方再用自己私钥对加密

  • c# RSA非对称加解密及XML&PEM格式互换方案

    最近因考虑接口安全问题,有实现给WEB API实现统一的参数鉴权功能,以防止请求参数被篡改或重复执行,参数鉴权方法基本与常见的鉴权思路相同,采用(timestamp+sign),而我为了防止timestamp被更改,sign算法(timestamp+相关参数排序.格式化后拼接再MD5)也因为在前端是不安全的,故对timestamp采取使用非对称加解密,以尽可能的保证生成的sign不易被破解或替换: RSA加解密(即:非对称加解密) 生成公钥.私钥对方法(C#),生成出来后默认都是XML格式: p

  • Python生成rsa密钥对操作示例

    本文实例讲述了Python生成rsa密钥对操作.分享给大家供大家参考,具体如下: # -*- coding: utf-8 -*- import rsa # 先生成一对密钥,然后保存.pem格式文件,当然也可以直接使用 (pubkey, privkey) = rsa.newkeys(1024) pub = pubkey.save_pkcs1() pubfile = open('public.pem','w+') pubfile.write(pub) pubfile.close() pri = pr

  • C#实现简单的RSA非对称加密算法示例

    本文实例讲述了C#实现简单的RSA非对称加密算法.分享给大家供大家参考,具体如下: 界面控件 namespace RSA算法 { partial class Form1 { /// <summary> /// 必需的设计器变量. /// </summary> private System.ComponentModel.IContainer components = null; /// <summary> /// 清理所有正在使用的资源. /// </summary

  • c# 实现RSA非对称加密算法

    目录 公钥与私钥 C#实现 公钥与私钥 公钥与私钥是成对的,一般的,我们认为的是公钥加密.私钥解密.私钥签名.公钥验证,有人说成私钥加密,公钥解密时不对的. 公钥与私钥的生成有多种方式,可以通过程序生成(下文具体实现),可以通过openssl工具: # 生成一个私钥,推荐使用1024位的秘钥,秘钥以pem格式保存到-out参数指定的文件中,采用PKCS1格式 openssl genrsa -out rsa.pem 1024 # 生成与私钥对应的公钥,生成的是Subject Public Key,

  • 使用openssl实现rsa非对称加密算法示例

    复制代码 代码如下: <?php/** * 使用openssl实现非对称加密 * @since 2010-07-08 */class Rsa{    /**     * private key     */        private $_privKey; /**         * public key         */        private $_pubKey; /**         * the keys saving path         */        privat

  • Python3非对称加密算法RSA实例详解

    本文实例讲述了Python3非对称加密算法RSA.分享给大家供大家参考,具体如下: python3 可以使用 Crypto.PublicKey.RSA 和 rsa 生成公钥.私钥. 其中 python3.6 Crypto 库的安装方式请参考前面一篇<Python3对称加密算法AES.DES3> rsa 加解密的库使用 pip3 install rsa 就行了 C:\WINDOWS\system32>pip3 install rsa Collecting rsa   Downloading

  • JAVA加密算法- 非对称加密算法(DH,RSA)的详细介绍

    非对称密码概念 1.与对称加密算法的主要差别在于,加密和解密的密钥不相同,一个公开(公钥),一个保密(私钥).主要解决了对称加密算法密钥分配管理的问题,提高了算法安全性. 2.非对称加密算法的加密.解密的效率比较低.在算法设计上,非对称加密算法对待加密的数据长度有着苛刻的要求.例如RSA算法要求待加密的数据不得大于53个字节. 3.非对称加密算法主要用于 交换对称加密算法的密钥,而非数据交换 4.java6提供实现了DH和RSA两种算法.Bouncy Castle提供了E1Gamal算法支持.除

  • 详解PHP使用非对称加密算法RSA

    加密的类型 在日常设计及开发中,为确保数据传输和数据存储的安全,可通过特定的算法,将数据明文加密成复杂的密文.目前主流加密手段大致可分为单向加密和双向加密. 单向加密:通过对数据进行摘要计算生成密文,密文不可逆推还原.算法代表:Base64,MD5,SHA; 双向加密:与单向加密相反,可以把密文逆推还原成明文,双向加密又分为对称加密和非对称加密. 对称加密:指数据使用者必须拥有相同的密钥才可以进行加密解密,就像彼此约定的一串暗号.算法代表:DES,3DES,AES,IDEA,RC4,RC5; 非

  • Java 实现常见的非对称加密算法

    概述 非对称加密算法与对称加密算法的主要差别在于非对称加密算法用于加密和解密的密钥不相同,非对称加密算法密钥分为公钥和私钥,公钥加密只能用私钥解密,反之私钥加密只能用公钥解密.相比对称加密算法,非对称加密算法加/解密效率低,但安全性高,这两种算法一般结合使用.常见非对称加密算法有RSA.ECC.Elgamal等. 使用RSA实现加密解密 公钥加密,私钥解密. package com.ss.utils; import javax.crypto.Cipher; import java.securit

  • java 非对称加密算法DH实现详解

    非对称加密算法是相对于对称加密算法来说的,对于对称加密算法请查阅之前的总结,今天为大家介绍一下DH算法,DH是一种密钥交换算法,接收方根据发送方加密时的密钥,生成接收方解密密钥.下面就一起来学习一下吧: 初始化发送方密钥: KeyPairGenerator sendKeyPairGenerator = KeyPairGenerator.getInstance("DH"); sendKeyPairGenerator.initialize(512); KeyPair sendKeyPair

随机推荐