public static void NegativeVerify_BadKeysize()
{
byte[] signature;
using (RSA rsa = RSAFactory.Create())
{
rsa.ImportParameters(TestData.RSA2048Params);
signature = rsa.SignData(TestData.HelloBytes, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
}
using (RSA rsa = RSAFactory.Create())
{
rsa.ImportParameters(TestData.RSA1024Params);
bool signatureMatched = rsa.VerifyData(TestData.HelloBytes, signature, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
Assert.False(signatureMatched);
}
}
public static void ExportAfterDispose(bool importKey)
{
RSA rsa = importKey ? RSAFactory.Create(TestData.RSA2048Params) : RSAFactory.Create(1024);
// Ensure that the key got created, and then Dispose it.
using (rsa)
{
rsa.Encrypt(TestData.HelloBytes, RSAEncryptionPadding.Pkcs1);
}
Assert.Throws <ObjectDisposedException>(() => rsa.ExportParameters(false));
Assert.Throws <ObjectDisposedException>(() => rsa.ExportParameters(true));
if (!(PlatformDetection.IsFullFramework && rsa.GetType().Name.EndsWith("Cng")))
{
Assert.Throws <ObjectDisposedException>(() => rsa.ImportParameters(TestData.RSA1024Params));
}
}
public static void InvalidHashAlgorithm()
{
using (RSA rsa = RSAFactory.Create())
{
var formatter = new RSAPKCS1SignatureFormatter(rsa);
var deformatter = new RSAPKCS1SignatureDeformatter(rsa);
// Exception is deferred until VerifySignature
formatter.SetHashAlgorithm("INVALIDVALUE");
deformatter.SetHashAlgorithm("INVALIDVALUE");
using (SHA1 alg = SHA1.Create())
{
Assert.Throws <CryptographicUnexpectedOperationException>(() =>
VerifySignature(formatter, deformatter, alg, "INVALIDVALUE"));
}
}
}
public static void ImportFromPem_Pkcs8AlgorithmMismatch_Throws()
{
using (RSA rsa = RSAFactory.Create())
{
string pem = @"
The below PEM is a 1024-bit DSA key.
-----BEGIN PRIVATE KEY-----
MIIBSgIBADCCASsGByqGSM44BAEwggEeAoGBAL5KGXEaazCA+k1pMcCBc/+bodFh
0P4U2QDLyDtnmytusGPaHcFp69pVdJZWMBycwJdaFQkraQNmqQsjAmBHtpqMeJpE
VLgjzve83oMAw5aysmaQC4Wy35vnBZnshvdzgbPRHZD2dWmFvWxToqBnxh74rb/H
Nkpt8JrirFOdNuyvAhUA9+LZ6XHLZZKeFhDxYl+a9lYabdsCgYACRi+pc9joLRah
A9ushrXVItFyOsq45hOB9hT37nyTEmane/YAjmoR28XyDYdF/Ql97iSVm3cY3OYT
eDr38gQ/Hk0CgW3/RFrNWdbIpfMifs80vqCUNqDggcQixEmDVZ0gwq4+wz8EVyYG
42+vM7ajN4O2VGvCA99Vl6zv69hOpAQWAhQtFFLZyKAUOQwUQh4hNw+oBgPhFw==
-----END PRIVATE KEY-----";
Assert.Throws <CryptographicException>(() => rsa.ImportFromPem(pem));
}
}
public static void ImportNoModulus()
{
RSAParameters imported = new RSAParameters
{
Exponent = TestData.RSA1024Params.Exponent,
};
using (RSA rsa = RSAFactory.Create())
{
if (rsa is RSACng && PlatformDetection.IsFullFramework)
{
AssertExtensions.Throws <ArgumentException>(null, () => rsa.ImportParameters(imported));
}
else
{
Assert.ThrowsAny <CryptographicException>(() => rsa.ImportParameters(imported));
}
}
}
public static void ImportExport1032()
{
RSAParameters imported = TestData.RSA1032Parameters;
RSAParameters exported;
RSAParameters exportedPublic;
using (RSA rsa = RSAFactory.Create())
{
rsa.ImportParameters(imported);
exported = rsa.ExportParameters(true);
exportedPublic = rsa.ExportParameters(false);
}
AssertKeyEquals(imported, exported);
Assert.Equal(exportedPublic.Modulus, imported.Modulus);
Assert.Equal(exportedPublic.Exponent, imported.Exponent);
Assert.Null(exportedPublic.D);
}
public static void ImportFromEncryptedPem_NoEncryptedPem()
{
using (RSA rsa = RSAFactory.Create())
{
string pem = @"
-----BEGIN PRIVATE KEY-----
MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAtz9Z9e6L1V4kt/8C
mtFqhUPJbSU+VDGbk1MsQcPBR3uJ2y0vM9e5qHRYSOBqjmg7UERRHhvKNiUn4Xz0
KzgGFQIDAQABAkEAr+byNi+cr17FpJH4MCEiPXaKnmkH4c4U52EJtL9yg2gijBrp
Ykat3c2nWb0EGGi5aWgXxQHoi7z97/ACD4X3KQIhAPNyex6GdiBVlNPHOgInTU8a
mARKKVHIXM0SxvxXrRl7AiEAwLI66OpSqftDTv1KUfNe6+hyoh23ggzUSYiWuVT0
Ya8CHwiO/cUU9RIt8A2B84gf2ZfuV2nPMaSuZpTPFC/K5UsCIQCsJMzx1JuilQAN
acPiMCuFTnRSFYAhozpmsqoLyTREqwIhAMLJlZTGjEB2N+sEazH5ToEczQzKqp7t
9juGNbOPhoEL
-----END PRIVATE KEY-----";
ArgumentException ae = AssertExtensions.Throws <ArgumentException>("input", () =>
rsa.ImportFromEncryptedPem(pem, "test" u8));
Assert.Contains(NoPemExceptionMarker, ae.Message);
}
}
private void ExpectHashSignature(
byte[] expectedSignature,
byte[] dataHash,
string hashAlgorithmName,
RSAParameters rsaParameters)
{
// RSA signatures use PKCS 1.5 EMSA encoding (encoding method, signature algorithm).
// EMSA specifies a fixed filler type of { 0x01, 0xFF, 0xFF ... 0xFF, 0x00 } whose length
// is as long as it needs to be to match the block size. Since the filler is deterministic,
// the signature is deterministic, so we can safely verify it here.
byte[] signature;
using (RSA rsa = RSAFactory.Create())
{
rsa.ImportParameters(rsaParameters);
signature = SignHash(rsa, dataHash, new HashAlgorithmName(hashAlgorithmName), RSASignaturePadding.Pkcs1);
}
Assert.Equal(expectedSignature, signature);
}
public void RsaDecryptPkcs1LeadingZero()
{
// The first search for an encrypted value with a leading 0x00 turned up one with
// two leading zeros. How fortuitous.
byte[] encrypted = (
"0000B81E93CB9BA2B096DAC80ADC0C053D15CAD79A09D3DC154E3E75E0F59AF0" +
"D0816C0946946A56FEAEDB951A49C3854966C01C47A9F54DE2A050C1625869FE" +
"02BAD7AA427C42FE79D31267AE8713504CBBBBFA28EED0DF3E9F5BFC12C8A701" +
"382E92BC50D7E9E9897AEBDDA8005B7906AE1ABAFFD30CF5A8733CAB7264445A" +
"333730EA31F5F9F120B4B59F689BA529E106DA78340678C3BA2CE46427375A84" +
"9E86950FC18BD1D6C33508596BAEF0D916F0E29D647C037022753B1E8E44ABCF" +
"0079CEFA8972F02D05C4204078BD9ADF98571CE5374AB94BF01918F0EA31A815" +
"59F065A4C3FA0DD0E3086530608CA54387F86F25ED77D46C7576376B64BE3C91").HexToByteArray();
using (RSA rsa = RSAFactory.Create(TestData.RSA2048Params))
{
byte[] decrypted = Decrypt(rsa, encrypted, RSAEncryptionPadding.Pkcs1);
Assert.Equal(TestData.HelloBytes, decrypted);
}
}
public void RsaDecryptOaep_ExpectFailure()
{
// This particular byte pattern, when decrypting under OAEP-SHA-2-384 has
// an 0x01 in the correct range, and y=0, but lHash and lHashPrime do not agree
byte[] encrypted = (
"2A1914D11E2F6B9E286DAC9D76F32A008EC31457522CEA058D7C48C85085899F" +
"E9C2DBD4FCA5FAD936F2B747E0BEF131217F8521FA921DF807A83C1B34DB1547" +
"8D637EDFED222B6411C80D465332B2EE5208F87D4F8D1736FEBC291E14E77C4B" +
"75A1F06B5124F225F310BFFA83BCA9F11101BA67A64109C37F52BF00B84FFD9A" +
"D39282AD2BA9EEADADA0FE38998755B556B152EE8974F2C8158ACFA5F509DD4A" +
"BFE72218C0DF596DFF02C332F45ECC04280455F5D2666E93A3522BB8B41FC92E" +
"0176AFB1D3A5AE474B708B882ACA88447046E13D44E5EA8D66421DFC177A683B" +
"7B395F18886AAFD9CED072079739ED1D390354976D188C50A29AAD58784886E6").HexToByteArray();
using (RSA rsa = RSAFactory.Create(TestData.RSA2048Params))
{
Assert.ThrowsAny <CryptographicException>(
() => Decrypt(rsa, encrypted, RSAEncryptionPadding.OaepSHA384));
}
}
public static void ImportFromPem_SubjectPublicKeyInfo_IgnoresUnrelatedAlgorithm()
{
using (RSA rsa = RSAFactory.Create())
{
string pem = @"
-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIHChLC2xaEXtVv9oz8IaRys/BNfWhRv2NJ8tfVs0UrOKoAoGCCqGSM49
AwEHoUQDQgAEgQHs5HRkpurXDPaabivT2IaRoyYtIsuk92Ner/JmgKjYoSumHVmS
NfZ9nLTVjxeD08pD548KWrqmJAeZNsDDqQ==
-----END EC PRIVATE KEY-----
-----BEGIN PUBLIC KEY-----
MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALc/WfXui9VeJLf/AprRaoVDyW0lPlQx
m5NTLEHDwUd7idstLzPXuah0WEjgao5oO1BEUR4byjYlJ+F89Cs4BhUCAwEAAQ==
-----END PUBLIC KEY-----";
rsa.ImportFromPem(pem);
RSAParameters rsaParameters = rsa.ExportParameters(false);
ImportExport.AssertKeyEquals(TestData.DiminishedDPParameters.ToPublic(), rsaParameters);
}
}
public static void ImportFromPem_RSAPrivateKey_Simple()
{
using (RSA rsa = RSAFactory.Create())
{
string pem = @"
-----BEGIN RSA PRIVATE KEY-----
MIIBOwIBAAJBALc/WfXui9VeJLf/AprRaoVDyW0lPlQxm5NTLEHDwUd7idstLzPX
uah0WEjgao5oO1BEUR4byjYlJ+F89Cs4BhUCAwEAAQJBAK/m8jYvnK9exaSR+DAh
Ij12ip5pB+HOFOdhCbS/coNoIowa6WJGrd3Np1m9BBhouWloF8UB6Iu8/e/wAg+F
9ykCIQDzcnsehnYgVZTTxzoCJ01PGpgESilRyFzNEsb8V60ZewIhAMCyOujqUqn7
Q079SlHzXuvocqIdt4IM1EmIlrlU9GGvAh8Ijv3FFPUSLfANgfOIH9mX7ldpzzGk
rmaUzxQvyuVLAiEArCTM8dSbopUADWnD4jArhU50UhWAIaM6ZrKqC8k0RKsCIQDC
yZWUxoxAdjfrBGsx+U6BHM0Myqqe7fY7hjWzj4aBCw==
-----END RSA PRIVATE KEY-----";
rsa.ImportFromPem(pem);
RSAParameters rsaParameters = rsa.ExportParameters(true);
ImportExport.AssertKeyEquals(TestData.DiminishedDPParameters, rsaParameters);
}
}
public void RsaDecryptOaepWrongData()
{
using (RSA rsa = RSAFactory.Create(TestData.RSA2048Params))
{
byte[] data = TestData.HelloBytes;
byte[] encrypted = Encrypt(rsa, data, RSAEncryptionPadding.OaepSHA1);
encrypted[1] ^= 0xFF;
Assert.ThrowsAny <CryptographicException>(
() => Decrypt(rsa, encrypted, RSAEncryptionPadding.OaepSHA1));
if (RSAFactory.SupportsSha2Oaep)
{
encrypted = Encrypt(rsa, data, RSAEncryptionPadding.OaepSHA256);
encrypted[1] ^= 0xFF;
Assert.ThrowsAny <CryptographicException>(
() => Decrypt(rsa, encrypted, RSAEncryptionPadding.OaepSHA256));
}
}
}
public static void ImportFromPem_EncryptedPrivateKeyFails()
{
using (RSA rsa = RSAFactory.Create())
{
string pem = @"
-----BEGIN ENCRYPTED PRIVATE KEY-----
MIIBsTBLBgkqhkiG9w0BBQ0wPjApBgkqhkiG9w0BBQwwHAQIioaQaFwlfasCAggA
MAwGCCqGSIb3DQIJBQAwEQYFKw4DAgcECJLGzSuIgnSkBIIBYHofFpp5AsrkNc9w
s0uebkLBgMXbmhu+t6XQYXhnZXguT4KF4g49vIE3XwtZkXzEeSrNRIWZcPH1UWp2
qbv2d+ub3wBpMdFDzv5Zty6e6gACWwyMRy/oX8gZqWDfDnQwm7BV21yLANEFnRuT
K3c9EmQ9IAT2MLLRUeijyg6KUL0dZ5VmXbtQdDoovuhzU20HjSyQLXNbX8NzUhWy
VMuNHs8NhiIgOuFKMoqlN42LBA1+iOA4MGR5XDXXmGyKPLCs0USbD9Dm4/Q1h7Fs
x2yC94Mej7kgAusuNZk9GafsIQbM7jZT1PLxIKyMXAxIpS9sIYbegxK774npiy8/
LiBC1SQXJ3sJdAeUE0QPJEci937f8SteWUmF5mUqznb/0nYjvSZh/GcZ4GWEAO8j
RkMxT/C7OZVMOlb3HV3fJj7kDmOMqfc6aKEQjLdWtuYRB8CgaudldIpK4jP2+0b5
pBORBb0=
-----END ENCRYPTED PRIVATE KEY-----";
ArgumentException ae = AssertExtensions.Throws <ArgumentException>("input", () => rsa.ImportFromPem(pem));
Assert.Contains(EncryptedExceptionMarker, ae.Message);
}
}
public static void ImportFromPem_RSAPrivateKey_AmbiguousKey_EncryptedPkcs8()
{
using (RSA rsa = RSAFactory.Create())
{
string pem = @"
-----BEGIN ENCRYPTED PRIVATE KEY-----
MII=
-----END ENCRYPTED PRIVATE KEY-----
-----BEGIN RSA PRIVATE KEY-----
MIIBOwIBAAJBALc/WfXui9VeJLf/AprRaoVDyW0lPlQxm5NTLEHDwUd7idstLzPX
uah0WEjgao5oO1BEUR4byjYlJ+F89Cs4BhUCAwEAAQJBAK/m8jYvnK9exaSR+DAh
Ij12ip5pB+HOFOdhCbS/coNoIowa6WJGrd3Np1m9BBhouWloF8UB6Iu8/e/wAg+F
9ykCIQDzcnsehnYgVZTTxzoCJ01PGpgESilRyFzNEsb8V60ZewIhAMCyOujqUqn7
Q079SlHzXuvocqIdt4IM1EmIlrlU9GGvAh8Ijv3FFPUSLfANgfOIH9mX7ldpzzGk
rmaUzxQvyuVLAiEArCTM8dSbopUADWnD4jArhU50UhWAIaM6ZrKqC8k0RKsCIQDC
yZWUxoxAdjfrBGsx+U6BHM0Myqqe7fY7hjWzj4aBCw==
-----END RSA PRIVATE KEY-----";
ArgumentException ae = AssertExtensions.Throws <ArgumentException>("input", () => rsa.ImportFromPem(pem));
Assert.Contains(AmbiguousExceptionMarker, ae.Message);
}
}
public static void ImportFromPem_Pkcs8UnEncrypted_Simple()
{
using (RSA rsa = RSAFactory.Create())
{
string pem = @"
-----BEGIN PRIVATE KEY-----
MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAtz9Z9e6L1V4kt/8C
mtFqhUPJbSU+VDGbk1MsQcPBR3uJ2y0vM9e5qHRYSOBqjmg7UERRHhvKNiUn4Xz0
KzgGFQIDAQABAkEAr+byNi+cr17FpJH4MCEiPXaKnmkH4c4U52EJtL9yg2gijBrp
Ykat3c2nWb0EGGi5aWgXxQHoi7z97/ACD4X3KQIhAPNyex6GdiBVlNPHOgInTU8a
mARKKVHIXM0SxvxXrRl7AiEAwLI66OpSqftDTv1KUfNe6+hyoh23ggzUSYiWuVT0
Ya8CHwiO/cUU9RIt8A2B84gf2ZfuV2nPMaSuZpTPFC/K5UsCIQCsJMzx1JuilQAN
acPiMCuFTnRSFYAhozpmsqoLyTREqwIhAMLJlZTGjEB2N+sEazH5ToEczQzKqp7t
9juGNbOPhoEL
-----END PRIVATE KEY-----";
rsa.ImportFromPem(pem);
RSAParameters rsaParameters = rsa.ExportParameters(true);
ImportExport.AssertKeyEquals(TestData.DiminishedDPParameters, rsaParameters);
}
}
private void VerifyHashSignature(
byte[] signature,
byte[] dataHash,
string hashAlgorithmName,
RSAParameters rsaParameters)
{
RSAParameters publicOnly = new RSAParameters
{
Modulus = rsaParameters.Modulus,
Exponent = rsaParameters.Exponent,
};
bool signatureMatched;
using (RSA rsa = RSAFactory.Create())
{
rsa.ImportParameters(publicOnly);
signatureMatched = VerifyHash(rsa, dataHash, signature, new HashAlgorithmName(hashAlgorithmName), RSASignaturePadding.Pkcs1);
}
Assert.True(signatureMatched);
}
public static void UnusualExponentImportExport()
{
// Most choices for the Exponent value in an RSA key use a Fermat prime.
// Since a Fermat prime is 2^(2^m) + 1, it always only has two bits set, and
// frequently has the form { 0x01, [some number of 0x00s], 0x01 }, which has the same
// representation in both big- and little-endian.
//
// The only real requirement for an Exponent value is that it be coprime to (p-1)(q-1).
// So here we'll use the (non-Fermat) prime value 433 (0x01B1) to ensure big-endian export.
RSAParameters unusualExponentParameters = TestData.UnusualExponentParameters;
RSAParameters exported;
using (RSA rsa = RSAFactory.Create())
{
rsa.ImportParameters(unusualExponentParameters);
exported = rsa.ExportParameters(true);
}
// Exponent is the most likely to fail, the rest just otherwise ensure that Export
// isn't losing data.
AssertKeyEquals(unusualExponentParameters, exported);
}
private void RsaCryptRoundtrip(RSAEncryptionPadding paddingMode, bool expectSuccess = true)
{
byte[] crypt;
byte[] output;
using (RSA rsa = RSAFactory.Create(2048))
{
if (!expectSuccess)
{
Assert.ThrowsAny <CryptographicException>(
() => Encrypt(rsa, TestData.HelloBytes, paddingMode));
return;
}
crypt = Encrypt(rsa, TestData.HelloBytes, paddingMode);
output = Decrypt(rsa, crypt, paddingMode);
}
Assert.NotEqual(crypt, output);
Assert.Equal(TestData.HelloBytes, output);
}
public void RsaDecryptOaepWrongDataLength()
{
using (RSA rsa = RSAFactory.Create(TestData.RSA2048Params))
{
byte[] data = TestData.HelloBytes;
byte[] encrypted = Encrypt(rsa, data, RSAEncryptionPadding.OaepSHA1);
Array.Resize(ref encrypted, encrypted.Length + 1);
if (!PlatformDetection.IsNetFramework)
{
Assert.ThrowsAny <CryptographicException>(
() => Decrypt(rsa, encrypted, RSAEncryptionPadding.OaepSHA1));
}
Array.Resize(ref encrypted, encrypted.Length - 2);
Assert.ThrowsAny <CryptographicException>(
() => Decrypt(rsa, encrypted, RSAEncryptionPadding.OaepSHA1));
if (RSAFactory.SupportsSha2Oaep)
{
encrypted = Encrypt(rsa, data, RSAEncryptionPadding.OaepSHA256);
Array.Resize(ref encrypted, encrypted.Length + 1);
if (!PlatformDetection.IsNetFramework)
{
Assert.ThrowsAny <CryptographicException>(
() => Decrypt(rsa, encrypted, RSAEncryptionPadding.OaepSHA256));
}
Array.Resize(ref encrypted, encrypted.Length - 2);
Assert.ThrowsAny <CryptographicException>(
() => Decrypt(rsa, encrypted, RSAEncryptionPadding.OaepSHA256));
}
}
}
public static void ImportFromEncryptedPem_Pkcs8Encrypted_Char_Simple()
{
using (RSA rsa = RSAFactory.Create())
{
string pem = @"
-----BEGIN ENCRYPTED PRIVATE KEY-----
MIIBsTBLBgkqhkiG9w0BBQ0wPjApBgkqhkiG9w0BBQwwHAQIcvgI1lw9LqYCAggA
MAwGCCqGSIb3DQIJBQAwEQYFKw4DAgcECFDpLREQXt5pBIIBYOKuM5ljAvCViDL+
nTFq7A/fI9rqdL20TMdf0wy7s43oXmsw5gCStoNEaoVToFCQWYYBRU99mK8YNFA8
1ZJT53SDS7buJ0zX9oDltf2ByXRPI4mn2Il2HZvN2hi9ir1w8M3XoSFSurN9tC8r
IOiGkVfK9Ll54knONewNiCNefFZFctRfVMbac5SwHokCkBMHukl0oPrpVuBE8kRo
p7XtjM8ILtzLVz0iLqKXiNIf6kRdouCBmCn8VIQgIvPPIHD8vheMXWjN7g69P5n4
1YI4c/acljcofmq1BBPTwvxaETrg2NHW0XMIgAxoaVP8lIIGlNk1glWTYpuMd69L
AWvBUt33Sozc+dF0l7NGLAWL2tqkkpyDQuKn6UgYz/vxkFeQAVfSuaJVR+fUlHg0
N4lD7/hJq7b+yYPhlN3Fvvt8M9MtRg1TLAve67CA2v4TITHB06M/ELe3y42bZuLW
CA7ffFk=
-----END ENCRYPTED PRIVATE KEY-----";
rsa.ImportFromEncryptedPem(pem, "test");
RSAParameters rsaParameters = rsa.ExportParameters(true);
ImportExport.AssertKeyEquals(TestData.DiminishedDPParameters, rsaParameters);
}
}
public void RsaDecryptPkcs1WrongDataLength()
{
using (RSA rsa = RSAFactory.Create(TestData.RSA2048Params))
{
byte[] data = TestData.HelloBytes;
byte[] encrypted = Encrypt(rsa, data, RSAEncryptionPadding.Pkcs1);
Array.Resize(ref encrypted, encrypted.Length + 1);
// Baseline/exempt a .NET Framework difference for RSACng
if (!PlatformDetection.IsNetFramework ||
rsa.GetType().Assembly.GetName().Name != "System.Core")
{
Assert.ThrowsAny <CryptographicException>(
() => Decrypt(rsa, encrypted, RSAEncryptionPadding.Pkcs1));
}
Array.Resize(ref encrypted, encrypted.Length - 2);
Assert.ThrowsAny <CryptographicException>(
() => Decrypt(rsa, encrypted, RSAEncryptionPadding.Pkcs1));
}
}
public static void ImportFromEncryptedPem_Pkcs8Encrypted_Byte_Simple()
{
using (RSA rsa = RSAFactory.Create())
{
string pem = @"
-----BEGIN ENCRYPTED PRIVATE KEY-----
MIIBvTBXBgkqhkiG9w0BBQ0wSjApBgkqhkiG9w0BBQwwHAQIciLWmWb33X0CAggA
MAwGCCqGSIb3DQIJBQAwHQYJYIZIAWUDBAECBBBVEmHhJdbi+HKzPttNjXm4BIIB
YFejknurbot2VDXwc671A0mfA0cw/u7K44gsYXcZwAARC8j6f3lSzB0tN2kMEx/L
TB+kpMBbfAoIPKoEc9Y4w9m3NXkQYrLRONh9AFiAnOjULHwkstQfN2ofFlolDfbH
hAE6ga6aQJTQ8rDKTL4QkCg+s+qWlicPqs5ikSQfUz2Qiy8FKe7zZlJ0OWpT+zk7
EYRrUSKQcEAjfNS7anlMps2ZXRc1LkLJNHZSl6h2BuFPfIKEV9REpy3Y7sH7vNZZ
PWPa9/xM4CX/c/ommy6LqvZikUuUGc56/Hbz65SwG3voivIhOTmM28LiA6z0YXmY
E+nr7hyinl51raM1RSHojJB22oOW+GwV7GgWYIjUgIEMDOhN10FcGNfTeC65PCXx
5QSEe7EKVF0aHXBYB5SzMGVuxR/BqydDa26jlhVzO3LNvy9FYuqLKUslCrBCmPrt
raZNyk8KAsLs+FJq9T2tda0=
-----END ENCRYPTED PRIVATE KEY-----";
rsa.ImportFromEncryptedPem(pem, Encoding.UTF8.GetBytes("test"));
RSAParameters rsaParameters = rsa.ExportParameters(true);
ImportExport.AssertKeyEquals(TestData.DiminishedDPParameters, rsaParameters);
}
}
public void RoundtripEmptyArray()
{
using (RSA rsa = RSAFactory.Create(TestData.RSA2048Params))
{
void RoundtripEmpty(RSAEncryptionPadding paddingMode)
{
byte[] encrypted = Encrypt(rsa, Array.Empty <byte>(), paddingMode);
byte[] decrypted = Decrypt(rsa, encrypted, paddingMode);
Assert.Equal(Array.Empty <byte>(), decrypted);
}
RoundtripEmpty(RSAEncryptionPadding.Pkcs1);
RoundtripEmpty(RSAEncryptionPadding.OaepSHA1);
if (RSAFactory.SupportsSha2Oaep)
{
RoundtripEmpty(RSAEncryptionPadding.OaepSHA256);
RoundtripEmpty(RSAEncryptionPadding.OaepSHA384);
RoundtripEmpty(RSAEncryptionPadding.OaepSHA512);
}
}
}
public void DecryptWithPublicKey_Fails()
{
byte[] cipherBytes =
{
0x35, 0x6F, 0x8F, 0x2C, 0x4D, 0x1A, 0xAC, 0x6D,
0xE7, 0x52, 0xA5, 0xDF, 0x26, 0x54, 0xA6, 0x34,
0xF5, 0xBB, 0x14, 0x26, 0x1C, 0xE4, 0xDC, 0xA2,
0xD8, 0x4D, 0x8F, 0x1C, 0x55, 0xD4, 0xC7, 0xA7,
0xF2, 0x3C, 0x99, 0x77, 0x9F, 0xE4, 0xB7, 0x34,
0xA6, 0x28, 0xB2, 0xC4, 0xFB, 0x6F, 0x85, 0xCA,
0x19, 0x21, 0xCA, 0xC1, 0xA7, 0x8D, 0xAE, 0x95,
0xAB, 0x9B, 0xA9, 0x88, 0x5B, 0x44, 0xC6, 0x9B,
0x44, 0x26, 0x71, 0x5D, 0x02, 0x3F, 0x43, 0x42,
0xEF, 0x4E, 0xEE, 0x09, 0x87, 0xEF, 0xCD, 0xCF,
0xF9, 0x88, 0x99, 0xE8, 0x49, 0xF7, 0x8F, 0x9B,
0x59, 0x68, 0x20, 0xF3, 0xA7, 0xB2, 0x94, 0xA4,
0x23, 0x70, 0x83, 0xD9, 0xAC, 0xE7, 0x5E, 0xEE,
0xE9, 0x7B, 0xE4, 0x4F, 0x73, 0x2E, 0x9B, 0xD8,
0x2A, 0x75, 0xFB, 0x6C, 0xB9, 0x39, 0x6D, 0x72,
0x8A, 0x9C, 0xCD, 0x58, 0x1A, 0x27, 0x79, 0x97,
};
using (RSA rsa = RSAFactory.Create())
{
RSAParameters parameters = TestData.RSA1024Params;
RSAParameters pubParameters = new RSAParameters
{
Modulus = parameters.Modulus,
Exponent = parameters.Exponent,
};
rsa.ImportParameters(pubParameters);
Assert.ThrowsAny <CryptographicException>(
() => Decrypt(rsa, cipherBytes, RSAEncryptionPadding.OaepSHA1));
}
}
public void RsaPkcsEncryptMaxSize()
{
RSAParameters rsaParameters = TestData.RSA2048Params;
using (RSA rsa = RSAFactory.Create(rsaParameters))
{
RSAEncryptionPadding paddingMode1 = RSAEncryptionPadding.Pkcs1;
// The overhead required is 8 + 3 => 11.
const int Pkcs1Overhead = 11;
int maxSize = rsaParameters.Modulus.Length - Pkcs1Overhead;
byte[] data = new byte[maxSize];
byte[] encrypted = Encrypt(rsa, data, paddingMode1);
byte[] decrypted = Decrypt(rsa, encrypted, paddingMode1);
Assert.Equal(data.ByteArrayToHex(), decrypted.ByteArrayToHex());
data = new byte[maxSize + 1];
Assert.ThrowsAny <CryptographicException>(
() => Encrypt(rsa, data, paddingMode1));
}
}