/// <summary>
/// 解密
/// </summary>
/// <param name="s"></param>
/// <param name="key"></param>
/// <param name="isPublic"></param>
/// <returns></returns>
public string DecryptByPublicKey(string s, string key, bool isPublic)
{
s = s.Replace("\r", "").Replace("\n", "").Replace(" ", "");
//非对称加密算法，加解密用
IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
//加密
try
{
engine.Init(false, isPublic ? GetPublicKeyParameter(key) : GetPrivateKeyParameter(key));
byte[] byteData = Convert.FromBase64String(s);
int inputLen = byteData.Length;
MemoryStream ms = new MemoryStream();
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段加密
while (inputLen - offSet > 0)
{
if (inputLen - offSet > 128)
{
cache = engine.ProcessBlock(byteData, offSet, 128);
}
else
{
cache = engine.ProcessBlock(byteData, offSet, inputLen - offSet);
}
ms.Write(cache, 0, cache.Length);
i++;
offSet = i * 128;
}
byte[] encryptedData = ms.ToArray();
//var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
return(Encoding.UTF8.GetString(ms.ToArray()));
//Console.WriteLine("密文（base64编码）:" + Convert.ToBase64String(testData) + Environment.NewLine);
}
catch (Exception ex)
{
return(ex.Message);
}
}
public static string RsaEncryptBC(byte[] bytesToEncrypt)
{
var encryptEngine = new Pkcs1Encoding(new RsaEngine());
string certificateLocation = "Resources\\GSTN_G2B_SANDBOX_UAT_public.pem";
string publicKey = File.ReadAllText(certificateLocation).Replace("RSA PUBLIC", "PUBLIC");
using (var txtreader = new StringReader(publicKey))
{
var keyParameter = (AsymmetricKeyParameter) new PemReader(txtreader).ReadObject();
encryptEngine.Init(true, keyParameter);
}
var encrypted = Convert.ToBase64String(encryptEngine.ProcessBlock(bytesToEncrypt, 0, bytesToEncrypt.Length));
return(encrypted);
}
public static string RsaDecryptWithPublic(string base64Input, string publicKey)
{
var pem = string.Format(PUBLIC_KEY_FORMAT, publicKey);
var bytesToDecrypt = Convert.FromBase64String(base64Input);
var decryptEngine = new Pkcs1Encoding(new RsaEngine());
using (var txtreader = new StringReader(pem))
{
var keyParameter = (AsymmetricKeyParameter) new PemReader(txtreader).ReadObject();
decryptEngine.Init(false, keyParameter);
}
var decrypted = Encoding.UTF8.GetString(decryptEngine.ProcessBlock(bytesToDecrypt, 0, bytesToDecrypt.Length));
return(decrypted);
}
public static string RsaEncryptWithPrivate(string clearText, string privateKey)
{
var pem = string.Format(PRIVATE_KEY_FORMAT, privateKey);
var bytesToEncrypt = Encoding.UTF8.GetBytes(clearText);
var encryptEngine = new Pkcs1Encoding(new RsaEngine());
using (var txtreader = new StringReader(pem))
{
var keyPair = (AsymmetricCipherKeyPair) new PemReader(txtreader).ReadObject();
encryptEngine.Init(true, keyPair.Private);
}
var encrypted = Convert.ToBase64String(encryptEngine.ProcessBlock(bytesToEncrypt, 0, bytesToEncrypt.Length));
return(encrypted);
}
public byte[] Decrypt(byte[] data, string privateKey)
{
using (var reader = new StringReader(privateKey))
{
// https://stackoverflow.com/a/60423034
var pemReader = new Org.BouncyCastle.Utilities.IO.Pem.PemReader(reader);
var pem = pemReader.ReadPemObject();
AsymmetricKeyParameter pk = PrivateKeyFactory.CreateKey(pem.Content);
var cipher1 = new Pkcs1Encoding(new RsaEngine());
cipher1.Init(false, (ICipherParameters)pk);
var decipheredData = cipher1.ProcessBlock(data, 0, data.Length);
return(decipheredData);
}
}
public static void Verify_WithCorrectlySignedData_WillVerifyTheDataAsValid()
{
// Arrange
var signature = "This is a signature.";
var unsignedData = Encoding.UTF8.GetBytes(signature);
var signer = new Pkcs1Encoding(new RsaEngine());
signer.Init(true, TestExtensions.ClientPrivateKey.AsCipherParameters());
var signedData = signer.ProcessBlock(unsignedData, 0, unsignedData.Length);
// Act
var result = signedData.Verify(Encoding.UTF8.GetBytes(signature), TestExtensions.ClientPublicKey);
// Assert
Assert.True(result);
}
/// <summary>
/// 公钥加密
/// </summary>
/// <param name="s"></param>
/// <param name="key"></param>
/// <returns></returns>
public static string EncryptByPublicKey(string s, string key)
{
//非对称加密算法，加解密用
IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
//加密
try
{
engine.Init(true, GetPublicKeyParameter(key));
byte[] byteData = System.Text.Encoding.UTF8.GetBytes(s);
var resultData = engine.ProcessBlock(byteData, 0, byteData.Length);
return(Convert.ToBase64String(resultData));
}
catch (Exception ex)
{
return(null);
}
}
public byte[] RsaDecryptWithPrivateBytes(byte[] Input, string privateKey)
{
var bytesToDecrypt = Input;
AsymmetricCipherKeyPair keyPair;
var decryptEngine = new Pkcs1Encoding(new RsaEngine());
using (var txtreader = new StringReader(privateKey))
{
keyPair = (AsymmetricCipherKeyPair) new PemReader(txtreader).ReadObject();
decryptEngine.Init(false, keyPair.Private);
}
var res = decryptEngine.ProcessBlock(bytesToDecrypt, 0, bytesToDecrypt.Length);
//var decrypted = Encoding.UTF8.GetString(res);
return(res);
}
public byte[] RsaEncryptWithPublicBytes(byte[] clearData, string publicKey)
{
var bytesToEncrypt = clearData;
var encryptEngine = new Pkcs1Encoding(new RsaEngine());
using (var txtreader = new StringReader(publicKey))
{
var keyParameter = (AsymmetricKeyParameter) new PemReader(txtreader).ReadObject();
encryptEngine.Init(true, keyParameter);
}
var bytesRes = encryptEngine.ProcessBlock(bytesToEncrypt, 0, bytesToEncrypt.Length);
return(bytesRes);
}
public static string RsaBCEncryptPEM(byte[] bytesToEncrypt, string cert_file)
{
var encryptEngine = new Pkcs1Encoding(new RsaEngine());
string certificateLocation = System.IO.Path.Combine(GSTNConstants.base_path, "Resources\\" + cert_file);
string publicKey = File.ReadAllText(certificateLocation).Replace("RSA PUBLIC", "PUBLIC");
using (var txtreader = new StringReader(publicKey))
{
var keyParameter = (AsymmetricKeyParameter) new PemReader(txtreader).ReadObject();
encryptEngine.Init(true, keyParameter);
}
var encrypted = Convert.ToBase64String(encryptEngine.ProcessBlock(bytesToEncrypt, 0, bytesToEncrypt.Length));
return(encrypted);
}
/// <summary>
/// 公钥加密
/// </summary>
/// <param name="data">加密内容</param>
/// <param name="publicKey">公钥（Base64编码后的）</param>
/// <returns>返回Base64内容</returns>
public string EncryptByPublicKey(string data, string publicKey)
{
//非对称加密算法，加解密用
IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
//加密
try
{
engine.Init(true, GetPublicKeyParameter(publicKey));
byte[] byteData = Encoding_UTF8.GetBytes(data);
var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
return(Convert.ToBase64String(ResultData));
}
catch (Exception ex)
{
return(ex.Message);
}
}
public override bool GenerateSignature()
{
if (RsaKey.Instance.isKeyGenerated())
{
// RSA Schlüssellänge setzen für Methode in Oberklasse
this.m_KeyLength = RsaKey.Instance.RsaKeySize;
IAsymmetricBlockCipher signerPkcs1Enc = new Pkcs1Encoding(new RsaEngine());
signerPkcs1Enc.Init(true, RsaKey.Instance.getPrivKey());
byte[] output = signerPkcs1Enc.ProcessBlock(this.getCompleteHw(), 0, this.getCompleteHw().Length);
this.m_bSigGenerated = true;
this.m_Signature = output;
this.OnRaiseSigGenEvent(SignatureType.Pkcs1);
return(true);
}
return(false);
}
public static string RsaEncryptWithPublic(string clearText
, string publicKey)
{
var bytesToEncrypt = Encoding.UTF8.GetBytes(clearText);
var encryptEngine = new Pkcs1Encoding(new RsaEngine());
using (var txtreader = new StringReader(publicKey))
{
var keyParameter = (AsymmetricKeyParameter) new PemReader(txtreader).ReadObject();
encryptEngine.Init(true, keyParameter);
}
var encrypted = Convert.ToBase64String(encryptEngine.ProcessBlock(bytesToEncrypt, 0, bytesToEncrypt.Length));
return(encrypted);
}
// Decryption:
public string RsaDecryptWithPrivate(string base64Input, string privateKey)
{
var bytesToDecrypt = Convert.FromBase64String(base64Input);
AsymmetricCipherKeyPair keyPair;
var decryptEngine = new Pkcs1Encoding(new RsaEngine());
using (var txtreader = new StringReader(privateKey))
{
keyPair = (AsymmetricCipherKeyPair) new PemReader(txtreader).ReadObject();
decryptEngine.Init(false, keyPair.Private);
}
var decrypted = Encoding.UTF8.GetString(decryptEngine.ProcessBlock(bytesToDecrypt, 0, bytesToDecrypt.Length));
return(decrypted);
}
public static string Decrypt(string source)
{
byte[] publicInfoByte = Convert.FromBase64String(publicKeyJava);
AsymmetricKeyParameter pubKey = PublicKeyFactory.CreateKey(publicInfoByte);
IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
try
{
engine.Init(false, pubKey);
byte[] byteData = Convert.FromBase64String(source);
var resultData = engine.ProcessBlock(byteData, 0, byteData.Length);
return(Encoding.UTF8.GetString(resultData));
}
catch (Exception e)
{
return(e.Message);
}
}
public static string RSAEncrypt(string content, string privateKeyStr)
{
//content.NotNull(nameof(content));
var bytesToEncrypt = Encoding.UTF8.GetBytes(content);
var encryptEngine = new Pkcs1Encoding(new RsaEngine());
using (var txtreader = GetStreamReader(privateKeyStr))
{
var keyPair = (AsymmetricCipherKeyPair) new PemReader(txtreader).ReadObject();
encryptEngine.Init(true, keyPair.Private);
}
var encrypted = Convert.ToBase64String(encryptEngine.ProcessBlock(bytesToEncrypt, 0, bytesToEncrypt.Length));
return(encrypted);
}
/// <summary>
/// Generate cipher. The cipher can be reused.
/// </summary>
/// <param name="padding">Asymmetric algorithm padding mode.</param>
/// <param name="asymmetricKey">Asymmetric public key or private key.</param>
/// <returns></returns>
/// <exception cref="Exception"/>
public IAsymmetricBlockCipher GenerateCipher(AsymmetricPaddingMode padding, AsymmetricKeyParameter asymmetricKey)
{
IAsymmetricBlockCipher cipher = new RsaBlindedEngine();
switch (padding)
{
case AsymmetricPaddingMode.NoPadding: break;
case AsymmetricPaddingMode.PKCS1: cipher = new Pkcs1Encoding(cipher); break;
case AsymmetricPaddingMode.OAEP: cipher = new OaepEncoding(cipher); break;
case AsymmetricPaddingMode.ISO9796_1: cipher = new ISO9796d1Encoding(cipher); break;
default: throw new System.Security.Cryptography.CryptographicException("Unsupported padding mode.");
}
cipher.Init(!asymmetricKey.IsPrivate, asymmetricKey);
return(cipher);
}
private void RsaDecryptWithPrivate(string pathOfRsaPrivateKey, string pathOfEncryptedSessionKey)
{
string encrypted = File.ReadAllText(pathOfEncryptedSessionKey);
var bytesToDecrypt = Convert.FromBase64String(encrypted);
AsymmetricCipherKeyPair keyPair;
var decryptEngine = new Pkcs1Encoding(new RsaEngine());
using (var reader = File.OpenText(pathOfRsaPrivateKey))
{
keyPair = (AsymmetricCipherKeyPair) new PemReader(reader).ReadObject();
decryptEngine.Init(false, keyPair.Private);
}
var decrypted = Encoding.UTF8.GetString(decryptEngine.ProcessBlock(bytesToDecrypt, 0, bytesToDecrypt.Length));
Console.WriteLine("{0}", decrypted);
}
public byte[] Encrypt(byte[] data, string publicKey)
{
AsymmetricKeyParameter publicKeyParameters;
using (var reader = new StringReader(publicKey))
{
var pemReader = new PemReader(reader);
publicKeyParameters = (AsymmetricKeyParameter)pemReader.ReadObject();
}
var cipher = new Pkcs1Encoding(new RsaEngine());
cipher.Init(true, publicKeyParameters);
Console.WriteLine(cipher.AlgorithmName);
var cipheredData = cipher.ProcessBlock(data, 0, data.Length);
return(cipheredData);
}
public string DecryptWithPrivate(string base64Input, string privateKey)
{
privateKey = "-----BEGIN PRIVATE KEY-----" + Environment.NewLine + privateKey + Environment.NewLine + "-----END PRIVATE KEY-----";
var bytesToDecrypt = Convert.FromBase64String(base64Input);
var decryptEngine = new Pkcs1Encoding(new RsaEngine());
using (var txtreader = new StringReader(privateKey))
{
var r = new PemReader(txtreader).ReadObject();
decryptEngine.Init(false, (ICipherParameters)r);
}
var bytes = decryptEngine.ProcessBlock(bytesToDecrypt, 0, bytesToDecrypt.Length);
var decrypted = Encoding.UTF8.GetString(bytes, 0, bytes.Length);
return(decrypted);
}
public string EncryptByPrivateKey(string s, string key)
{
//非对称加密算法，加解密用
IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
//加密
try
{
engine.Init(true, GetPrivateKeyParameter(key));
byte[] byteData = System.Text.Encoding.UTF8.GetBytes(s);
var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
return(Convert.ToBase64String(ResultData));
// Console.WriteLine("密文（base64编码）:" + Convert.ToBase64String(testData) + Environment.NewLine);
}
catch (Exception ex)
{
return(ex.Message);
}
}
/// <summary>
/// 解密公钥
/// </summary>
/// <param name="s"></param>
/// <param name="key"></param>
/// <returns></returns>
/// <summary>
/// 解密公钥
/// </summary>
/// <param name="s"></param>
/// <param name="key"></param>
/// <returns></returns>
public static string DecryptByPublicKey(string s, string key)
{
s = s.Replace("\r", "").Replace("\n", "").Replace(" ", "");
//非对称加密算法，加解密用
IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
//解密
try
{
engine.Init(false, GetPublicKeyParameter(key));
byte[] byteData = Convert.FromBase64String(s);
var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
return(System.Text.Encoding.UTF8.GetString(ResultData));
}
catch (Exception ex)
{
return(ex.Message);
}
}
/// <summary>
/// RSA解密
/// </summary>
/// <param name="privateKey">私钥</param>
/// <param name="encryptedText">待解密的字符串(Base64)</param>
/// <returns>解密后的字符串</returns>
public static string Decrypt(string privateKey, string encryptedText)
{
using TextReader reader = new StringReader(privateKey);
dynamic key = new PemReader(reader).ReadObject();
var rsaDecrypt = new Pkcs1Encoding(new RsaEngine());
key = key switch
{
AsymmetricKeyParameter parameter => parameter,
AsymmetricCipherKeyPair pair => pair.Private,
_ => key
};
rsaDecrypt.Init(false, key); //这里加密是true；解密是false
var entData = Convert.FromBase64String(encryptedText);
entData = rsaDecrypt.ProcessBlock(entData, 0, entData.Length);
return(Encoding.UTF8.GetString(entData));
}
}
/// <summary>
/// 私钥解密
/// </summary>
/// <param name="data">待解密的内容</param>
/// <param name="privateKey">私钥（Base64编码后的）</param>
/// <returns>返回明文</returns>
public string DecryptByPrivateKey(string data, string privateKey)
{
data = data.Replace("\r", "").Replace("\n", "").Replace(" ", "");
//非对称加密算法，加解密用
IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
//解密
try
{
engine.Init(false, GetPrivateKeyParameter(privateKey));
byte[] byteData = Convert.FromBase64String(data);
var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
return(Encoding_UTF8.GetString(ResultData));
}
catch (Exception ex)
{
return(ex.Message);
}
}
public string EncryptByPublicKey(string s, string key)
{
//非对称加密算法，加解密用
IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
//加密
try
{
engine.Init(true, GetPublicKeyParameter(key));
byte[] byteData = System.Text.Encoding.UTF8.GetBytes(s);
int inputLen = byteData.Length;
MemoryStream ms = new MemoryStream();
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段加密
while (inputLen - offSet > 0)
{
if (inputLen - offSet > 117)
{
cache = engine.ProcessBlock(byteData, offSet, 117);
}
else
{
cache = engine.ProcessBlock(byteData, offSet, inputLen - offSet);
}
ms.Write(cache, 0, cache.Length);
i++;
offSet = i * 117;
}
byte[] encryptedData = ms.ToArray();
//var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
return(Convert.ToBase64String(encryptedData));
//Console.WriteLine("密文（base64编码）:" + Convert.ToBase64String(testData) + Environment.NewLine);
}
catch (Exception ex)
{
return(ex.Message);
}
}
public static string RsaEncryptWithPrivate(string dataToEncrypt)
{
try
{
var bytesToEncrypt = Encoding.UTF8.GetBytes(dataToEncrypt);
var encryptEngine = new Pkcs1Encoding(new RsaEngine());
using (var txtReader = new StringReader(_privateKeyString))
{
var keyPair = (AsymmetricCipherKeyPair) new PemReader(txtReader, new PasswordFinder("trdfdsfsd@12311".ToCharArray())).ReadObject();
encryptEngine.Init(true, keyPair.Private);
}
var encryptedText = Convert.ToBase64String(encryptEngine.ProcessBlock(bytesToEncrypt, 0, bytesToEncrypt.Length));
return(encryptedText);
}
catch
{
return(dataToEncrypt);
}
}
public string Decrypt(String ciphertext)
{
var bytesToDecrypt = Convert.FromBase64String(ciphertext);
var plaintext = "";
if (padding == PADDING_PKCS1V15)
{
var decryptEngine = new Pkcs1Encoding(new RsaEngine());
decryptEngine.Init(false, PrivateKey);
plaintext = Encoding.UTF8.GetString(decryptEngine.ProcessBlock(bytesToDecrypt, 0, bytesToDecrypt.Length));
}
else
{
var decryptEngine = new OaepEncoding(new RsaEngine());
decryptEngine.Init(false, PrivateKey);
plaintext = Encoding.UTF8.GetString(decryptEngine.ProcessBlock(bytesToDecrypt, 0, bytesToDecrypt.Length));
}
return(plaintext);
}
public static byte[] EncryptData(Pkcs1Encoding engine, byte[] data)
{
int inputBlockSize = engine.GetInputBlockSize(), totalBlocks = (data.Length + inputBlockSize - 1) / inputBlockSize;
byte[] result = new byte[totalBlocks * engine.GetOutputBlockSize()];
int inputOffset = 0, outputOffset = 0;
while (inputOffset < data.Length)
{
int dataToConsume = Math.Min(inputBlockSize, data.Length - inputOffset);
byte[] encryptedBlock = engine.ProcessBlock(data, inputOffset, dataToConsume);
Array.Reverse(encryptedBlock);
Buffer.BlockCopy(encryptedBlock, 0, result, outputOffset, encryptedBlock.Length);
inputOffset += dataToConsume;
outputOffset += encryptedBlock.Length;
}
return(result);
}
private async Task Encrypt(Stream inputStream, Stream outputStream, PublicKey publicKey)
{
if (publicKey == null)
{
throw new ArgumentNullException(nameof(publicKey));
}
var encryptEngine = new Pkcs1Encoding(new RsaEngine());
var pr = new PemReader(new StringReader(publicKey.Value));
var keyParameter = (RsaKeyParameters)pr.ReadObject();
if (keyParameter != null)
{
encryptEngine.Init(true, keyParameter);
}
else
{
throw new Exception();
}
await ProcessStream(inputStream, outputStream, encryptEngine);
}
public string RsaEncryptWithPrivate(string clearText, string privateKey)
{
var bytesToEncrypt = Encoding.UTF8.GetBytes(clearText);
var encryptEngine = new Pkcs1Encoding(new RsaEngine());
string encrypted = null;
using (var txtreader = new StringReader(privateKey))
{
var keyPair = (AsymmetricCipherKeyPair) new PemReader(txtreader).ReadObject();
if (keyPair != null)
{
encryptEngine.Init(true, keyPair.Private);
encrypted = Convert.ToBase64String(encryptEngine.ProcessBlock(bytesToEncrypt, 0, bytesToEncrypt.Length));
}
}
return(encrypted);
}
