// Use the RSAOAEPKeyExchangeDeformatter class to decode the
// specified message.
private string DecodeMessage(byte[] encodedMessage)
{
string decodedMessage = null;
try
{
// Construct a deformatter with the specified RSA key.
//<Snippet8>
RSAOAEPKeyExchangeDeformatter keyDecryptor =
new RSAOAEPKeyExchangeDeformatter(rsaKey);
//</Snippet8>
// Decrypt the encoded message.
//<Snippet9>
byte[] decodedBytes =
keyDecryptor.DecryptKeyExchange(encodedMessage);
//</Snippet9>
// Retrieve a string representation of the decoded message.
decodedMessage = Encoding.ASCII.GetString(decodedBytes);
}
catch (Exception ex)
{
Console.WriteLine("Unexpected exception caught:" + ex.ToString());
}
return(decodedMessage);
}
public void ExchangeTooBig()
{
AsymmetricKeyExchangeDeformatter keyex = new RSAOAEPKeyExchangeDeformatter(key);
byte[] EM = new byte [(key.KeySize >> 3) + 1];
// invalid format
byte[] M = keyex.DecryptKeyExchange(EM);
}
/// <summary>秘密鍵生成</summary>
/// <param name="exchangeKeyOfAlice">Aliceの交換鍵</param>
/// <param name="iv">初期化ベクター</param>
public void GeneratePrivateKey(byte[] exchangeKeyOfAlice, byte[] iv)
{
this._aes = new AesCryptoServiceProvider();
RSAOAEPKeyExchangeDeformatter keyExchangeDeformatter = new RSAOAEPKeyExchangeDeformatter(this._asa);
this._aes.Key = keyExchangeDeformatter.DecryptKeyExchange(exchangeKeyOfAlice);
this._aes.IV = iv;
}
public byte[] Decrypt_RSA(byte[] input)
{
if (input == null || input.Length == 0)
{
ErrorHandler.OccurException(System.Net.HttpStatusCode.BadRequest);
}
return(_RSADeformatter.DecryptKeyExchange(input));
}
public byte[] DecryptSessionKeyByRSA(byte[] exchangeData)
{
AsymmetricAlgorithm rsa = algo;
RSAOAEPKeyExchangeDeformatter defor = new RSAOAEPKeyExchangeDeformatter();
defor.SetKey(rsa);
byte[] keySession = defor.DecryptKeyExchange(exchangeData);
return(keySession);
}
public void Bug79320()
{
string s = "hdphq/mn8goBi43YGPkmOfPj5vXjHrKPJkT4mLT3l+XzLttHMLC4/yBYkuzlXtbrl2jtAJRb6oA8UcQFalUMnCa09LDZrgNU2yySn7YbiG8raSq7u2nfDCbPu+c8T9fyHxrCHrX0zeqqImX33csIn6rIrQZ8HKcMsoQso4qtS2A=";
byte [] bytes = Convert.FromBase64String(s);
RSACryptoServiceProvider r = new RSACryptoServiceProvider();
r.FromXmlString("<RSAKeyValue><Modulus>iSObDmmhDgrl4NiLaviFcpv4NdysBWJcqiVz3AQbPdajtXaQQ8VJdfRkixah132yKOFGCWZhHS3EuPMh8dcNwGwta2nh+m2IV6ktzI4+mZ7CSNAsmlDY0JI+H8At1vKvNArlC5jkVGuliYroJeSU/NLPLNYgspi7TtXGy9Rfug8=</Modulus><Exponent>EQ==</Exponent><P>pd4svtxrnTWXVSb151/JFgT9szI6dxQ5pAFPd4A4yuxLLEay2W2z7d9LVk5siMFhZ10uTJGWzNP5pSgLT8wdww==</P><Q>06j6m4cGRc3uoKVuFFGA19JG3Bi4tDBEQHebEc/Y3+eThrOasYIRrQmGUfqWnd9eFitO9GOaVJ0muNDV7NOxxQ==</Q><DP>OoqmYXr4zhLqHg3AM4s36adomZlBz6zJDLUrGx4yKYCTAJFsTL1OkDCxLYUXP1NPjeSm7dkIDA6UWGh8doRGvQ==</DP><DQ>PkDCLb5NI5br1OVcnJBxMGsFyEOBnmiMi2545x8DjSX+Nq1LnZ6555ljvcIsTIz9jgy83nel3KaxCS5dCWtwhQ==</DQ><InverseQ>OrFYaG7wTqim/bub4qY0CvIfhsjG4/4MEabg0UFTf/+tekKas7DDKg2TD5BS2q0O3XEt7xIfp0S6dpOAnrlyGQ==</InverseQ><D>IESc9FUW1iCuj0ICr8IBSCSy3383iMvZkXI5YPHoSskXdf3Hl3m27pPbbAVTQcM4+o9bxfn4u5JMZ8C8sV/G/8Cfl4ss1NVMbZOecvVObRqRpqXaveq5fN2X0EklH1wzm5w3O8cMXdbC/hc0gKUqaMjFVn1zpf3zVjpOkY0eGRE=</D></RSAKeyValue>");
RSAOAEPKeyExchangeDeformatter def = new RSAOAEPKeyExchangeDeformatter(r);
AssertNotNull(def.DecryptKeyExchange(bytes));
}
public static byte[] Unprotect(byte[] encryptedData, byte[] optionalEntropy, DataProtectionScope scope)
{
if (encryptedData == null)
{
throw new ArgumentNullException("encryptedData");
}
byte[]? decdata = null;
Rijndael aes = Rijndael.Create();
RSA rsa = GetKey(scope);
int headerSize = (rsa.KeySize >> 3);
bool valid1 = (encryptedData.Length >= headerSize);
if (!valid1)
{
headerSize = encryptedData.Length;
}
byte[] header = new byte[headerSize];
Buffer.BlockCopy(encryptedData, 0, header, 0, headerSize);
byte[]? secret = null;
byte[]? key = null;
byte[]? iv = null;
bool valid2 = false;
bool valid3 = false;
bool valid4 = false;
using SHA256 hash = SHA256.Create();
try
{
try
{
RSAOAEPKeyExchangeDeformatter deformatter = new RSAOAEPKeyExchangeDeformatter(rsa);
secret = deformatter.DecryptKeyExchange(header);
valid2 = (secret.Length == 68);
}
catch
{
valid2 = false;
}
if (!valid2)
{
secret = new byte[68];
}
// known values for structure (version 1 or 2)
valid3 = ((secret ![1] == 16) && (secret[18] == 16) && (secret[35] == 32));
public static void TestKnownValueOaep()
{
using (RSA rsa = RSAFactory.Create())
{
rsa.ImportParameters(TestData.RSA1024Params);
byte[] encrypted =
( "19134ffba4025a1c651120ca07258a46e005a327c3927f615465060734dc0339114cabfd13803288883abf9329296a3e3a5cb1587927"
+ "a6e8a2e736f0a756e342b4adb0f1de5bba9ba5faee30456fb7409678eb71a70185606eda3303d9425fbeb730ab7803bea50e208b563f"
+ "e9bfa97a8966deefb211a3bd6abe08cd15e0b927").HexToByteArray();
RSAOAEPKeyExchangeDeformatter deformatter = new RSAOAEPKeyExchangeDeformatter(rsa);
byte[] plain = deformatter.DecryptKeyExchange(encrypted);
byte[] expectedPlain = { 0x41, 0x42, 0x43 };
Assert.Equal(expectedPlain, plain);
}
}
public static void TestKnownValueOaep()
{
using (RSA rsa = RSAFactory.Create())
{
rsa.ImportParameters(TestData.RSA1024Params);
byte[] encrypted =
("19134ffba4025a1c651120ca07258a46e005a327c3927f615465060734dc0339114cabfd13803288883abf9329296a3e3a5cb1587927"
+ "a6e8a2e736f0a756e342b4adb0f1de5bba9ba5faee30456fb7409678eb71a70185606eda3303d9425fbeb730ab7803bea50e208b563f"
+ "e9bfa97a8966deefb211a3bd6abe08cd15e0b927").HexToByteArray();
RSAOAEPKeyExchangeDeformatter deformatter = new RSAOAEPKeyExchangeDeformatter(rsa);
byte[] plain = deformatter.DecryptKeyExchange(encrypted);
byte[] expectedPlain = { 0x41, 0x42, 0x43 };
Assert.Equal(expectedPlain, plain);
}
}
private void DecryptButton_Click(object sender, EventArgs e)
{
RSA myRSAProv;
if (CngKey.Exists(KeyContainerEncryptTextBox.Text))
{
myRSAProv = new RSACng(CngKey.Open(KeyContainerDecryptTextBox.Text));
}
else
{
myRSAProv = new RSACng(CngKey.Create(CngAlgorithm.Rsa, KeyContainerDecryptTextBox.Text));
}
RSAOAEPKeyExchangeDeformatter myKeyFormatter = new RSAOAEPKeyExchangeDeformatter(myRSAProv);
AesCng mySymmProv = new AesCng();
using (FileStream fs = new FileStream(FileDecryptTextBox.Text, FileMode.Open))
{
int keyLength;
byte[] encrKey;
int ivLength;
byte[] IV;
using (BinaryReader br = new BinaryReader(fs))
{
keyLength = br.ReadInt32();
encrKey = new byte[keyLength];
br.Read(encrKey, 0, keyLength);
ivLength = br.ReadInt32();
IV = new byte[ivLength];
br.Read(IV, 0, ivLength);
byte[] Key = myKeyFormatter.DecryptKeyExchange(encrKey);
mySymmProv.Key = Key;
mySymmProv.IV = IV;
using (CryptoStream cs = new CryptoStream(fs, mySymmProv.CreateDecryptor(), CryptoStreamMode.Read))
{
int dataLen = (int)fs.Length - 4 - keyLength - 4 - ivLength;
byte[] data = new byte[dataLen];
int len = cs.Read(data, 0, dataLen);
using (FileStream outStream = File.Open(FileDecryptTextBox.Text.Replace("encrypted", "decrypted"), FileMode.OpenOrCreate))
{
outStream.Write(data, 0, len);
}
}
}
}
MessageBox.Show("Decryption completed.");
}
public void Exchange128()
{
AsymmetricKeyExchangeFormatter keyex = new RSAOAEPKeyExchangeFormatter(key);
byte[] M = { 0xd4, 0x36, 0xe9, 0x95, 0x69, 0xfd, 0x32, 0xa7, 0xc8, 0xa0, 0x5b, 0xbc, 0x90, 0xd3, 0x2c, 0x49 };
try {
byte[] EM = keyex.CreateKeyExchange(M, typeof(Rijndael));
AsymmetricKeyExchangeDeformatter keyback = new RSAOAEPKeyExchangeDeformatter(key);
byte[] Mback = keyback.DecryptKeyExchange(EM);
AssertEquals("RSAOAEPKeyExchangeFormatter 128", M, Mback);
}
catch (CryptographicException ce) {
// not supported by every version of Windows - Minimum: Windows XP
Console.WriteLine(ce.Message + " (" + Environment.OSVersion.ToString() + ")");
}
}
public void ExchangeMin()
{
AsymmetricKeyExchangeFormatter keyex = new RSAOAEPKeyExchangeFormatter(key);
byte[] M = { 0x01 };
try {
byte[] EM = keyex.CreateKeyExchange(M);
AsymmetricKeyExchangeDeformatter keyback = new RSAOAEPKeyExchangeDeformatter(key);
byte[] Mback = keyback.DecryptKeyExchange(EM);
AssertEquals("RSAOAEPKeyExchangeFormatter Min", M, Mback);
}
catch (CryptographicException ce) {
// not supported by every version of Windows - Minimum: Windows XP
Console.WriteLine(ce.Message + " (" + Environment.OSVersion.ToString() + ")");
}
}
public void CapiExchange128()
{
byte[] M = { 0xd4, 0x36, 0xe9, 0x95, 0x69, 0xfd, 0x32, 0xa7, 0xc8, 0xa0, 0x5b, 0xbc, 0x90, 0xd3, 0x2c, 0x49 };
byte[] EM = { 0x6D, 0xAA, 0xBC, 0x7C, 0xE7, 0x7C, 0xE6, 0x16, 0x72, 0x6F, 0xBE, 0xAF, 0x26, 0xBF, 0x87, 0x77, 0xB5, 0x47, 0x25, 0x37, 0x01, 0xC7, 0xD8, 0x18, 0xA8, 0x09, 0x0F, 0x1F, 0x13, 0x24, 0xD0, 0x2A, 0xD4, 0xDC, 0x5A, 0x2D, 0x91, 0x6D, 0x11, 0x6C, 0x1A, 0x67, 0xB2, 0xFC, 0xA3, 0xE7, 0xF4, 0xEF, 0xDC, 0xEC, 0xB2, 0xAF, 0x42, 0xB5, 0xD9, 0x7A, 0x6D, 0xE5, 0x76, 0xBA, 0x7D, 0x04, 0xCA, 0x17, 0xB0, 0x06, 0x88, 0x4D, 0xE8, 0xCC, 0x82, 0xEA, 0x13, 0xC8, 0x12, 0x05, 0x05, 0xC6, 0xB0, 0x4B, 0x53, 0x1D, 0x07, 0xFA, 0x09, 0x64, 0x30, 0xCD, 0x5C, 0xE3, 0x41, 0xB1, 0x25, 0x94, 0x05, 0x5A, 0xC2, 0xD8, 0x2E, 0xC4, 0x39, 0x51, 0x73, 0x75, 0x0C, 0x4B, 0x2F, 0x4B, 0xAD, 0x04, 0x54, 0x32, 0x30, 0x94, 0xF4, 0xFE, 0x92, 0xF4, 0xB4, 0x54, 0x07, 0x22, 0xCD, 0xB5, 0xB2, 0x01, 0x95, 0xA0 };
AsymmetricKeyExchangeDeformatter keyback = new RSAOAEPKeyExchangeDeformatter(key);
try {
byte[] Mback = keyback.DecryptKeyExchange(EM);
AssertEquals("RSAOAEPKeyExchangeFormatter 1", M, Mback);
}
catch (CryptographicException ce) {
// not supported by every version of Windows - Minimum: Windows XP
Console.WriteLine(ce.Message + " (" + Environment.OSVersion.ToString() + ")");
}
}
public void MonoExchange192()
{
byte[] M = { 0xd4, 0x36, 0xe9, 0x95, 0x69, 0xfd, 0x32, 0xa7, 0xc8, 0xa0, 0x5b, 0xbc, 0x90, 0xd3, 0x2c, 0x49, 0x00, 0x00, 0x00, 0x00 };
byte[] EM = { 0xAD, 0xFA, 0x95, 0x2E, 0xCE, 0x23, 0xBE, 0xA5, 0x77, 0x81, 0x34, 0x98, 0x64, 0x58, 0x02, 0xAB, 0x62, 0x28, 0x97, 0x84, 0x6D, 0xF3, 0xE1, 0x9D, 0xB2, 0x04, 0xA8, 0xB0, 0x1D, 0x48, 0xFC, 0x94, 0x1A, 0x3A, 0xB1, 0x72, 0x39, 0xE1, 0xFE, 0x25, 0xF6, 0x6E, 0x64, 0xA5, 0x84, 0xA3, 0x2F, 0x3D, 0x49, 0x4F, 0x7F, 0xD1, 0x45, 0x74, 0xFB, 0x42, 0x6F, 0x50, 0x5C, 0x19, 0x44, 0xB8, 0x0F, 0x3B, 0x31, 0x94, 0x8E, 0xC2, 0x44, 0x47, 0xA2, 0xE9, 0x6E, 0x7F, 0x58, 0x49, 0x38, 0xB9, 0x2C, 0xB8, 0x0E, 0xA9, 0x7A, 0x86, 0x2B, 0xDB, 0xED, 0x5A, 0x16, 0x48, 0x41, 0x84, 0x3B, 0xE3, 0xA8, 0x26, 0x01, 0xAE, 0x09, 0x41, 0xB3, 0x95, 0xC5, 0xA4, 0x5A, 0x82, 0xC3, 0x37, 0x57, 0xD9, 0x03, 0x53, 0x8D, 0x28, 0x24, 0xA4, 0x37, 0x2A, 0xA9, 0xC7, 0x66, 0xAD, 0xAC, 0x5F, 0x3A, 0xF0, 0xE5, 0x90 };
AsymmetricKeyExchangeDeformatter keyback = new RSAOAEPKeyExchangeDeformatter(key);
try {
byte[] Mback = keyback.DecryptKeyExchange(EM);
AssertEquals("RSAOAEPKeyExchangeFormatter 192", M, Mback);
}
catch (CryptographicException ce) {
// not supported by every version of Windows - Minimum: Windows XP
Console.WriteLine(ce.Message + " (" + Environment.OSVersion.ToString() + ")");
}
}
public void CapiExchangeMin()
{
byte[] M = { 0x01 };
byte[] EM = { 0x4D, 0x5F, 0x26, 0x67, 0x88, 0x07, 0xF1, 0xB5, 0x85, 0x33, 0xDA, 0x8B, 0xD6, 0x9E, 0x9B, 0x56, 0xE6, 0x54, 0x49, 0xF3, 0x4A, 0x8B, 0x5B, 0xB2, 0xCB, 0x10, 0x50, 0x91, 0x85, 0xBC, 0xE1, 0x5E, 0xDC, 0x8A, 0xAE, 0x63, 0xAD, 0x57, 0xC3, 0x03, 0x78, 0xDD, 0xCE, 0xCD, 0x46, 0x71, 0x43, 0x2F, 0x7F, 0xA4, 0x6A, 0x93, 0xE4, 0xB7, 0x4C, 0x36, 0x92, 0x5C, 0xFF, 0xAC, 0x32, 0xE8, 0x71, 0x1E, 0x69, 0xD6, 0x8C, 0xB5, 0x65, 0xA5, 0x83, 0xC2, 0x3F, 0xED, 0x35, 0x6F, 0x03, 0x0D, 0x4B, 0xE1, 0x0F, 0x7B, 0x5D, 0x0A, 0x68, 0x90, 0x71, 0xA0, 0xD6, 0xC0, 0xEC, 0x6B, 0x24, 0x45, 0x3D, 0x9C, 0x11, 0xD9, 0xC8, 0xFB, 0xC8, 0x8F, 0xDB, 0x48, 0x70, 0x1F, 0xC4, 0x7D, 0x83, 0x58, 0x95, 0xDC, 0x36, 0xA0, 0x68, 0xE1, 0xCF, 0x2D, 0xA9, 0x8A, 0xF0, 0xB8, 0xA6, 0x0D, 0x6E, 0xA6, 0x9C, 0xBC };
AsymmetricKeyExchangeDeformatter keyback = new RSAOAEPKeyExchangeDeformatter(key);
try {
byte[] Mback = keyback.DecryptKeyExchange(EM);
AssertEquals("RSAOAEPKeyExchangeDeformatter 1", M, Mback);
}
catch (CryptographicException ce) {
// not supported by every version of Windows - Minimum: Windows XP
Console.WriteLine(ce.Message + " (" + Environment.OSVersion.ToString() + ")");
}
}
public void MonoExchangeMax()
{
byte[] M = new byte [(key.KeySize >> 3) - 2 * 20 - 2];
byte[] EM = { 0x6C, 0x3E, 0x71, 0x14, 0xAD, 0xDE, 0x46, 0x26, 0x42, 0xA8, 0x84, 0x40, 0xCC, 0x06, 0x73, 0xCC, 0x88, 0x76, 0x40, 0x08, 0x93, 0xE5, 0x5F, 0xFF, 0x7D, 0x02, 0x88, 0xE9, 0x2D, 0xF6, 0x90, 0xA1, 0x8F, 0x64, 0x9A, 0x79, 0x67, 0x63, 0xA5, 0xBE, 0xCE, 0x7F, 0x48, 0x65, 0x8F, 0x53, 0x24, 0x70, 0x4F, 0x2A, 0x61, 0x7C, 0x95, 0xB6, 0xD0, 0x1D, 0x6F, 0x92, 0xA5, 0x2B, 0xB9, 0x13, 0x6B, 0xD2, 0xEB, 0x1D, 0x4F, 0x1E, 0x51, 0x6D, 0x65, 0xA6, 0x97, 0xE8, 0x60, 0x4B, 0x19, 0xE4, 0x23, 0xDC, 0x22, 0xED, 0x23, 0x02, 0x5E, 0x0C, 0x0B, 0x99, 0x5D, 0xBA, 0xFC, 0xBD, 0x75, 0x2F, 0x3E, 0xCD, 0x33, 0xBF, 0x08, 0xD5, 0x31, 0x68, 0x7C, 0x51, 0x2E, 0xBF, 0x8A, 0xBF, 0xA9, 0x8F, 0x0A, 0xDF, 0xB0, 0x91, 0xB1, 0x95, 0x03, 0x37, 0x3C, 0x77, 0x61, 0x75, 0x06, 0x61, 0xD8, 0x94, 0x04, 0x42 };
AsymmetricKeyExchangeDeformatter keyback = new RSAOAEPKeyExchangeDeformatter(key);
try {
byte[] Mback = keyback.DecryptKeyExchange(EM);
AssertEquals("RSAOAEPKeyExchangeFormatter Max", M, Mback);
}
catch (CryptographicException ce) {
// not supported by every version of Windows - Minimum: Windows XP
Console.WriteLine(ce.Message + " (" + Environment.OSVersion.ToString() + ")");
}
}
public void MonoExchangeMin()
{
byte[] M = { 0x01 };
byte[] EM = { 0x75, 0x06, 0x33, 0xB4, 0x47, 0xDB, 0x9C, 0x72, 0x1A, 0x09, 0x48, 0xEA, 0xF3, 0xED, 0xCF, 0xA7, 0x6D, 0x09, 0x8E, 0xF5, 0xC9, 0x70, 0x18, 0xF7, 0x22, 0xCC, 0xEC, 0xCB, 0xD3, 0x2B, 0xE7, 0xE3, 0x0A, 0x47, 0xF4, 0xE1, 0x66, 0x73, 0xEA, 0x7F, 0x5B, 0x27, 0x32, 0x62, 0x9D, 0x0C, 0x2F, 0x88, 0x2E, 0x3A, 0x37, 0x6C, 0x0C, 0x09, 0x1D, 0xF3, 0xE1, 0x80, 0x66, 0x26, 0x29, 0x97, 0x3D, 0xB7, 0xE6, 0x01, 0xD0, 0x88, 0x9C, 0x68, 0x3F, 0x62, 0x7C, 0x71, 0x36, 0xDA, 0xC3, 0xE2, 0x93, 0x20, 0x95, 0xF8, 0x15, 0x89, 0x73, 0x24, 0xDF, 0xFB, 0x72, 0xD9, 0x63, 0x19, 0x84, 0x41, 0x92, 0x3C, 0x71, 0x36, 0xB9, 0x09, 0x24, 0xD6, 0x8E, 0x2D, 0x5A, 0xF2, 0x4B, 0xF4, 0xCD, 0x58, 0xEB, 0x4E, 0xE4, 0x97, 0xB3, 0x09, 0xED, 0xCF, 0x6A, 0x6D, 0xBC, 0xE4, 0xD4, 0x8D, 0xEC, 0xA6, 0x35, 0x53 };
AsymmetricKeyExchangeDeformatter keyback = new RSAOAEPKeyExchangeDeformatter(key);
try {
byte[] Mback = keyback.DecryptKeyExchange(EM);
AssertEquals("RSAOAEPKeyExchangeDeformatter Min", M, Mback);
}
catch (CryptographicException ce) {
// not supported by every version of Windows - Minimum: Windows XP
Console.WriteLine(ce.Message + " (" + Environment.OSVersion.ToString() + ")");
}
}
public void MonoExchange128()
{
byte[] M = { 0xd4, 0x36, 0xe9, 0x95, 0x69, 0xfd, 0x32, 0xa7, 0xc8, 0xa0, 0x5b, 0xbc, 0x90, 0xd3, 0x2c, 0x49 };
byte[] EM = { 0x3A, 0x18, 0xE7, 0xF7, 0x45, 0x32, 0x5B, 0x60, 0x46, 0x2A, 0x20, 0x1A, 0x69, 0x98, 0x84, 0x68, 0x76, 0xC0, 0x01, 0x7D, 0x37, 0xE7, 0xEB, 0x72, 0x18, 0xD7, 0xF3, 0xE5, 0x1B, 0x2C, 0xB2, 0x47, 0x86, 0x9D, 0x90, 0xE8, 0x38, 0x43, 0x0C, 0x58, 0x59, 0xDB, 0x2A, 0x46, 0xBA, 0x15, 0xD9, 0x79, 0x77, 0xB5, 0x8B, 0xA7, 0x06, 0x15, 0xE1, 0xBF, 0xA2, 0xA7, 0x69, 0xC6, 0x6A, 0x6C, 0x4F, 0x87, 0xA3, 0xA1, 0xBC, 0x21, 0x46, 0x68, 0x61, 0xEC, 0x1E, 0xE1, 0x2B, 0xEF, 0xD7, 0xE0, 0x61, 0xAF, 0xF5, 0xDA, 0x27, 0xCB, 0xFC, 0x98, 0x0C, 0x12, 0x59, 0x45, 0x64, 0x75, 0x58, 0xB5, 0x5B, 0x7A, 0x9B, 0x76, 0x68, 0x14, 0x9F, 0xAB, 0x64, 0xC7, 0x4E, 0xB7, 0xFF, 0x7D, 0x3D, 0xA3, 0x11, 0x9E, 0xE8, 0x06, 0xAF, 0x5D, 0xA3, 0xEB, 0x8E, 0x1E, 0x38, 0x5D, 0x0D, 0xC3, 0x8C, 0xC3, 0xF0, 0x57 };
AsymmetricKeyExchangeDeformatter keyback = new RSAOAEPKeyExchangeDeformatter(key);
try {
byte[] Mback = keyback.DecryptKeyExchange(EM);
AssertEquals("RSAOAEPKeyExchangeFormatter 128", M, Mback);
}
catch (CryptographicException ce) {
// not supported by every version of Windows - Minimum: Windows XP
Console.WriteLine(ce.Message + " (" + Environment.OSVersion.ToString() + ")");
}
}
public void CapiExchangeMax()
{
byte[] M = new byte [(key.KeySize >> 3) - 2 * 20 - 2];
byte[] EM = { 0x45, 0x31, 0xA7, 0x4A, 0xE5, 0x8B, 0xC7, 0x0C, 0x5C, 0x8B, 0xE6, 0xAB, 0xC5, 0x99, 0xF3, 0x31, 0xB9, 0x64, 0xFA, 0x19, 0x4A, 0x41, 0xF3, 0x49, 0x05, 0x0B, 0x28, 0xD5, 0x96, 0x43, 0x0E, 0xEB, 0x62, 0x0B, 0x22, 0xFE, 0x5F, 0x92, 0x4F, 0x60, 0xB9, 0xAE, 0x7F, 0xAA, 0xC8, 0x82, 0x66, 0xD7, 0x19, 0xCF, 0xC0, 0x69, 0x1C, 0xAA, 0x7E, 0x95, 0x5D, 0x70, 0x3D, 0x4A, 0x1D, 0x3B, 0x55, 0xBC, 0x7D, 0x36, 0xCF, 0x98, 0x09, 0xF8, 0x20, 0x92, 0x34, 0x79, 0x0B, 0x1A, 0x91, 0xE5, 0xFB, 0x94, 0xAD, 0x2A, 0x15, 0x6E, 0x3D, 0xF4, 0xA5, 0x6F, 0x6B, 0xAE, 0x77, 0x80, 0x3C, 0xF5, 0xCC, 0x84, 0x3A, 0xF9, 0xCE, 0x9F, 0x06, 0xF6, 0xCC, 0xA8, 0x75, 0xE1, 0x55, 0x56, 0xA5, 0x76, 0x50, 0x28, 0xA7, 0x3E, 0x91, 0x11, 0x5C, 0x82, 0x7C, 0x1A, 0x92, 0x02, 0x74, 0xCC, 0xA9, 0x6C, 0xFC, 0xA4 };
AsymmetricKeyExchangeDeformatter keyback = new RSAOAEPKeyExchangeDeformatter(key);
try {
byte[] Mback = keyback.DecryptKeyExchange(EM);
AssertEquals("RSAOAEPKeyExchangeFormatter 1", M, Mback);
}
catch (CryptographicException ce) {
// not supported by every version of Windows - Minimum: Windows XP
Console.WriteLine(ce.Message + " (" + Environment.OSVersion.ToString() + ")");
}
}
public void CapiExchange192()
{
byte[] M = { 0xd4, 0x36, 0xe9, 0x95, 0x69, 0xfd, 0x32, 0xa7, 0xc8, 0xa0, 0x5b, 0xbc, 0x90, 0xd3, 0x2c, 0x49, 0x00, 0x00, 0x00, 0x00 };
byte[] EM = { 0x72, 0x0A, 0x0E, 0xA0, 0x8C, 0x40, 0x69, 0x9D, 0x78, 0xBC, 0x94, 0x4B, 0x2C, 0x14, 0xC0, 0xC8, 0x13, 0x8B, 0x6D, 0x2F, 0x01, 0xE3, 0x45, 0x33, 0xE7, 0x9B, 0x87, 0xDB, 0x37, 0xBD, 0xA9, 0x63, 0xCC, 0x94, 0x8F, 0xBB, 0x1D, 0x61, 0xA1, 0x5E, 0x6A, 0x33, 0xBD, 0xD5, 0xC8, 0x22, 0x40, 0xB1, 0x32, 0xFB, 0x6F, 0x2A, 0x3B, 0x8A, 0x15, 0x4E, 0xC1, 0x25, 0xF0, 0x34, 0x17, 0x9A, 0x68, 0x34, 0x27, 0x5B, 0x49, 0xC5, 0xEA, 0x4D, 0x7F, 0x07, 0x4C, 0xAC, 0xF8, 0xE3, 0xD7, 0x9E, 0x72, 0xB0, 0xD1, 0xAD, 0x9E, 0x9C, 0xBB, 0xC6, 0x79, 0x14, 0x63, 0x5E, 0x13, 0xD1, 0x02, 0xDE, 0x57, 0xB5, 0xBC, 0x57, 0x68, 0xAC, 0xE3, 0xEF, 0x79, 0xED, 0xAF, 0xC0, 0xBB, 0xFE, 0xB3, 0xA6, 0x4C, 0xE8, 0x79, 0xE2, 0x3A, 0xB3, 0x37, 0x97, 0x90, 0x05, 0xCF, 0xB9, 0x1A, 0x92, 0xEC, 0x73, 0xC5, 0x8D };
AsymmetricKeyExchangeDeformatter keyback = new RSAOAEPKeyExchangeDeformatter(key);
try {
byte[] Mback = keyback.DecryptKeyExchange(EM);
AssertEquals("RSAOAEPKeyExchangeFormatter 1", M, Mback);
}
catch (CryptographicException ce) {
// not supported by every version of Windows - Minimum: Windows XP
Console.WriteLine(ce.Message + " (" + Environment.OSVersion.ToString() + ")");
}
}
public static byte[] DecryptKey(byte[] keyData, RSA rsa, bool useOAEP)
{
if (keyData == null)
{
throw new ArgumentNullException("keyData");
}
if (rsa == null)
{
throw new ArgumentNullException("rsa");
}
if (useOAEP)
{
RSAOAEPKeyExchangeDeformatter deformatter = new RSAOAEPKeyExchangeDeformatter(rsa);
return(deformatter.DecryptKeyExchange(keyData));
}
RSAPKCS1KeyExchangeDeformatter deformatter2 = new RSAPKCS1KeyExchangeDeformatter(rsa);
return(deformatter2.DecryptKeyExchange(keyData));
}
//<Snippet3>
public void Receive(byte[] iv, byte[] encryptedSessionKey, byte[] encryptedMessage)
{
using (Aes aes = new AesCryptoServiceProvider())
{
aes.IV = iv;
// Decrypt the session key
RSAOAEPKeyExchangeDeformatter keyDeformatter = new RSAOAEPKeyExchangeDeformatter(rsaKey);
aes.Key = keyDeformatter.DecryptKeyExchange(encryptedSessionKey);
// Decrypt the message
using (MemoryStream plaintext = new MemoryStream())
using (CryptoStream cs = new CryptoStream(plaintext, aes.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(encryptedMessage, 0, encryptedMessage.Length);
cs.Close();
string message = Encoding.UTF8.GetString(plaintext.ToArray());
Console.WriteLine(message);
}
}
}
// decrypts the supplied data using an RSA key and specifies whether we want to use OAEP
// padding or PKCS#1 v1.5 padding as described in the PKCS specification
public static byte[] DecryptKey(byte[] keyData, RSA rsa, bool useOAEP)
{
if (keyData is null)
{
throw new ArgumentNullException(nameof(keyData));
}
if (rsa is null)
{
throw new ArgumentNullException(nameof(rsa));
}
if (useOAEP)
{
RSAOAEPKeyExchangeDeformatter rsaDeformatter = new RSAOAEPKeyExchangeDeformatter(rsa);
return(rsaDeformatter.DecryptKeyExchange(keyData));
}
else
{
RSAPKCS1KeyExchangeDeformatter rsaDeformatter = new RSAPKCS1KeyExchangeDeformatter(rsa);
return(rsaDeformatter.DecryptKeyExchange(keyData));
}
}
/// <summary>
/// Decrypts the symmetric key.
/// </summary>
/// <param name="cert">The cert.</param>
/// <param name="encryptedData">The encrypted data.</param>
/// <returns>The decrypted key.</returns>
public static byte[] DecryptSymmetricKey(X509Certificate2 cert, byte[] encryptedData)
{
AsymmetricAlgorithm rsaPrivateKey = null;
RSAOAEPKeyExchangeDeformatter keyFormatter = null;
if (cert == null)
{
throw new ArgumentNullException("cert");
}
if (!cert.HasPrivateKey)
{
throw new ArgumentException("Certificate does not have a private key which is a requirment for decryption.", "cert");
}
try
{
rsaPrivateKey = cert.PrivateKey;
}
catch (CryptographicException ce)
{
if (ce.Message.Contains("Keyset does not exist"))
{
IdentityReference currentUser = WindowsIdentity.GetCurrent().Owner as IdentityReference;
string message = string.Format(CultureInfo.CurrentCulture, "Unable to create the RSAOAEPKeyExchangeDeformatter likely due to the access permissions on the private key. Check to see if the current user has access to the private key for the certificate with thumbprint={0}. Current User is {1}.", cert.Thumbprint, currentUser.ToString());
throw new InvalidOperationException(message, ce);
}
else
{
throw;
}
}
keyFormatter = new RSAOAEPKeyExchangeDeformatter(rsaPrivateKey);
return(keyFormatter.DecryptKeyExchange(encryptedData));
}
public static byte[] DecryptBytes(TanksCommon.Encryption.EncryptioinKeys key, byte[] toDecrypt)
{
byte[] result = null;
using (Aes aes = new AesCryptoServiceProvider())
{
aes.IV = key.Iv;
RSAOAEPKeyExchangeDeformatter keyDeformatter = new RSAOAEPKeyExchangeDeformatter(key.RsaKey);
aes.Key = keyDeformatter.DecryptKeyExchange(key.SessionKey);
// Decrypt the message
using (System.IO.MemoryStream plaintext = new System.IO.MemoryStream())
{
using (CryptoStream cs = new CryptoStream(plaintext, aes.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(toDecrypt, 0, toDecrypt.Length);
cs.Close();
}
plaintext.Close();
result = plaintext.ToArray();
}
}
return(result);
}
public void ExchangeNoKey()
{
AsymmetricKeyExchangeDeformatter keyex = new RSAOAEPKeyExchangeDeformatter();
byte[] M = keyex.DecryptKeyExchange(new byte [(key.KeySize >> 3) - 2 * 20 - 2]);
}
//////////////////////////////////////
//////////////////////////////////////
//////////////////////////////////////
public bool SRVLogin()
{
try
{
TPServer = new TcpClient(localhost, port);
}
catch (SocketException e)
{
MessageBox.Show(e.Message);
return(false);
}
//Фишка алгоритма RSA в том, что открытым ключом можно только зашифровать, расшифровывают
// закрытым ключом. Потому с помощью него мы передадим закрытый сессионый ключ,
//а дальше будем использовать Rijndael-шифрование, потому что им удобнее работать с потоками
//Обычный фокус при шифровании: сначала даём серверу наш открытый ключ
//сервер им шифрует свой сеансовый открытый и закрытый ключ
//мы получаем от севера его ключи и расшифровываем(у нас-то закрытый ключ есть)
//затем передаём данные использую ключи сервера
//Получаем, что мы ни разу не передали через сеть закрытый ключ в незашифрованном виде
// и оба оказались с подходящим закрытым и открытым ключом
CryRijnd = new RijndaelManaged(); //объект класса шифрования
using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
{
byte[] RSAKeyPublic = RSA.ExportCspBlob(false); //берём открытый ключ для RSА-шифратора
byte[] mess = new byte[4 + RSAKeyPublic.Length];
ToAByte(RSAKeyPublic.Length).CopyTo(mess, 0);
RSAKeyPublic.CopyTo(mess, 4);
TPServer.GetStream().Write(mess, 0, mess.Length); //отправили публичный ключ
byte[] encSessionKey = ReadMessageNoCry(); //получили сессионый ключ
//этот класс специально предназначен для зашифрованного обмена ключами,
//потому им и воспользуемся
RSAOAEPKeyExchangeDeformatter keyDeformatter = new RSAOAEPKeyExchangeDeformatter(RSA);
byte[] CryKey = keyDeformatter.DecryptKeyExchange(encSessionKey);
byte[] CryIV = ReadMessageNoCry();
CryRijnd.Key = CryKey; //устанавливаем в шифровщик сессионный ключ
CryRijnd.IV = CryIV;
//шифратор и дешифратор. Нужны для создания потоков шифрования
Encryptor = CryRijnd.CreateEncryptor();
Decryptor = CryRijnd.CreateDecryptor();
//создаём потоки чтения и записи для шифрования на основе сетевого потока
CryWr = new CryptoStream(TPServer.GetStream(), Encryptor, CryptoStreamMode.Write);
CryRd = new CryptoStream(TPServer.GetStream(), Decryptor, CryptoStreamMode.Read);
}
//Запускаем поток ожидания сообщений
Thread thread = new Thread(new ParameterizedThreadStart(ThreadNetMess));
thread.Start();
SendResponse("LOGIN ", Login);
while (lastRec == null)
{
Thread.Sleep(100);
}
int tmpSize = 10 * 2; //берём в строку только первые 10 символов
if (tmpSize > lastRec.Length)
{
tmpSize = lastRec.Length; //или сколько там этих символов есть в сообщении
}
string tmpStr = Encoding.Unicode.GetString(lastRec, 0, tmpSize);
string command = tmpStr.Split(' ')[0];
lastRec = null;
if (command == "LOG_OK")
{
return(true);
}
if (TPServer != null)
{
if (TPServer.Connected)
{
TPServer.Close();
}
}
TPServer = null;
return(false);
}
static void Main(string[] args)
{
if (args.Length < 3)
{
Console.WriteLine("Usage: -e/-d Filename KeyContainer");
return;
}
if (args[0] == "-e")
{
CspParameters myCspParms = new CspParameters {
KeyContainerName = args[2]
};
RSACryptoServiceProvider myRSAProv = new RSACryptoServiceProvider(myCspParms);
RSAOAEPKeyExchangeFormatter myKeyFormatter = new RSAOAEPKeyExchangeFormatter(myRSAProv);
Aes mySymmProv = Aes.Create();
byte[] encrKey = myKeyFormatter.CreateKeyExchange(mySymmProv.Key);
byte[] data = File.ReadAllBytes(args[1]);
using (FileStream fsout = new FileStream(args[1] + ".encrypted", FileMode.Create))
{
using (BinaryWriter bw = new BinaryWriter(fsout))
{
bw.Write(encrKey.Length);
bw.Write(encrKey, 0, encrKey.Length);
bw.Write(mySymmProv.IV.Length);
bw.Write(mySymmProv.IV, 0, mySymmProv.IV.Length);
bw.Flush();
using (CryptoStream cs = new CryptoStream(fsout, mySymmProv.CreateEncryptor(), CryptoStreamMode.Write))
{
using (BinaryWriter sw = new BinaryWriter(cs))
{
sw.Write(data);
sw.Flush();
}
}
}
}
}
else if (args[0] == "-d")
{
CspParameters myCspParms = new CspParameters {
KeyContainerName = args[2]
};
RSACryptoServiceProvider myRSAProv = new RSACryptoServiceProvider(myCspParms);
RSAOAEPKeyExchangeDeformatter myKeyDeformatter = new RSAOAEPKeyExchangeDeformatter(myRSAProv);
Aes mySymmProv = Aes.Create();
using (FileStream fs = new FileStream(args[1], FileMode.Open))
{
using (BinaryReader br = new BinaryReader(fs))
{
int keyLength = br.ReadInt32();
byte[] encrKey = new byte[keyLength];
br.Read(encrKey, 0, keyLength);
int ivLength = br.ReadInt32();
byte[] IV = new byte[ivLength];
br.Read(IV, 0, ivLength);
byte[] Key = myKeyDeformatter.DecryptKeyExchange(encrKey);
mySymmProv.Key = Key;
mySymmProv.IV = IV;
using (CryptoStream cs = new CryptoStream(fs, mySymmProv.CreateDecryptor(), CryptoStreamMode.Read))
{
int dataLen = (int)fs.Length - 4 - keyLength - 4 - ivLength;
byte[] data = new byte[dataLen];
int len = cs.Read(data, 0, dataLen);
using (FileStream outStream = File.Open(args[1].Replace("encrypted", "decrypted"), FileMode.OpenOrCreate))
{
outStream.Write(data, 0, len);
outStream.Flush();
}
}
}
}
}
else
{
Console.WriteLine("Usage: -e/-d Filename KeyContainer");
return;
}
}
/// <summary>
/// Decrypt salted data using keys linked to the user account.
/// </summary>
/// <param name="encryptedData">The data to decrypt.</param>
/// <param name="optionalEntropy">The salt to apply to the data after decryption.</param>
/// <returns>The decrypted data.</returns>
public static byte[] Unprotect(byte[] encryptedData, byte[] optionalEntropy)
{
if (encryptedData == null)
{
throw new ArgumentNullException("encryptedData");
}
byte[] decdata = null;
Rijndael aes = Rijndael.Create();
RSA rsa = GetKey();
int headerSize = rsa.KeySize >> 3;
bool valid1 = encryptedData.Length >= headerSize;
if (!valid1)
{
headerSize = encryptedData.Length;
}
byte[] header = new byte[headerSize];
Buffer.BlockCopy(encryptedData, 0, header, 0, headerSize);
byte[] secret = null;
byte[] key = null;
byte[] iv = null;
bool valid2 = false;
bool valid3 = false;
bool valid4 = false;
SHA256 hash = SHA256.Create();
try
{
try
{
RSAOAEPKeyExchangeDeformatter deformatter = new RSAOAEPKeyExchangeDeformatter(rsa);
secret = deformatter.DecryptKeyExchange(header);
valid2 = secret.Length == 68;
}
catch
{
valid2 = false;
}
if (!valid2)
{
secret = new byte[68];
}
valid3 = (secret[1] == 16) && (secret[18] == 16) && (secret[35] == 32);
key = new byte[16];
Buffer.BlockCopy(secret, 2, key, 0, 16);
iv = new byte[16];
Buffer.BlockCopy(secret, 19, iv, 0, 16);
if ((optionalEntropy != null) && (optionalEntropy.Length > 0))
{
byte[] mask = hash.ComputeHash(optionalEntropy);
for (int i = 0; i < 16; i++)
{
key[i] ^= mask[i];
iv[i] ^= mask[i + 16];
}
valid3 &= secret[0] == 2;
}
else
{
valid3 &= secret[0] == 1;
}
using (MemoryStream ms = new MemoryStream())
{
ICryptoTransform t = aes.CreateDecryptor(key, iv);
using (CryptoStream cs = new CryptoStream(ms, t, CryptoStreamMode.Write))
{
try
{
cs.Write(encryptedData, headerSize, encryptedData.Length - headerSize);
cs.Close();
}
catch { }
}
decdata = ms.ToArray();
}
byte[] digest = hash.ComputeHash(decdata);
valid4 = true;
for (int i = 0; i < 32; i++)
{
if (digest[i] != secret[36 + i])
{
valid4 = false;
}
}
}
finally
{
if (key != null)
{
Array.Clear(key, 0, key.Length);
key = null;
}
if (secret != null)
{
Array.Clear(secret, 0, secret.Length);
secret = null;
}
if (iv != null)
{
Array.Clear(iv, 0, iv.Length);
iv = null;
}
aes.Clear();
hash.Clear();
}
if (!valid1 || !valid2 || !valid3 || !valid4)
{
if (decdata != null)
{
Array.Clear(decdata, 0, decdata.Length);
decdata = null;
}
throw new CryptographicException("Invalid data.");
}
return(decdata);
}
// FIXME [KeyContainerPermission (SecurityAction.Assert, KeyContainerName = "DAPI",
// Flags = KeyContainerPermissionFlags.Open | KeyContainerPermissionFlags.Decrypt)]
public static byte[] Unprotect(byte[] encryptedData, byte[] optionalEntropy, DataProtectionScope scope)
{
if (encryptedData == null)
{
throw new ArgumentNullException("encryptedData");
}
byte[] decdata = null;
Rijndael aes = Rijndael.Create();
RSA rsa = GetKey(scope);
int headerSize = (rsa.KeySize >> 3);
bool valid1 = (encryptedData.Length >= headerSize);
if (!valid1)
{
headerSize = encryptedData.Length;
}
byte[] header = new byte[headerSize];
Buffer.BlockCopy(encryptedData, 0, header, 0, headerSize);
byte[] secret = null;
byte[] key = null;
byte[] iv = null;
bool valid2 = false;
bool valid3 = false;
bool valid4 = false;
SHA256 hash = SHA256.Create();
try
{
try
{
RSAOAEPKeyExchangeDeformatter deformatter = new RSAOAEPKeyExchangeDeformatter(rsa);
secret = deformatter.DecryptKeyExchange(header);
valid2 = (secret.Length == 68);
}
catch
{
valid2 = false;
}
if (!valid2)
{
secret = new byte[68];
}
// known values for structure (version 1 or 2)
valid3 = ((secret[1] == 16) && (secret[18] == 16) && (secret[35] == 32));
key = new byte[16];
Buffer.BlockCopy(secret, 2, key, 0, 16);
iv = new byte[16];
Buffer.BlockCopy(secret, 19, iv, 0, 16);
if ((optionalEntropy != null) && (optionalEntropy.Length > 0))
{
// the decrypted data won't be valid if the entropy isn't
// the same as the one used to protect (encrypt) it
byte[] mask = hash.ComputeHash(optionalEntropy);
for (int i = 0; i < 16; i++)
{
key[i] ^= mask[i];
iv[i] ^= mask[i + 16];
}
valid3 &= (secret[0] == 2); // with entropy
}
else
{
valid3 &= (secret[0] == 1); // without entropy
}
using (MemoryStream ms = new MemoryStream())
{
ICryptoTransform t = aes.CreateDecryptor(key, iv);
using (CryptoStream cs = new CryptoStream(ms, t, CryptoStreamMode.Write))
{
try
{
cs.Write(encryptedData, headerSize, encryptedData.Length - headerSize);
cs.Close();
}
catch
{
// whatever, we keep going
}
}
decdata = ms.ToArray();
}
byte[] digest = hash.ComputeHash(decdata);
valid4 = true;
for (int i = 0; i < 32; i++)
{
if (digest[i] != secret[36 + i])
{
valid4 = false;
}
}
}
finally
{
if (key != null)
{
Array.Clear(key, 0, key.Length);
key = null;
}
if (secret != null)
{
Array.Clear(secret, 0, secret.Length);
secret = null;
}
if (iv != null)
{
Array.Clear(iv, 0, iv.Length);
iv = null;
}
aes.Clear();
hash.Clear();
}
// single point of error (also limits timing informations)
if (!valid1 || !valid2 || !valid3 || !valid4)
{
if (decdata != null)
{
Array.Clear(decdata, 0, decdata.Length);
decdata = null;
}
throw new CryptographicException("Invalid data.");
}
return(decdata);
}
/// <inheritdoc />
protected internal override byte[] Decrypt(byte[] data, byte[] iv)
{
var keyExchange = new RSAOAEPKeyExchangeDeformatter(this.Rsa);
return(keyExchange.DecryptKeyExchange(data));
}
