C# RSA Asymmetric Encryption Algorithm

2023年4月25日 22点热度 0人点赞 0条评论

内容目录

Basic Knowledge

In C#, there are symmetric and asymmetric encryption methods, among which RSA is the most commonly used asymmetric encryption.

Due to significant changes in the encryption libraries in different .NET versions, this discussion will focus on versions after .NET 7.

Firstly, the inheritance relationship of RSA is as follows:

Object -> AsymmetricAlgorithm -> RSA -> RSACryptoServiceProvider

AsymmetricAlgorithm is a unified abstract interface for asymmetric encryption, while SymmetricAlgorithm serves as the abstract interface for symmetric encryption.

Asymmetric encryption consists of public and private keys, where the private key is mainly used for decryption, and the public key is used for encryption.

RSA is an abstract class that provides a unified abstraction for all RSA algorithms, and the RSACryptoServiceProvider class is an implementation of RSA.

To create an RSA class, you can use:

RSA.Create()

Or directly:

new RSACryptoServiceProvider()

Using RSACryptoServiceProvider directly, you can refer to the following example:

void Main()
{
	var keySize = 2048;

	var rsaCryptoServiceProvider = new RSACryptoServiceProvider(keySize);

	// Print private key and public key
	Convert.ToBase64String(rsaCryptoServiceProvider.ExportPkcs8PrivateKey()).Dump();
	Convert.ToBase64String(rsaCryptoServiceProvider.ExportRSAPublicKey()).Dump();

	var parameters = rsaCryptoServiceProvider.ExportParameters(true);
	// Encrypted string
	var cipherText = Encrypt("hello world", parameters);

	// Decrypted string
	var plainText = Decrypt(cipherText, parameters);
	Console.WriteLine(plainText);

}

// Encrypt
public string Encrypt(string data, RSAParameters key)
{

	using (var rsa = new RSACryptoServiceProvider())
	{
		rsa.ImportParameters(key);
		var byteData = Encoding.UTF8.GetBytes(data);
		var encryptData = rsa.Encrypt(byteData, false);
		return Convert.ToBase64String(encryptData);
	}
}

// Decrypt
public string Decrypt(string cipherText, RSAParameters key)
{

	using (var rsa = new RSACryptoServiceProvider())
	{
		var cipherByteData = Convert.FromBase64String(cipherText);
		rsa.ImportParameters(key);

		var encryptData = rsa.Decrypt(cipherByteData, false);
		return Encoding.UTF8.GetString(encryptData);
	}
}

Using the RSA Class

For loading RSA public and private keys, we can categorize them into two types: PKCS1 and PKCS8. For PKCS1, the export and import can be done directly, while PKCS8 requires a few more steps.

Here, we design a helper class for RSA, mainly targeting PKCS8, and the example code is as follows:

/// <summary>
/// Rsa encryption and decryption.
/// </summary>
public static class RsaHelper
{
    /// <summary>
    /// Export PKCS8 public key.
    /// </summary>
    /// <param name="rsa"></param>
    /// <returns></returns>
    public static string ExportPublichKeyPck8(this RSA rsa)
    {
        StringBuilder builder = new StringBuilder();
        builder.AppendLine("-----BEGIN PUBLIC KEY-----");
        builder.AppendLine(Convert.ToBase64String(rsa.ExportSubjectPublicKeyInfo(), Base64FormattingOptions.InsertLineBreaks));
        builder.AppendLine("-----END PUBLIC KEY-----");
        return builder.ToString();
    }

    public static void ImportPublichKeyPck8(this RSA rsa, string publicKey)
    {
        publicKey = publicKey
        .Replace("-----BEGIN RSA PUBLIC KEY-----", "")
        .Replace("-----END RSA PUBLIC KEY-----", "")
        .Replace("-----BEGIN PUBLIC KEY-----", "")
        .Replace("-----END PUBLIC KEY-----", "")
            .Replace("\r", "")
            .Replace("\n", "");

        rsa.ImportSubjectPublicKeyInfo(Convert.FromBase64String(publicKey), out var bytesRead);
    }

    /// <summary>
    /// Encrypt information.
    /// </summary>
    /// <param name="rsa"></param>
    /// <param name="message"></param>
    /// <param name="padding">e.g. <see cref="RSAEncryptionPadding.OaepSHA256"/></param>
    /// <returns></returns>
    public static string Encrypt(this RSA rsa, string message, RSAEncryptionPadding padding)
    {
        var encryptData = rsa.Encrypt(Encoding.UTF8.GetBytes(message), padding);
        return Convert.ToBase64String(encryptData);
    }

    /// <summary>
    /// Decrypt
    /// </summary>
    /// <param name="rsa"></param>
    /// <param name="message"></param>
    /// <param name="padding"></param>
    /// <returns></returns>
    public static string Decrypt(this RSA rsa, string message, RSAEncryptionPadding padding)
    {
        var cipherByteData = Convert.FromBase64String(message);

        var encryptData = rsa.Decrypt(cipherByteData, padding);
        return Encoding.UTF8.GetString(encryptData);
    }
}

You can use the following code to export RSA in PKCS8 format for both private and public keys, and then store them in files:

void Main()
{
	using (RSA rsa = RSA.Create())
	{
		rsa.ExportPkcs8PrivateKeyPem().Dump();

		string publicKeyPem = "-----BEGIN PUBLIC KEY-----\n" +
					  Convert.ToBase64String(rsa.ExportSubjectPublicKeyInfo(), Base64FormattingOptions.InsertLineBreaks) +
					  "\n-----END PUBLIC KEY-----";
					  publicKeyPem.Dump();
	}
}

file

You can import/export PKCS8 format private and public keys like this:

var privateKey = RSA.Create();
privateKey.ImportFromPem(File.ReadAllText("./private.key"));
var publicKey = RSA.Create();
publicKey.ImportPublichKeyPck8(File.ReadAllText("./public.key"));

You can check the correctness of the exported private and public keys here: https://www.bejson.com/enc/rsa/

Using RSACryptoServiceProvider

Continue using the two public and private key files generated earlier.

Write the import method:

/// <summary>
/// Import public key
/// </summary>
/// <param name="rsa"></param>
/// <param name="publicKey"></param>
/// <returns></returns>
private static RSACryptoServiceProvider ImportPublicKeyFromPEM(RSACryptoServiceProvider rsa, string publicKey)
{
	publicKey = publicKey
	.Replace("-----BEGIN RSA PUBLIC KEY-----", "")
	.Replace("-----END RSA PUBLIC KEY-----", "")
	.Replace("-----BEGIN PUBLIC KEY-----", "")
	.Replace("-----END PUBLIC KEY-----", "")
		.Replace("\r", "")
		.Replace("\n", "");
	rsa.ImportSubjectPublicKeyInfo(Convert.FromBase64String(publicKey), out var bytesRead);
	return rsa;
}

Import the PKCS8 format public key:

var publicKey = new RSACryptoServiceProvider();
RsaHelper.ImportPublicKeyFromPEM(publicKey, File.ReadAllText("./public.key"));

Since RSACryptoServiceProvider implements RSA, the usage methods are also quite similar.

However, RSA.Create() defaults to returning RSAWrapper and RSACng.

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可

C# RSA Asymmetric Encryption Algorithm

Basic Knowledge

Using the RSA Class

Using RSACryptoServiceProvider

文章评论