public static byte[] RsaDecryptWithPublic(byte[] bytesToDecrypt, string publicKey)
{
var decryptEngine = new RsaEngine();
using (var txtreader = new StringReader(publicKey))
{
var keyParameter = (RsaKeyParameters) new PemReader(txtreader).ReadObject();
decryptEngine.Init(false, keyParameter);
}
return(decryptEngine.ProcessBlock(bytesToDecrypt, 0, bytesToDecrypt.Length));
}
/// <summary>
/// Preforms RSA decryption (or signing) using private key.
/// </summary>
/// <param name="privKey">The private key</param>
/// <param name="encrypted">Data to decrypt (or sign)</param>
/// <returns></returns>
internal static byte[] Decrypt(this RsaPrivateCrtKeyParameters privKey, byte[] encrypted)
{
if (encrypted == null)
{
throw new ArgumentNullException(nameof(encrypted));
}
RsaEngine engine = new RsaEngine();
engine.Init(false, privKey);
return(engine.ProcessBlock(encrypted, 0, encrypted.Length));
}
/// <summary>
/// Preforms RSA encryption using public key.
/// </summary>
/// <param name="pubKey">Public key</param>
/// <param name="data">Data to encrypt</param>
/// <returns></returns>
internal static byte[] Encrypt(this RsaKeyParameters pubKey, byte[] data)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
RsaEngine engine = new RsaEngine();
engine.Init(true, pubKey);
return(engine.ProcessBlock(data, 0, data.Length));
}
// Decryption:
public static byte[] RsaDecryptWithPrivate(byte[] bytesToDecrypt, string privateKey)
{
var decryptEngine = new RsaEngine();
using (var txtreader = new StringReader(privateKey))
{
var keyParameter = (AsymmetricCipherKeyPair) new PemReader(txtreader).ReadObject();
decryptEngine.Init(false, keyParameter.Private);
}
return(decryptEngine.ProcessBlock(bytesToDecrypt, 0, bytesToDecrypt.Length));
}
public static string Decryption(byte[] ct, RsaKeyParameters Pvtkey)
{
//IAsymmetricBlockCipher cipher = new OaepEncoding(new RsaEngine());
//cipher.Init(false, Pvtkey);
RsaEngine cipher = new RsaEngine();
cipher.Init(false, Pvtkey);
byte[] cipherText = cipher.ProcessBlock(ct, 0, ct.Length);
string descifrado = Encoding.ASCII.GetString(cipherText);
return(descifrado);
}
private void testSig(
int id,
RsaKeyParameters pub,
RsaKeyParameters prv,
byte[] slt,
byte[] msg,
byte[] sig)
{
RsaBlindingFactorGenerator blindFactorGen = new RsaBlindingFactorGenerator();
RsaBlindingEngine blindingEngine = new RsaBlindingEngine();
PssSigner blindSigner = new PssSigner(blindingEngine, new Sha1Digest(), 20);
PssSigner signer = new PssSigner(new RsaEngine(), new Sha1Digest(), 20);
blindFactorGen.Init(pub);
BigInteger blindFactor = blindFactorGen.GenerateBlindingFactor();
RsaBlindingParameters parameters = new RsaBlindingParameters(pub, blindFactor);
// generate a blind signature
blindSigner.Init(true, new ParametersWithRandom(parameters, new FixedRandom(slt)));
blindSigner.BlockUpdate(msg, 0, msg.Length);
byte[] blindedData = blindSigner.GenerateSignature();
RsaEngine signerEngine = new RsaEngine();
signerEngine.Init(true, prv);
byte[] blindedSig = signerEngine.ProcessBlock(blindedData, 0, blindedData.Length);
// unblind the signature
blindingEngine.Init(false, parameters);
byte[] s = blindingEngine.ProcessBlock(blindedSig, 0, blindedSig.Length);
//signature verification
if (!AreEqual(s, sig))
{
Fail("test " + id + " failed generation");
}
//verify signature with PssSigner
signer.Init(false, pub);
signer.BlockUpdate(msg, 0, msg.Length);
if (!signer.VerifySignature(s))
{
Fail("test " + id + " failed PssSigner verification");
}
}
static PublicRSA()
{
var openTibiaEncryptKey = new RsaKeyParameters(false, new BigInteger(OpenTibiaM), new BigInteger(OpenTibiaE));
OpenTibiaEncryptEngine = new RsaEngine();
OpenTibiaEncryptEngine.Init(true, openTibiaEncryptKey);
var realTibiaEncruptKey = new RsaKeyParameters(false, new BigInteger(RealTibiaM), new BigInteger(RealTibiaE));
RealTibiaEncryptEngine = new RsaEngine();
RealTibiaEncryptEngine.Init(true, realTibiaEncruptKey);
s_Random = new Random();
}
static RSA()
{
var openTibiaDecryptKey = new RsaPrivateCrtKeyParameters(new BigInteger(OpenTibiaM), new BigInteger(OpenTibiaE),
new BigInteger(OpenTibiaE), new BigInteger(OpenTibiaP), new BigInteger(OpenTibiaQ),
new BigInteger(OpenTibiaDP), new BigInteger(OpenTibiaDQ), new BigInteger(OpenTibiaInverseQ));
openTibiaDecryptEngine = new RsaEngine();
openTibiaDecryptEngine.Init(false, openTibiaDecryptKey);
var openTibiaEncryptKey = new RsaKeyParameters(false, new BigInteger(OpenTibiaM), new BigInteger(OpenTibiaE));
openTibiaEncryptEngine = new RsaEngine();
openTibiaEncryptEngine.Init(true, openTibiaEncryptKey);
}
/// <summary>
/// 公钥解密（key公钥解密）- 必须对应私钥加密
/// </summary>
/// <param name="source">加密后的数据（密文）</param>
/// <param name="publicKey">公钥</param>
/// <returns></returns>
public string DecryptByPublibKey(string source, string publicKey)
{
var publicInfoByte = Convert.FromBase64String(publicKey);
Asn1Object pubKeyObj = Asn1Object.FromByteArray(publicInfoByte);//这里也可以从流中读取，从本地导入
AsymmetricKeyParameter pubKey = PublicKeyFactory.CreateKey(SubjectPublicKeyInfo.GetInstance(pubKeyObj));
//开始解密
IAsymmetricBlockCipher cipher = new RsaEngine();
cipher.Init(false, pubKey);
//解密已加密的数据
byte[] encryptedData = Convert.FromBase64String(source);
encryptedData = cipher.ProcessBlock(encryptedData, 0, encryptedData.Length);
return(Encoding.UTF8.GetString(encryptedData, 0, encryptedData.Length));
}
/// <summary>
/// Gets the encrypting stream.
/// </summary>
/// <param name="output">The output.</param>
/// <returns></returns>
public FinishingStream GetEncryptingStream(Stream output, KeyczarBase keyczar)
{
var rsa = new RsaEngine();
var oaep = UpdatePadding(rsa);
return(new AsymmetricStream(
oaep,
output,
(cipher, encrypt) => cipher.Init(encrypt, new RsaKeyParameters(false,
Modulus.ToBouncyBigInteger(),
PublicExponent.ToBouncyBigInteger())),
encrypt: true));
}
/*
* Método estático para la encriptaicón
* */
public static string Encryption(string text, RsaKeyParameters PublicKey)
{
RsaEngine cipher = new RsaEngine();
cipher.Init(true, PublicKey);
byte[] ct = Encoding.ASCII.GetBytes(text);
byte[] cipherText = cipher.ProcessBlock(ct, 0, ct.Length);
string cifrado = Convert.ToBase64String(cipherText);
return(cifrado);
}
/// <summary>
/// Decrypt data using RSA Asymmetric Block Cipher
/// </summary>
/// <param name="data">The data to decrypt</param>
/// <param name="exponent">The key exponent to use</param>
/// <param name="key">The RSA key to use</param>
/// <returns>The decrypted data</returns>
public string DecryptRsa(string data, string exponent, string key)
{
BigInteger mod = new BigInteger(key, 16);
BigInteger pubExp = new BigInteger(exponent, 16);
RsaKeyParameters pubParameters = new RsaKeyParameters(false, mod, pubExp);
IAsymmetricBlockCipher eng = new RsaEngine();
eng.Init(true, pubParameters);
byte[] encdata = StringTools.HexStringToByteArray(data);
encdata = eng.ProcessBlock(encdata, 0, encdata.Length);
string result = StringTools.ByteArrayToHexString(encdata);
return(result);
}
private string EncryptData(string plaintext)
{
var bytesToEncrypt = StringHelper.StringToByteArray(plaintext);
var keyPair = GetPublicKey(Txt_PublicKey.Text);
var engine = new RsaEngine();
engine.Init(true, keyPair);
var encrypted = engine.ProcessBlock(bytesToEncrypt, 0, bytesToEncrypt.Length);
var cryptMessage = StringHelper.GetBase64(encrypted);
return(cryptMessage);
}
private string DecryptData(string ciphertext)
{
var bytesToDecrypt = StringHelper.Base64ToByteArray(ciphertext);
var keyPair = GetPrivateKey(Txt_PrivateKey.Text);
var decryptEngine = new RsaEngine();
decryptEngine.Init(false, keyPair.Private);
var decrypted = decryptEngine.ProcessBlock(bytesToDecrypt, 0, bytesToDecrypt.Length);
var decryptedMessage = StringHelper.ByteArrayToString(decrypted);
return(decryptedMessage);
}
//解密
public static string RSADecrypt(string data, string privkey)
{
byte[] privateInfoByte = Convert.FromBase64String(privkey);
//解密
AsymmetricKeyParameter priKey = PrivateKeyFactory.CreateKey(privateInfoByte);
IAsymmetricBlockCipher cipher = new RsaEngine();
//false表示解密
cipher.Init(false, priKey);
byte[] encryptData = Convert.FromBase64String(data);
string decryptData = Encoding.UTF8.GetString(cipher.ProcessBlock(encryptData, 0, encryptData.Length));
return(decryptData);
}
public byte[] Encrypt(byte[] message)
{
RsaEngine rsa = new RsaEngine();
rsa.Init(true, publicKey);
int blockSize = rsa.GetInputBlockSize();
List <byte> output = new List <byte>();
for (int chunkPosition = 0; chunkPosition < message.Length; chunkPosition += blockSize)
{
int chunkSize = Math.Min(blockSize, message.Length - (chunkPosition * blockSize));
byte[] tmp = rsa.ProcessBlock(message, chunkPosition, chunkSize);
output.AddRange(tmp);
}
return(output.ToArray());
}
public void TestRsa()
{
var generator = new RsaKeyPairGenerator();
generator.Init(new RsaKeyGenerationParameters(new BigInteger("11", 16), new SecureRandom(), 128, 6));
var pair = generator.GenerateKeyPair();
var rsaEngine = new RsaEngine();
rsaEngine.Init(true, pair.Public);
var data = Encoding.UTF8.GetBytes("Hello world");
var xdata = rsaEngine.ProcessBlock(data, 0, data.Length);
rsaEngine.Init(false, pair.Private);
var rdata = rsaEngine.ProcessBlock(xdata, 0, xdata.Length);
Assert.AreEqual("Hello world", Encoding.UTF8.GetString(rdata));
}
//加密
public static string RSAEncrypt(string data, string pubkey)
{
byte[] publicInfoByte = Convert.FromBase64String(pubkey);
//加密
Asn1Object pubKeyObj = Asn1Object.FromByteArray(publicInfoByte);
AsymmetricKeyParameter pubKey = PublicKeyFactory.CreateKey(SubjectPublicKeyInfo.GetInstance(pubKeyObj));
IAsymmetricBlockCipher cipher = new RsaEngine();
//true表示加密
cipher.Init(true, pubKey);
//加密
byte[] encryptData = cipher.ProcessBlock(Encoding.UTF8.GetBytes(data), 0, Encoding.UTF8.GetBytes(data).Length);
string retData = Convert.ToBase64String(encryptData);
return(retData);
}
public byte[] Decrypt(byte[] cipher)
{
RsaEngine rsa = new RsaEngine();
rsa.Init(false, privateKey);
int blockSize = rsa.GetInputBlockSize();
List <byte> output = new List <byte>();
for (int chunkPosition = 0; chunkPosition < cipher.Length; chunkPosition += blockSize)
{
int chunkSize = Math.Min(blockSize, cipher.Length - chunkPosition);
byte[] tmp = cipher.ToList().GetRange(chunkPosition, chunkSize).ToArray().Reverse().ToArray();
output.AddRange(rsa.ProcessBlock(tmp, 0, tmp.Length));
}
return(output.ToArray());
}
/*加密核心
* Src加密内容
*
* PFXorCER 证书
*
* Mode 加密或解密 true OR false
*/
private static byte[] RSAEDCore(byte[] Src, AsymmetricKeyParameter PFXorCER, bool Mode)
{
IAsymmetricBlockCipher engine = new RsaEngine();
IBufferedCipher Cipher = CipherUtilities.GetCipher("RSA/ECB/PKCS1Padding"); //加密标准
Cipher.Init(Mode, PFXorCER); //初始加密程序
byte[] EDString = null;
int blockSize = Cipher.GetBlockSize();
for (int i = 0; i < Src.Length; i += blockSize)
{
byte[] outBytes = Cipher.DoFinal(Subarray(Src, i, i + blockSize));//数据加密
EDString = AddAll(EDString, outBytes);
}
return(EDString);
}
/// <summary>
/// Executes the EMV Recovery Function to retrieve data.
/// </summary>
/// <param name="signature">EMV certificate to recover data from.</param>
/// <param name="publicKey">Public Key to use.</param>
/// <returns>Data recovered from the certificate.</returns>
public static byte[] RecoverMessage(this byte[] signature, AsymmetricKeyParameter publicKey)
{
IAsymmetricBlockCipher engine = new RsaEngine();
engine.Init(false, publicKey);
var x = engine.ProcessBlock(signature, 0, signature.Length);
return(x);
/*
* This section describes the special case of the digital signature scheme giving message recovery using a hash function according to ISO/IEC 9796-2 [3], which is used in the EMV specification for both static and dynamic data authentication.
* The digital signature scheme uses the following two types of algorithms.
* • A reversible asymmetric algorithm consisting of a signing function Sign($$S_{{K}})$$[ ] depending on a Private Key $$S_{{K}}$$ and a recovery function Recover($$P_{{K}})$$[ ] depending on a Public Key $$P_{{K}}$$. Both functions map N-byte numbers onto N-byte numbers and have the property that
* $${\rm Recover}({P}_{{K}})[{\rm Sign}({S}_{{K}})[{X}]] = {X},$$
* for any N-byte number X.
* • A hash algorithm Hash[ ] that maps a message of arbitrary length onto an 20-byte hash code.
*/
}
/// <summary>
/// 根据pem格式的key和明文，加密。此方法用的是BouncyCastle，因此公钥/私钥都能用于加密/解密
/// </summary>
/// <param name="pemKey">pem格式的key，可以为publicKey或是privateKey</param>
/// <param name="inBuf">明文的byte[]</param>
/// <returns></returns>
public static byte[] EncryptByPemKey(string pemKey, byte[] inBuf)
{
var pemReader = new PemReader(new StringReader(pemKey));
var rsaEngine = new RsaEngine();
var pemObject = pemReader.ReadObject();
if (pemObject is AsymmetricKeyParameter publicPara)
{
//如果pemKey为公钥
rsaEngine.Init(true, publicPara);
}
else if (pemObject is AsymmetricCipherKeyPair keyPair)
{
//如果pemKey为私钥
rsaEngine.Init(true, keyPair.Private);
}
return(rsaEngine.ProcessBlock(inBuf, 0, inBuf.Length));
}
public static string EncryptRSA(string encryptString, string encryptKey, int model)
{
AsymmetricKeyParameter encKey;
if (model == 1)
{
encKey = PublicKeyFactory.CreateKey(Convert.FromBase64String(encryptKey));
}
else
{
encKey = PrivateKeyFactory.CreateKey(Convert.FromBase64String(encryptKey));
}
IAsymmetricBlockCipher cipher = new RsaEngine();
cipher.Init(true, encKey);//true表示加密
byte[] encryptData = cipher.ProcessBlock(Encoding.UTF8.GetBytes(encryptString), 0, Encoding.UTF8.GetBytes(encryptString).Length);
return(Convert.ToBase64String(encryptData));
}
/// <summary>
/// Decrypts a file with a provided decryption key.
/// </summary>
/// <param name="filePath">An encrypted file</param>
/// <param name="key">The RSA key in PEM format</param>
/// <exception cref="ArgumentNullException">When the argument filePath is null</exception>
/// <exception cref="ArgumentNullException">When the argument keyPath is null</exception>
/// <returns>A memory stream with the decrypted file</returns>
public static MemoryStream DecryptRsa(string filePath, string key)
{
if (filePath == null)
{
throw new ArgumentNullException(nameof(filePath));
}
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
AsymmetricKeyParameter keyParameter = GetKeyOrDefault(key);
RsaEngine engine = new RsaEngine();
engine.Init(false, keyParameter);
MemoryStream outputStream = new MemoryStream();
using (FileStream inputStream = File.OpenRead(filePath))
{
int inputBlockSize = engine.GetInputBlockSize();
int outputBlockSize = engine.GetOutputBlockSize();
byte[] inputBlock = new byte[inputBlockSize];
while (inputStream.Read(inputBlock, 0, inputBlock.Length) > 0)
{
byte[] outputBlock = engine.ProcessBlock(inputBlock, 0, inputBlockSize);
int requiredPadding = outputBlockSize - outputBlock.Length;
if (requiredPadding > 0)
{
byte[] paddedOutputBlock = new byte[outputBlockSize];
outputBlock.CopyTo(paddedOutputBlock, requiredPadding);
outputBlock = paddedOutputBlock;
}
outputStream.Write(outputBlock, 0, outputBlock.Length);
}
}
outputStream.Seek(0, SeekOrigin.Begin);
return(outputStream);
}
static Rsa()
{
var openTibiaDecryptKey = new RsaPrivateCrtKeyParameters(new BigInteger(Constants.RSAKey.OpenTibiaM), new BigInteger(Constants.RSAKey.OpenTibiaE),
new BigInteger(Constants.RSAKey.OpenTibiaE), new BigInteger(Constants.RSAKey.OpenTibiaP), new BigInteger(Constants.RSAKey.OpenTibiaQ),
new BigInteger(Constants.RSAKey.OpenTibiaDP), new BigInteger(Constants.RSAKey.OpenTibiaDQ), new BigInteger(Constants.RSAKey.OpenTibiaInverseQ));
openTibiaDecryptEngine = new RsaEngine();
openTibiaDecryptEngine.Init(false, openTibiaDecryptKey);
var realTibiaEncryptKey = new RsaKeyParameters(false, new BigInteger(Constants.RSAKey.RealTibiaM), new BigInteger(Constants.RSAKey.RealTibiaE));
realTibiaEncryptEngine = new RsaEngine();
realTibiaEncryptEngine.Init(true, realTibiaEncryptKey);
var openTibiaEncryptKey = new RsaKeyParameters(false, new BigInteger(Constants.RSAKey.OpenTibiaM), new BigInteger(Constants.RSAKey.OpenTibiaE));
openTibiaEncryptEngine = new RsaEngine();
openTibiaEncryptEngine.Init(true, openTibiaEncryptKey);
}
static void Main(string[] args)
{
byte[][] X = new byte[11][];
Random rnd = new Random();
for (int i = 0; i < 11; ++i)
{
UTF8Encoding utf8enc = new UTF8Encoding();
X[i] = utf8enc.GetBytes(rnd.Next().ToString());
}
RsaKeyParameters[] P = new RsaKeyParameters[11];
for (int i = 0; i < 10; ++i)
{
RsaKeyPairGenerator rsaKeyPairGnr = new RsaKeyPairGenerator();
rsaKeyPairGnr.Init(new Org.BouncyCastle.Crypto.KeyGenerationParameters(new SecureRandom(), 512));
Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair keyPair = rsaKeyPairGnr.GenerateKeyPair();
RsaKeyParameters publicKey = (RsaKeyParameters)keyPair.Public;
IAsymmetricBlockCipher cipher = new RsaEngine();
P[i + 1] = publicKey;
}
RsaKeyPairGenerator rsaKeyPairGnr_s = new RsaKeyPairGenerator();
rsaKeyPairGnr_s.Init(new Org.BouncyCastle.Crypto.KeyGenerationParameters(new SecureRandom(), 512));
Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair keyPair_s = rsaKeyPairGnr_s.GenerateKeyPair();
P[0] = (RsaKeyParameters)keyPair_s.Public;
RsaKeyParameters Ks = (RsaKeyParameters)keyPair_s.Private;
string m = "Hello!!";
byte[] v = ring_sign(P, m, Ks, X);
Console.WriteLine("v: " + ByteArrayToString(v));
Console.WriteLine();
ring_verify(P, v, X, m);
}
private bool isProcessingOkay(
RsaKeyParameters pub,
RsaKeyParameters prv,
byte[] data,
SecureRandom random)
{
RsaBlindingFactorGenerator blindFactorGen = new RsaBlindingFactorGenerator();
RsaBlindingEngine blindingEngine = new RsaBlindingEngine();
PssSigner blindSigner = new PssSigner(blindingEngine, new Sha1Digest(), 20);
PssSigner pssEng = new PssSigner(new RsaEngine(), new Sha1Digest(), 20);
random.NextBytes(data);
blindFactorGen.Init(pub);
BigInteger blindFactor = blindFactorGen.GenerateBlindingFactor();
RsaBlindingParameters parameters = new RsaBlindingParameters(pub, blindFactor);
// generate a blind signature
blindSigner.Init(true, new ParametersWithRandom(parameters, random));
blindSigner.BlockUpdate(data, 0, data.Length);
byte[] blindedData = blindSigner.GenerateSignature();
RsaEngine signerEngine = new RsaEngine();
signerEngine.Init(true, prv);
byte[] blindedSig = signerEngine.ProcessBlock(blindedData, 0, blindedData.Length);
// unblind the signature
blindingEngine.Init(false, parameters);
byte[] s = blindingEngine.ProcessBlock(blindedSig, 0, blindedSig.Length);
//verify signature with PssSigner
pssEng.Init(false, pub);
pssEng.BlockUpdate(data, 0, data.Length);
return(pssEng.VerifySignature(s));
}
public static bool ring_verify(RsaKeyParameters[] P, byte[] v, byte[][] X, string m)
{
Console.WriteLine("Ring signature verification");
byte[][] y = new byte[11][];
for (int i = 0; i < 11; ++i)
{
IAsymmetricBlockCipher cipher = new RsaEngine();
cipher.Init(true, P[i]);
y[i] = cipher.ProcessBlock(X[i], 0, X[i].Length);
}
byte[] k1 = Encoding.UTF8.GetBytes(m);
byte[] k = new byte[64];
for (int i = 0; i < k1.Length; ++i)
{
k[i] = (byte)(k[i] + k1[i]);
}
byte[] ring = y[0];
for (int i = 1; i < 11; ++i)
{
ring = exclusiveOR(ring, k);
ring = exclusiveOR(ring, y[i]);
}
Console.WriteLine("v: " + ByteArrayToString(v));
Console.WriteLine("r: " + ByteArrayToString(ring));
if (ByteArrayToString(v).Equals(ByteArrayToString(ring)))
{
return(true);
}
else
{
return(false);
}
}
public virtual void DoTest7()
{
byte[] salt = new byte[0];
RsaKeyParameters pubParameters = new RsaKeyParameters(false, mod6, pub6);
RsaKeyParameters privParameters = new RsaKeyParameters(true, mod6, pri6);
ParametersWithSalt sigParameters = new ParametersWithSalt(privParameters, salt);
RsaEngine rsa = new RsaEngine();
byte[] data;
//
// ISO 9796-2 - PSS Signing
//
Iso9796d2PssSigner eng = new Iso9796d2PssSigner(rsa, new Sha1Digest(), 0, false);
eng.Init(true, sigParameters);
eng.Update(msg7[0]);
eng.BlockUpdate(msg7, 1, msg7.Length - 1);
data = eng.GenerateSignature();
eng.Init(false, pubParameters);
if (!IsSameAs(sig7, 0, data))
{
Fail("failed ISO9796-2 generation Test 7");
}
eng.Update(msg7[0]);
eng.BlockUpdate(msg7, 1, msg7.Length - 1);
if (!eng.VerifySignature(data))
{
Fail("failed ISO9796-2 verify Test 7");
}
if (!IsSameAs(msg7, 0, eng.GetRecoveredMessage()))
{
Fail("failed ISO9796-2 recovery Test 7");
}
}
public override string Undo(string command)
{
if (command.TryConvertTo(out DefineRsaWorkingKeyRequest dwkRequest))
{
this.requestedRSAParameters = new RSAParameters()
{
Modulus = dwkRequest.Modulus.Value,
Exponent = dwkRequest.Exponent.Value
};
var rsaProvider = new RSACryptoServiceProvider(RSA_KEY_LENGTH);
this.detouredRSAParameters = rsaProvider.ExportParameters(true);
dwkRequest.Modulus.Value = this.detouredRSAParameters.Modulus;
dwkRequest.Exponent.Value = this.detouredRSAParameters.Exponent;
return(dwkRequest.ToString());
}
else if (command.TryConvertTo(out DefineRsaWorkingKeyResponse dwkResponse))
{
var privateRsaParameters = new RsaPrivateCrtKeyParameters(
new BigInteger(1, this.detouredRSAParameters.Modulus), new BigInteger(1, this.detouredRSAParameters.Exponent),
new BigInteger(1, this.detouredRSAParameters.D), new BigInteger(1, this.detouredRSAParameters.P),
new BigInteger(1, this.detouredRSAParameters.Q), new BigInteger(1, this.detouredRSAParameters.DP),
new BigInteger(1, this.detouredRSAParameters.DQ), new BigInteger(1, this.detouredRSAParameters.InverseQ)
);
var rsaEngine = new RsaEngine();
rsaEngine.Init(false, privateRsaParameters);
var processedBlock = rsaEngine.ProcessBlock(dwkResponse.Cryptogram.Value, 0, dwkResponse.Cryptogram.Value.Length);
var decryptedRsaCryptogram = new DecryptedRsaCryptogram();
decryptedRsaCryptogram.Init(new StringReader(Encoding.ASCII.GetString(processedBlock)));
this.WorkingKey = decryptedRsaCryptogram.WorkingKey.Value;
var publicRsaParameters = new RsaKeyParameters(false,
new BigInteger(1, this.requestedRSAParameters.Modulus), new BigInteger(1, this.requestedRSAParameters.Exponent)
);
rsaEngine.Init(true, publicRsaParameters);
var unprocessedBlock = Encoding.ASCII.GetBytes(decryptedRsaCryptogram.ToString());
dwkResponse.Cryptogram.Value = rsaEngine.ProcessBlock(unprocessedBlock, 0, unprocessedBlock.Length);
return(dwkResponse.ToString());
}
return(base.Undo(command));
}
