namespace MonoTests.System.Security.Cryptography {
[TestFixture]
-public class RSACryptoServiceProviderTest : Assertion {
+public class RSACryptoServiceProviderTest {
protected RSACryptoServiceProvider rsa;
protected RSACryptoServiceProvider disposed;
private bool machineKeyStore;
- [TestFixtureSetUp]
- public void FixtureSetUp ()
+ public RSACryptoServiceProviderTest ()
{
sha1OID = CryptoConfig.MapNameToOID ("SHA1");
disposed = new RSACryptoServiceProvider (minKeySize);
public void AssertEquals (string message, RSAParameters expectedKey, RSAParameters actualKey, bool checkPrivateKey)
{
if (checkPrivateKey) {
- AssertEquals (message + " P", expectedKey.P, actualKey.P);
- AssertEquals (message + " Q", expectedKey.Q, actualKey.Q);
- AssertEquals (message + " D", expectedKey.D, actualKey.D);
- AssertEquals (message + " DP", expectedKey.DP, actualKey.DP);
- AssertEquals (message + " DQ", expectedKey.DQ, actualKey.DQ);
- AssertEquals (message + " InverseQ", expectedKey.InverseQ, actualKey.InverseQ);
+ Assert.AreEqual (expectedKey.P, actualKey.P, message + " P");
+ Assert.AreEqual (expectedKey.Q, actualKey.Q, message + " Q");
+ Assert.AreEqual (expectedKey.D, actualKey.D, message + " D");
+ Assert.AreEqual (expectedKey.DP, actualKey.DP, message + " DP");
+ Assert.AreEqual (expectedKey.DQ, actualKey.DQ, message + " DQ");
+ Assert.AreEqual (expectedKey.InverseQ, actualKey.InverseQ, message + " InverseQ");
}
- AssertEquals (message + " Modulus", expectedKey.Modulus, actualKey.Modulus);
- AssertEquals (message + " Exponent", expectedKey.Exponent, actualKey.Exponent);
+ Assert.AreEqual (expectedKey.Modulus, actualKey.Modulus, message + " Modulus");
+ Assert.AreEqual (expectedKey.Exponent, actualKey.Exponent, message + " Exponent");
}
[Test]
// under Mono:: a new key pair isn't generated
rsa = new RSACryptoServiceProvider ();
// test default key size
- AssertEquals ("ConstructorEmpty", 1024, rsa.KeySize);
- Assert ("PersistKeyInCsp", !rsa.PersistKeyInCsp);
-#if NET_2_0
- Assert ("PublicOnly", !rsa.PublicOnly);
-#endif
+ Assert.AreEqual (1024, rsa.KeySize, "ConstructorEmpty");
+ Assert.IsFalse (rsa.PersistKeyInCsp, "PersistKeyInCsp");
+ Assert.IsFalse (rsa.PublicOnly, "PublicOnly");
}
[Test]
{
rsa = new RSACryptoServiceProvider (minKeySize);
// test default key size
- AssertEquals ("ConstructorKeySize", minKeySize, rsa.KeySize);
- Assert ("PersistKeyInCsp", !rsa.PersistKeyInCsp);
-#if NET_2_0
- Assert ("PublicOnly", !rsa.PublicOnly);
-#endif
+ Assert.AreEqual (minKeySize, rsa.KeySize, "ConstructorKeySize");
+ Assert.IsFalse (rsa.PersistKeyInCsp, "PersistKeyInCsp");
+ Assert.IsFalse (rsa.PublicOnly, "PublicOnly");
}
[Test]
- [Category ("TargetJvmNotSupported")]
public void ConstructorCspParameters ()
{
CspParameters csp = new CspParameters (1, null, "Mono1024");
// under MS a new keypair will only be generated the first time
rsa = new RSACryptoServiceProvider (csp);
// test default key size
- AssertEquals ("ConstructorCspParameters", 1024, rsa.KeySize);
- Assert ("PersistKeyInCsp", rsa.PersistKeyInCsp);
-#if NET_2_0
- Assert ("PublicOnly", !rsa.PublicOnly);
-#endif
+ Assert.AreEqual (1024, rsa.KeySize, "ConstructorCspParameters");
+ Assert.IsTrue (rsa.PersistKeyInCsp, "PersistKeyInCsp");
+ Assert.IsFalse (rsa.PublicOnly, "PublicOnly");
}
[Test]
- [Category ("TargetJvmNotSupported")]
public void ConstructorKeySizeCspParameters ()
{
int keySize = 512;
CspParameters csp = new CspParameters (1, null, "Mono512");
rsa = new RSACryptoServiceProvider (keySize, csp);
- AssertEquals ("ConstructorCspParameters", keySize, rsa.KeySize);
- Assert ("PersistKeyInCsp", rsa.PersistKeyInCsp);
-#if NET_2_0
- Assert ("PublicOnly", !rsa.PublicOnly);
-#endif
+ Assert.AreEqual (keySize, rsa.KeySize, "ConstructorCspParameters");
+ Assert.IsTrue (rsa.PersistKeyInCsp, "PersistKeyInCsp");
+ Assert.IsFalse (rsa.PublicOnly, "PublicOnly");
}
[Test]
KeySizes LegalKeySize = rsa.LegalKeySizes [0];
for (int i = LegalKeySize.MinSize; i <= LegalKeySize.MaxSize; i += LegalKeySize.SkipSize) {
rsa = new RSACryptoServiceProvider (i);
- AssertEquals ("KeySize", i, rsa.KeySize);
+ Assert.AreEqual (i, rsa.KeySize, "KeySize");
}
}
public void TooSmallKeyPair ()
{
rsa = new RSACryptoServiceProvider (256);
-#if NET_2_0
// in 2.0 MS delay the creation of the key pair until it is required
// (same trick that Mono almost always used ;-) but they also delay
// the parameter validation (what Mono didn't). So here we must "get"
// the key (export) to trigger the exception
rsa.ToXmlString (true);
-#endif
}
[Test]
public void TooBigKeyPair ()
{
rsa = new RSACryptoServiceProvider (32768);
-#if NET_2_0
// in 2.0 MS delay the creation of the key pair until it is required
// (same trick that Mono almost always used ;-) but they also delay
// the parameter validation (what Mono didn't). So here we must "get"
// the key (export) to trigger the exception
rsa.ToXmlString (true);
-#endif
}
[Test]
public void Properties ()
{
rsa = new RSACryptoServiceProvider (minKeySize);
- AssertEquals ("LegalKeySize", 1, rsa.LegalKeySizes.Length);
- AssertEquals ("LegalKeySize.MinSize", minKeySize, rsa.LegalKeySizes [0].MinSize);
- AssertEquals ("LegalKeySize.MaxSize", 16384, rsa.LegalKeySizes [0].MaxSize);
- AssertEquals ("LegalKeySize.SkipSize", 8, rsa.LegalKeySizes [0].SkipSize);
- AssertEquals ("KeyExchangeAlgorithm", "RSA-PKCS1-KeyEx", rsa.KeyExchangeAlgorithm);
- AssertEquals ("SignatureAlgorithm", "http://www.w3.org/2000/09/xmldsig#rsa-sha1", rsa.SignatureAlgorithm);
+ Assert.AreEqual (1, rsa.LegalKeySizes.Length, "LegalKeySize");
+ Assert.AreEqual (minKeySize, rsa.LegalKeySizes [0].MinSize, "LegalKeySize.MinSize");
+ Assert.AreEqual (16384, rsa.LegalKeySizes [0].MaxSize, "LegalKeySize.MaxSize");
+ Assert.AreEqual (8, rsa.LegalKeySizes [0].SkipSize, "LegalKeySize.SkipSize");
+ Assert.AreEqual ("RSA-PKCS1-KeyEx", rsa.KeyExchangeAlgorithm, "KeyExchangeAlgorithm");
+ Assert.AreEqual ("http://www.w3.org/2000/09/xmldsig#rsa-sha1", rsa.SignatureAlgorithm, "SignatureAlgorithm");
rsa.Clear ();
- AssertEquals ("LegalKeySize(disposed)", 1, rsa.LegalKeySizes.Length);
- AssertEquals ("LegalKeySize.MinSize(disposed)", minKeySize, rsa.LegalKeySizes [0].MinSize);
- AssertEquals ("LegalKeySize.MaxSize(disposed)", 16384, rsa.LegalKeySizes [0].MaxSize);
- AssertEquals ("LegalKeySize.SkipSize(disposed)", 8, rsa.LegalKeySizes [0].SkipSize);
- AssertEquals ("KeyExchangeAlgorithm(disposed)", "RSA-PKCS1-KeyEx", rsa.KeyExchangeAlgorithm);
- AssertEquals ("SignatureAlgorithm(disposed)", "http://www.w3.org/2000/09/xmldsig#rsa-sha1", rsa.SignatureAlgorithm);
+ Assert.AreEqual (1, rsa.LegalKeySizes.Length, "LegalKeySize(disposed)");
+ Assert.AreEqual (minKeySize, rsa.LegalKeySizes [0].MinSize, "LegalKeySize.MinSize(disposed)");
+ Assert.AreEqual (16384, rsa.LegalKeySizes [0].MaxSize, "LegalKeySize.MaxSize(disposed)");
+ Assert.AreEqual (8, rsa.LegalKeySizes [0].SkipSize, "LegalKeySize.SkipSize(disposed)");
+ Assert.AreEqual ("RSA-PKCS1-KeyEx", rsa.KeyExchangeAlgorithm, "KeyExchangeAlgorithm(disposed)");
+ Assert.AreEqual ("http://www.w3.org/2000/09/xmldsig#rsa-sha1", rsa.SignatureAlgorithm, "SignatureAlgorithm(disposed)");
}
[Test]
int total = 0;
for (int i=0; i < data.Length; i++)
total += data [i];
- AssertEquals ("DecryptDisposed", 0, total);
+ Assert.AreEqual (0, total, "DecryptDisposed");
}
[Test]
rsa.SignData (data, MD5.Create ());
}
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void SignDataWithInvalidOid ()
+ {
+ byte[] data = new byte [5];
+ rsa = new RSACryptoServiceProvider (minKeySize);
+
+ rsa.SignData (data, "1.2.3");
+ }
+
+ [Test]
+ public void SignDataWithOid ()
+ {
+ string oid = CryptoConfig.MapNameToOID ("SHA256");
+ byte[] data = new byte [5];
+ rsa = new RSACryptoServiceProvider (minKeySize);
+
+ rsa.SignData (data, oid);
+ }
+
[Test]
[ExpectedException (typeof (ArgumentNullException))]
public void SignHashNullValue ()
byte [] hash = new byte [20];
rsa = new RSACryptoServiceProvider (minKeySize);
byte[] signature = rsa.SignHash (hash, null);
- Assert ("Null OID == SHA1", rsa.VerifyHash (hash, "1.3.14.3.2.26", signature));
- Assert ("Null OID", rsa.VerifyHash (hash, null, signature));
+ Assert.IsTrue (rsa.VerifyHash (hash, "1.3.14.3.2.26", signature), "Null OID == SHA1");
+ Assert.IsTrue (rsa.VerifyHash (hash, null, signature), "Null OID");
}
void SignHash (string name, int size)
byte [] hash = new byte [size];
rsa = new RSACryptoServiceProvider (1024);
byte [] signature = rsa.SignHash (hash, oid);
- Assert (name, rsa.VerifyHash (hash, oid, signature));
- Assert ("OID", rsa.VerifyHash (hash, oid, signature));
+ Assert.IsTrue (rsa.VerifyHash (hash, oid, signature), name);
+ Assert.IsTrue (rsa.VerifyHash (hash, oid, signature), "OID");
}
[Test]
public void SignHashRIPEMD160 ()
{
string oid = CryptoConfig.MapNameToOID ("RIPEMD160");
- AssertNotNull (oid);
+ Assert.IsNotNull (oid);
byte [] hash = new byte [20];
rsa = new RSACryptoServiceProvider (minKeySize);
// OID not supported
rsa.VerifyHash (hash, "1.3.14.3.2.26", null);
}
-#if NET_2_0
+#if !MOBILE
[Test]
[Category ("NotWorking")]
public void ImportDisposed ()
rsa = new RSACryptoServiceProvider ();
rsa.FromXmlString (CapiXml384);
- AssertEquals ("Capi-Xml384", CapiXml384, rsa.ToXmlString (true));
+ Assert.AreEqual (CapiXml384, rsa.ToXmlString (true), "Capi-Xml384");
rsa.FromXmlString (CapiXml448);
- AssertEquals ("Capi-Xml448", CapiXml448, rsa.ToXmlString (true));
+ Assert.AreEqual (CapiXml448, rsa.ToXmlString (true), "Capi-Xml448");
rsa.FromXmlString (CapiXml512);
- AssertEquals ("Capi-Xml512", CapiXml512, rsa.ToXmlString (true));
+ Assert.AreEqual (CapiXml512, rsa.ToXmlString (true), "Capi-Xml512");
rsa.FromXmlString (CapiXml576);
- AssertEquals ("Capi-Xml576", CapiXml576, rsa.ToXmlString (true));
+ Assert.AreEqual (CapiXml576, rsa.ToXmlString (true), "Capi-Xml576");
rsa.FromXmlString (CapiXml640);
- AssertEquals ("Capi-Xml640", CapiXml640, rsa.ToXmlString (true));
+ Assert.AreEqual (CapiXml640, rsa.ToXmlString (true), "Capi-Xml640");
rsa.FromXmlString (CapiXml704);
- AssertEquals ("Capi-Xml704", CapiXml704, rsa.ToXmlString (true));
+ Assert.AreEqual (CapiXml704, rsa.ToXmlString (true), "Capi-Xml704");
rsa.FromXmlString (CapiXml768);
- AssertEquals ("Capi-Xml768", CapiXml768, rsa.ToXmlString (true));
+ Assert.AreEqual (CapiXml768, rsa.ToXmlString (true), "Capi-Xml768");
rsa.FromXmlString (CapiXml832);
- AssertEquals ("Capi-Xml832", CapiXml832, rsa.ToXmlString (true));
+ Assert.AreEqual (CapiXml832, rsa.ToXmlString (true), "Capi-Xml832");
rsa.FromXmlString (CapiXml896);
- AssertEquals ("Capi-Xml896", CapiXml896, rsa.ToXmlString (true));
+ Assert.AreEqual (CapiXml896, rsa.ToXmlString (true), "Capi-Xml896");
rsa.FromXmlString (CapiXml960);
- AssertEquals ("Capi-Xml960", CapiXml960, rsa.ToXmlString (true));
+ Assert.AreEqual (CapiXml960, rsa.ToXmlString (true), "Capi-Xml960");
rsa.FromXmlString (CapiXml1024);
- AssertEquals ("Capi-Xml1024", CapiXml1024, rsa.ToXmlString (true));
+ Assert.AreEqual (CapiXml1024, rsa.ToXmlString (true), "Capi-Xml1024");
rsa.FromXmlString (CapiXml1536);
- AssertEquals ("Capi-Xml1536", CapiXml1536, rsa.ToXmlString (true));
+ Assert.AreEqual (CapiXml1536, rsa.ToXmlString (true), "Capi-Xml1536");
rsa.FromXmlString (CapiXml2048);
- AssertEquals ("Capi-Xml2048", CapiXml2048, rsa.ToXmlString (true));
+ Assert.AreEqual (CapiXml2048, rsa.ToXmlString (true), "Capi-Xml2048");
}
[Test]
// the signature is never the same so the only way to know if
// it worked is to verify it ourselve (i.e. can't compare)
bool ok = key.VerifyHash (hash, sha1OID, sign);
- Assert (msg + "-SignAndVerify", ok);
+ Assert.IsTrue (ok, msg + "-SignAndVerify");
}
// Validate that we can sign with every keypair and verify the signature
rsa.FromXmlString (CapiXml384);
byte[] sign384 = { 0x6D, 0x6F, 0xE1, 0x17, 0x28, 0x88, 0x0C, 0x72, 0x9D, 0x17, 0xBD, 0x06, 0x02, 0xBA, 0x6D, 0xF0, 0x16, 0x2A, 0xE6, 0x19, 0x40, 0x1D, 0x58, 0xD3, 0x44, 0x70, 0xDE, 0x57, 0x4C, 0xC8, 0xE5, 0x9C, 0x5D, 0xA1, 0x84, 0x7E, 0xD4, 0xC3, 0x61, 0xAA, 0x21, 0xC3, 0x83, 0x5B, 0xAF, 0x1C, 0xB7, 0x2B };
- Assert ("Capi-384-Verify", rsa.VerifyHash (hash, sha1OID, sign384));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign384), "Capi-384-Verify");
sign384[0] = 0x00;
- Assert ("Capi-384-VerBad", !rsa.VerifyHash (hash, sha1OID, sign384));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign384), "Capi-384-VerBad");
rsa.FromXmlString (CapiXml448);
byte[] sign448 = { 0x59, 0xD9, 0x57, 0x80, 0x20, 0x18, 0xF6, 0x23, 0xDB, 0x3A, 0xE3, 0xB0, 0xFD, 0xEA, 0xD3, 0x2A, 0x52, 0x83, 0x41, 0x49, 0x48, 0xD8, 0xD5, 0x4F, 0xE7, 0xDB, 0x7A, 0x97, 0xF9, 0x07, 0x27, 0xD9, 0xAC, 0x60, 0xA2, 0x17, 0x76, 0x70, 0x09, 0x09, 0x23, 0x0E, 0xBF, 0x3D, 0x01, 0x93, 0x91, 0x97, 0xDB, 0xB3, 0x1F, 0x20, 0x78, 0xFA, 0x7E, 0x72 };
- Assert ("Capi-448-Verify", rsa.VerifyHash (hash, sha1OID, sign448));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign448), "Capi-448-Verify");
sign448[0] = 0x00;
- Assert ("Capi-448-VerBad", !rsa.VerifyHash (hash, sha1OID, sign448));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign448), "Capi-448-VerBad");
rsa.FromXmlString (CapiXml512);
byte[] sign512 = { 0x66, 0x80, 0x40, 0x76, 0x01, 0xDA, 0x66, 0xF2, 0x36, 0x5C, 0xCE, 0x4C, 0x47, 0xA1, 0x02, 0x1C, 0x4F, 0xC8, 0xCE, 0xB2, 0x01, 0xC2, 0xD1, 0x54, 0x55, 0x41, 0xAF, 0x12, 0x60, 0xD7, 0x49, 0x9A, 0x4B, 0x37, 0x20, 0x1A, 0x2A, 0xD8, 0x2B, 0x82, 0xCA, 0x84, 0xAF, 0xB3, 0xB1, 0x4D, 0xA9, 0x0B, 0x70, 0x17, 0x3B, 0xD8, 0x17, 0xAA, 0x51, 0xE7, 0x1F, 0xB7, 0xCF, 0xD8, 0xF9, 0x32, 0x60, 0x01 };
- Assert ("Capi-512-Verify", rsa.VerifyHash (hash, sha1OID, sign512));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign512), "Capi-512-Verify");
sign512[0] = 0x00;
- Assert ("Capi-512-VerBad", !rsa.VerifyHash (hash, sha1OID, sign512));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign512), "Capi-512-VerBad");
rsa.FromXmlString (CapiXml576);
byte[] sign576 = { 0x25, 0x39, 0x21, 0xDE, 0x34, 0x23, 0xEC, 0xFE, 0xEC, 0x28, 0xB2, 0xEA, 0x8D, 0x5A, 0x6C, 0x4B, 0x86, 0x2B, 0xEA, 0x6E, 0xB7, 0xBA, 0x1A, 0x38, 0x6A, 0x8C, 0xC9, 0xC5, 0xC1, 0x89, 0x84, 0x9F, 0x97, 0x5B, 0xA0, 0x58, 0xD6, 0x08, 0x09, 0x5B, 0x4C, 0x9A, 0x9F, 0xFF, 0x10, 0x8B, 0xD1, 0xEA, 0xED, 0x81, 0x62, 0x2D, 0x09, 0x87, 0x81, 0xED, 0x76, 0xCF, 0x47, 0xB8, 0xF8, 0x06, 0x84, 0x80, 0x8E, 0xBC, 0x8C, 0xDF, 0xF2, 0xEE, 0xAB, 0x47 };
- Assert ("Capi-576-Verify", rsa.VerifyHash (hash, sha1OID, sign576));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign576), "Capi-576-Verify");
sign576[0] = 0x00;
- Assert ("Capi-576-VerBad", !rsa.VerifyHash (hash, sha1OID, sign576));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign576), "Capi-576-VerBad");
rsa.FromXmlString (CapiXml640);
byte[] sign640 = { 0x7E, 0x58, 0x16, 0x4E, 0xD9, 0xFE, 0x4D, 0x73, 0x2E, 0x6D, 0x5B, 0x62, 0x05, 0x91, 0x43, 0xA4, 0xEF, 0x65, 0xA9, 0x68, 0xA6, 0x19, 0x65, 0x8F, 0x25, 0xBC, 0x2B, 0xE2, 0x93, 0xE2, 0xEF, 0x5E, 0x29, 0x11, 0x0C, 0xCE, 0x17, 0x01, 0x5D, 0xB7, 0x71, 0x79, 0x83, 0xC5, 0xAB, 0x51, 0xBF, 0x87, 0x80, 0x4A, 0x04, 0x7B, 0xB4, 0x46, 0xCA, 0x11, 0x71, 0xB1, 0x67, 0x28, 0x4C, 0x16, 0x82, 0x6B, 0xE3, 0x11, 0x72, 0x6D, 0xA9, 0x07, 0x4A, 0xE6, 0x33, 0x45, 0x30, 0x15, 0x83, 0x23, 0x5E, 0x05 };
- Assert ("Capi-640-Verify", rsa.VerifyHash (hash, sha1OID, sign640));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign640), "Capi-640-Verify");
sign640[0] = 0x00;
- Assert ("Capi-640-VerBad", !rsa.VerifyHash (hash, sha1OID, sign640));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign640), "Capi-640-VerBad");
rsa.FromXmlString (CapiXml704);
byte[] sign704 = { 0x91, 0x3C, 0x91, 0x7C, 0x2A, 0x26, 0xB1, 0x6F, 0x7C, 0xFD, 0x75, 0xCC, 0xB0, 0x63, 0x03, 0x76, 0xBF, 0x93, 0xAB, 0x3B, 0xD4, 0x71, 0x86, 0x86, 0xEF, 0x10, 0xD6, 0x51, 0x8D, 0x6B, 0xB4, 0xF2, 0xF9, 0xCC, 0x50, 0x3A, 0x63, 0x9A, 0xD2, 0xA2, 0xE2, 0x72, 0x06, 0x88, 0x4E, 0xCD, 0x38, 0x9B, 0x87, 0x72, 0xAD, 0x38, 0xF7, 0xCB, 0x6B, 0x69, 0x43, 0xA0, 0x4C, 0x9B, 0x10, 0x17, 0xAB, 0xE8, 0x50, 0x34, 0x6E, 0x8D, 0x56, 0xBC, 0x6C, 0x00, 0x87, 0x40, 0x05, 0x4A, 0x20, 0x16, 0x49, 0x4F, 0x93, 0x48, 0x5F, 0x7A, 0x10, 0x61, 0xC6, 0xC9 };
- Assert ("Capi-704-Verify", rsa.VerifyHash (hash, sha1OID, sign704));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign704), "Capi-704-Verify");
sign704[0] = 0x00;
- Assert ("Capi-704-VerBad", !rsa.VerifyHash (hash, sha1OID, sign704));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign704), "Capi-704-VerBad");
rsa.FromXmlString (CapiXml768);
byte[] sign768 = { 0x0D, 0x67, 0x37, 0x00, 0x3E, 0xD5, 0x02, 0x12, 0xF0, 0xF9, 0xC2, 0x63, 0x29, 0xD9, 0xEA, 0x7B, 0xDC, 0x5B, 0xF3, 0xF0, 0xB9, 0x3B, 0x04, 0x98, 0xD9, 0xE7, 0xA3, 0xB2, 0xD2, 0x01, 0x04, 0x7A, 0xF4, 0x11, 0x7F, 0x62, 0xC7, 0x18, 0x14, 0xA0, 0x54, 0x96, 0x51, 0x84, 0xC4, 0x6D, 0x6A, 0xCB, 0x67, 0x07, 0xD0, 0x33, 0x93, 0x99, 0xAD, 0x1F, 0x16, 0xA6, 0x7F, 0xE0, 0x60, 0x8A, 0xDC, 0x95, 0xB9, 0x0E, 0x68, 0xA9, 0x78, 0xE1, 0x0D, 0x47, 0x56, 0xF3, 0x01, 0x42, 0xF6, 0xD7, 0xE4, 0x4A, 0x98, 0x7E, 0xC4, 0x5E, 0x0E, 0x09, 0xC4, 0x92, 0x42, 0x69, 0x74, 0x7A, 0xC9, 0x0E, 0x9F, 0xF2 };
- Assert ("Capi-768-Verify", rsa.VerifyHash (hash, sha1OID, sign768));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign768), "Capi-768-Verify");
sign768[0] = 0x00;
- Assert ("Capi-768-VerBad", !rsa.VerifyHash (hash, sha1OID, sign768));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign768), "Capi-768-VerBad");
rsa.FromXmlString (CapiXml832);
byte[] sign832 = { 0x7B, 0xBC, 0xE6, 0xEC, 0x8B, 0x11, 0x7C, 0x28, 0x09, 0x3A, 0x06, 0x81, 0x52, 0x20, 0x7B, 0x50, 0x88, 0x74, 0x3C, 0x96, 0xBC, 0x40, 0xAF, 0x8E, 0xD3, 0x60, 0x49, 0xBF, 0x93, 0x6C, 0xF6, 0xE9, 0x34, 0xAB, 0x7E, 0xE7, 0x56, 0x2E, 0x33, 0x5A, 0x75, 0x4E, 0xFE, 0xFF, 0xC8, 0x15, 0x02, 0x8C, 0x30, 0x81, 0xD0, 0x46, 0x68, 0x42, 0x2E, 0xA8, 0x78, 0x5C, 0xDE, 0xEA, 0x98, 0x79, 0x81, 0xBF, 0xEA, 0xC4, 0x8B, 0x2F, 0x50, 0x7A, 0x50, 0x11, 0xAC, 0x01, 0xEB, 0x84, 0xA0, 0x9F, 0x7A, 0x67, 0xFA, 0x33, 0x3A, 0x65, 0x1C, 0xE9, 0xFA, 0xD9, 0x46, 0x06, 0xAF, 0x3E, 0x83, 0x4A, 0x67, 0x11, 0x0B, 0xD5, 0xD2, 0x56, 0x5E, 0x05, 0x69, 0xE8 };
- Assert ("Capi-832-Verify", rsa.VerifyHash (hash, sha1OID, sign832));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign832), "Capi-832-Verify");
sign832[0] = 0x00;
- Assert ("Capi-832-VerBad", !rsa.VerifyHash (hash, sha1OID, sign832));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign832), "Capi-832-VerBad");
rsa.FromXmlString (CapiXml896);
byte[] sign896 = { 0x60, 0xAA, 0x26, 0x4D, 0xBF, 0x0A, 0x38, 0x5E, 0x7B, 0x66, 0x1E, 0x1D, 0xED, 0x5F, 0xF2, 0x6A, 0xC4, 0xAB, 0x35, 0x43, 0x93, 0x67, 0x26, 0x90, 0xEB, 0x34, 0xC1, 0xCB, 0x22, 0x4C, 0x20, 0x00, 0xE5, 0xEB, 0xA8, 0x14, 0x06, 0x8A, 0xBD, 0x0A, 0x07, 0x02, 0x62, 0xC9, 0x82, 0x27, 0x84, 0x1D, 0x04, 0xC6, 0xFC, 0x20, 0xE4, 0x17, 0x07, 0x33, 0x03, 0xE7, 0x33, 0x8D, 0x4A, 0x69, 0x79, 0x51, 0xA5, 0x20, 0xED, 0xB8, 0x94, 0x02, 0x0B, 0xD2, 0xB9, 0x60, 0x71, 0x56, 0x47, 0x96, 0xE8, 0xA7, 0x1A, 0x4A, 0x71, 0xD8, 0xD1, 0x0C, 0x82, 0x86, 0xF9, 0x1C, 0x07, 0x46, 0xB6, 0x0F, 0xCB, 0x8C, 0x90, 0x95, 0x93, 0xBA, 0xF2, 0xC3, 0xB4, 0x68, 0xE8, 0xE4, 0x55, 0x6C, 0xEA, 0x1D, 0xA7, 0x53 };
- Assert ("Capi-896-Verify", rsa.VerifyHash (hash, sha1OID, sign896));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign896), "Capi-896-Verify");
sign896[0] = 0x00;
- Assert ("Capi-896-VerBad", !rsa.VerifyHash (hash, sha1OID, sign896));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign896), "Capi-896-VerBad");
rsa.FromXmlString (CapiXml960);
byte[] sign960 = { 0x57, 0x36, 0xBD, 0xF3, 0x5D, 0x99, 0x9A, 0x73, 0xF1, 0xE6, 0xC1, 0x4C, 0xDC, 0xBF, 0x5D, 0xC1, 0xC0, 0x7D, 0x32, 0x46, 0x2B, 0x0B, 0x51, 0xDB, 0x56, 0xA8, 0x25, 0xE7, 0xF9, 0x76, 0xB0, 0x0F, 0xC1, 0xBD, 0x49, 0x5E, 0x14, 0xF8, 0x1F, 0xD9, 0x94, 0x41, 0xA7, 0x4B, 0xF8, 0x9C, 0x4A, 0x9B, 0xA5, 0xF8, 0xDF, 0xE6, 0xF5, 0xF7, 0x6D, 0xFB, 0x59, 0x24, 0x9F, 0xAE, 0xBA, 0xDF, 0x51, 0x2F, 0xB2, 0x68, 0xF1, 0x35, 0xFB, 0xCC, 0xF7, 0x1D, 0x86, 0x2A, 0x2E, 0x53, 0x9F, 0xCA, 0xBC, 0x58, 0xBF, 0x6A, 0xBD, 0x3A, 0xAB, 0xCA, 0x64, 0x92, 0x42, 0x97, 0x87, 0x00, 0xEE, 0x4A, 0x3F, 0xE5, 0xED, 0x20, 0x49, 0xF4, 0x06, 0x53, 0xBA, 0xF8, 0x9D, 0x62, 0xC4, 0xC7, 0x99, 0x3E, 0x9C, 0xF9, 0xF1, 0xA6, 0xF7, 0x0D, 0x21, 0xBC, 0xF2, 0x8D };
- Assert ("Capi-960-Verify", rsa.VerifyHash (hash, sha1OID, sign960));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign960), "Capi-960-Verify");
sign960[0] = 0x00;
- Assert ("Capi-960-VerBad", !rsa.VerifyHash (hash, sha1OID, sign960));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign960), "Capi-960-VerBad");
rsa.FromXmlString (CapiXml1024);
byte[] sign1024 = { 0x30, 0xB9, 0x7F, 0xBC, 0x72, 0x75, 0xB4, 0xEE, 0x8F, 0x8F, 0xF1, 0xB9, 0xC3, 0xCB, 0xC0, 0xB2, 0x94, 0x8C, 0x1D, 0xB0, 0x60, 0xE8, 0x5E, 0x8D, 0x3F, 0x36, 0xF2, 0x4E, 0x09, 0xCD, 0x48, 0x85, 0xD3, 0x93, 0xEC, 0xEB, 0x08, 0xA6, 0xD1, 0xEF, 0x9F, 0xF5, 0xAB, 0x2D, 0x30, 0x3E, 0x86, 0x64, 0x8F, 0x9B, 0xB4, 0x0F, 0xDB, 0x70, 0x4A, 0x59, 0x8D, 0x6F, 0x14, 0x03, 0xFE, 0x46, 0xFC, 0x81, 0xA8, 0xC9, 0x75, 0x40, 0xEE, 0xB1, 0xED, 0xC4, 0xD0, 0xE5, 0xE5, 0x8F, 0xCD, 0x10, 0x01, 0xB2, 0x9D, 0xFD, 0xE6, 0x1E, 0x43, 0x3A, 0x69, 0xDB, 0xF9, 0x6D, 0xC9, 0xDD, 0x57, 0x9C, 0x84, 0x94, 0x7D, 0x0C, 0xDC, 0xFA, 0xD9, 0xDA, 0xE6, 0x90, 0xBA, 0x8C, 0x15, 0x68, 0xEA, 0x09, 0xEE, 0x8D, 0x5D, 0x5D, 0x73, 0xDE, 0xD1, 0x76, 0xE2, 0xF1, 0x48, 0x23, 0x57, 0xA6, 0xFA, 0x37, 0x57, 0xE7 };
- Assert ("Capi-1024-Verify", rsa.VerifyHash (hash, sha1OID, sign1024));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign1024), "Capi-1024-Verify");
sign1024[0] = 0x00;
- Assert ("Capi-1024-VerBad", !rsa.VerifyHash (hash, sha1OID, sign1024));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign1024), "Capi-1024-VerBad");
rsa.FromXmlString (CapiXml1536);
byte[] sign1536 = { 0x38, 0x0B, 0x7A, 0xF8, 0x64, 0xEB, 0x21, 0xCA, 0xC6, 0x7F, 0x09, 0x40, 0xD0, 0x92, 0x8C, 0x96, 0xEE, 0x47, 0x05, 0xFE, 0x17, 0xE9, 0x93, 0x97, 0xEF, 0x9F, 0xC0, 0xF1, 0xF5, 0x41, 0x91, 0x83, 0xEA, 0x77, 0x1B, 0x6A, 0x77, 0x4A, 0x14, 0xE2, 0xD9, 0x88, 0x8D, 0x8E, 0x91, 0xAF, 0x26, 0x87, 0xB9, 0xBC, 0x14, 0x52, 0xBD, 0xAD, 0x7E, 0x90, 0x00, 0x33, 0x1B, 0xF0, 0x08, 0x41, 0x7E, 0x77, 0x55, 0x4E, 0xAA, 0xF3, 0xAC, 0x8F, 0x00, 0x76, 0x25, 0xC0, 0x72, 0x88, 0xC0, 0xA4, 0x03, 0x46, 0xCC, 0xBC, 0xFE, 0x5A, 0x44, 0x10, 0x0D, 0x14, 0x7F, 0x65, 0x2E, 0x47, 0x55, 0x85, 0xF6, 0xC9, 0xEB, 0x60, 0x84, 0x09, 0x91, 0x3D, 0xAC, 0x8E, 0x40, 0x44, 0xE5, 0x7C, 0x4F, 0xAE, 0xA4, 0x21, 0x7D, 0x16, 0x27, 0xFC, 0x0E, 0xC5, 0x6B, 0x0C, 0x63, 0xA9, 0x1E, 0x0E, 0xCF, 0x9E, 0x8E, 0xFF, 0xA9, 0xA5, 0xB3, 0x87, 0xDC, 0x80, 0x71, 0xA2, 0x4F, 0x21, 0x80, 0xC2, 0x88, 0xC0, 0xA4, 0x99, 0x46, 0x96, 0x25, 0xFB, 0x73, 0x16, 0xCA, 0x97, 0x25, 0x5A, 0x92, 0x19, 0x50, 0xCD, 0xBA, 0xA0, 0x6D, 0xCA, 0x9F, 0x23, 0x14, 0x71, 0x51, 0xB8, 0x94, 0x47, 0xAC, 0xEE, 0x12, 0x53, 0x24, 0x7E, 0xF4, 0xD0, 0xD9, 0x51, 0x89, 0xDA, 0x1C, 0x6F, 0xDE, 0x51, 0x9A, 0xD9, 0xDA, 0xA0, 0xE5, 0xBE };
- Assert ("Capi-1536-Verify", rsa.VerifyHash (hash, sha1OID, sign1536));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign1536), "Capi-1536-Verify");
sign1536[0] = 0x00;
- Assert ("Capi-1536-VerBad", !rsa.VerifyHash (hash, sha1OID, sign1536));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign1536), "Capi-1536-VerBad");
rsa.FromXmlString (CapiXml2048);
byte[] sign2048 = { 0x62, 0xB8, 0xE3, 0xD0, 0x8B, 0x8E, 0x00, 0xFA, 0x59, 0x17, 0xC7, 0x0C, 0x81, 0x76, 0x3A, 0x35, 0xAA, 0xC7, 0xE4, 0xFA, 0x7C, 0x96, 0x9C, 0x88, 0x15, 0x88, 0xA5, 0xA6, 0x7C, 0x95, 0x55, 0xC5, 0xDD, 0xA5, 0x83, 0x25, 0x33, 0xFF, 0xEE, 0x9E, 0xDD, 0xF1, 0xF1, 0x85, 0xB3, 0xEE, 0x78, 0x11, 0xC7, 0x83, 0xA6, 0xD8, 0xB4, 0x34, 0xC4, 0x73, 0x2A, 0xE5, 0xC9, 0x2A, 0x5F, 0x5C, 0xF5, 0xAB, 0xB0, 0xB6, 0xAD, 0x52, 0xB3, 0xBA, 0x31, 0x0E, 0x5A, 0x09, 0xB1, 0x74, 0x90, 0xCC, 0xC7, 0x7C, 0x58, 0x2D, 0x49, 0x9F, 0xDC, 0x6F, 0x03, 0x58, 0xB0, 0x1D, 0xFA, 0x7F, 0xE5, 0x8E, 0x09, 0xAC, 0x17, 0xCF, 0xD8, 0x0F, 0xE0, 0x1F, 0x1B, 0xDD, 0x72, 0xA5, 0xCA, 0x5E, 0x51, 0x2F, 0x52, 0xD9, 0x66, 0xE9, 0xA5, 0x78, 0xCE, 0xE4, 0x73, 0x63, 0xCA, 0xE5, 0x58, 0x30, 0xE9, 0xB9, 0x57, 0x07, 0x56, 0x77, 0x67, 0xFC, 0xBC, 0xE2, 0xF6, 0xAF, 0xD6, 0x5D, 0x02, 0xBB, 0x14, 0x47, 0xD2, 0xDF, 0x12, 0xC8, 0x42, 0xF0, 0xA5, 0x42, 0x3B, 0x90, 0xB3, 0xC8, 0x9D, 0xD7, 0xB6, 0x89, 0x25, 0xDA, 0x7D, 0xC2, 0x53, 0x94, 0x1D, 0x20, 0x8E, 0x2C, 0x96, 0x32, 0x43, 0x4C, 0xE1, 0x20, 0x64, 0xEC, 0x15, 0xC5, 0x44, 0xEE, 0xCB, 0xEC, 0x89, 0xBF, 0x84, 0x1E, 0x93, 0x2B, 0x87, 0xEC, 0xE4, 0x97, 0x66, 0xF8, 0xD7, 0xD5, 0x4B, 0xFF, 0x9D, 0x4B, 0x5E, 0x73, 0xFA, 0x11, 0x50, 0xD5, 0xA0, 0xF3, 0x7C, 0x3D, 0xD8, 0x7B, 0x12, 0x04, 0xE8, 0xB7, 0x27, 0x5A, 0x11, 0xF0, 0x65, 0x33, 0x13, 0xC6, 0xDC, 0xC1, 0xFB, 0xD1, 0x7A, 0x93, 0xCF, 0x1B, 0xFB, 0x12, 0x72, 0xF6, 0xD9, 0x6F, 0x38, 0x0B, 0xFE, 0xBE, 0x4D, 0xE0, 0xF8, 0xEB, 0x21, 0xAE, 0x5D, 0xD2, 0x7C, 0x81, 0x74, 0x0A, 0x47, 0x1E };
- Assert ("Capi-2048-Verify", rsa.VerifyHash (hash, sha1OID, sign2048));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign2048), "Capi-2048-Verify");
sign2048[0] = 0x00;
- Assert ("Capi-2048-VerBad", !rsa.VerifyHash (hash, sha1OID, sign2048));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign2048), "Capi-2048-VerBad");
}
// all keypairs generated by Mono on Windows
rsa = new RSACryptoServiceProvider ();
rsa.FromXmlString (MonoXml384);
- AssertEquals ("Mono-Xml384", MonoXml384, rsa.ToXmlString (true));
+ Assert.AreEqual (MonoXml384, rsa.ToXmlString (true), "Mono-Xml384");
rsa.FromXmlString (MonoXml448);
- AssertEquals ("Mono-Xml448", MonoXml448, rsa.ToXmlString (true));
+ Assert.AreEqual (MonoXml448, rsa.ToXmlString (true), "Mono-Xml448");
rsa.FromXmlString (MonoXml512);
- AssertEquals ("Mono-Xml512", MonoXml512, rsa.ToXmlString (true));
+ Assert.AreEqual (MonoXml512, rsa.ToXmlString (true), "Mono-Xml512");
rsa.FromXmlString (MonoXml576);
- AssertEquals ("Mono-Xml576", MonoXml576, rsa.ToXmlString (true));
+ Assert.AreEqual (MonoXml576, rsa.ToXmlString (true), "Mono-Xml576");
rsa.FromXmlString (MonoXml640);
- AssertEquals ("Mono-Xml640", MonoXml640, rsa.ToXmlString (true));
+ Assert.AreEqual (MonoXml640, rsa.ToXmlString (true), "Mono-Xml640");
rsa.FromXmlString (MonoXml704);
- AssertEquals ("Mono-Xml704", MonoXml704, rsa.ToXmlString (true));
+ Assert.AreEqual (MonoXml704, rsa.ToXmlString (true), "Mono-Xml704");
rsa.FromXmlString (MonoXml768);
- AssertEquals ("Mono-Xml768", MonoXml768, rsa.ToXmlString (true));
+ Assert.AreEqual (MonoXml768, rsa.ToXmlString (true), "Mono-Xml768");
rsa.FromXmlString (MonoXml832);
- AssertEquals ("Mono-Xml832", MonoXml832, rsa.ToXmlString (true));
+ Assert.AreEqual (MonoXml832, rsa.ToXmlString (true), "Mono-Xml832");
rsa.FromXmlString (MonoXml896);
- AssertEquals ("Mono-Xml896", MonoXml896, rsa.ToXmlString (true));
+ Assert.AreEqual (MonoXml896, rsa.ToXmlString (true), "Mono-Xml896");
rsa.FromXmlString (MonoXml960);
- AssertEquals ("Mono-Xml960", MonoXml960, rsa.ToXmlString (true));
+ Assert.AreEqual (MonoXml960, rsa.ToXmlString (true), "Mono-Xml960");
rsa.FromXmlString (MonoXml1024);
- AssertEquals ("Mono-Xml1024", MonoXml1024, rsa.ToXmlString (true));
+ Assert.AreEqual (MonoXml1024, rsa.ToXmlString (true), "Mono-Xml1024");
rsa.FromXmlString (MonoXml1536);
- AssertEquals ("Mono-Xml1536", MonoXml1536, rsa.ToXmlString (true));
+ Assert.AreEqual (MonoXml1536, rsa.ToXmlString (true), "Mono-Xml1536");
rsa.FromXmlString (MonoXml2048);
- AssertEquals ("Mono-Xml2048", MonoXml2048, rsa.ToXmlString (true));
+ Assert.AreEqual (MonoXml2048, rsa.ToXmlString (true), "Mono-Xml2048");
}
[Test]
rsa.ToXmlString (true);
}
+ [Test]
+ [ExpectedException (typeof (CryptographicException))]
+ public void ExportWithoutCRT_2 ()
+ {
+ try {
+ rsa = new RSACryptoServiceProvider ();
+ rsa.FromXmlString (MonoXml384woCRT);
+ }
+ catch {
+ }
+ // exception is HERE!
+ rsa.ExportParameters (true);
+ }
+
// Validate that we can sign with every keypair and verify the signature
// With Windows this means that we can use Mono keypairs to sign and verify.
// For Mono this doesn't mean much.
rsa.FromXmlString (MonoXml384);
byte[] sign384 = { 0x6B, 0xEF, 0x8A, 0x2E, 0x2E, 0xD5, 0xB6, 0x19, 0x2D, 0x9C, 0x48, 0x75, 0xA8, 0x54, 0xAD, 0x61, 0xD1, 0xCC, 0xF3, 0x9A, 0x3E, 0x4E, 0xE2, 0xF1, 0x44, 0x1D, 0xC4, 0x3A, 0x30, 0xF4, 0x9B, 0x2D, 0x88, 0xA7, 0xB8, 0xEC, 0x2D, 0x17, 0x4E, 0x66, 0x6C, 0x4C, 0x5A, 0xB5, 0x44, 0x4B, 0xAF, 0x06 };
- Assert ("Mono-384-Verify", rsa.VerifyHash (hash, sha1OID, sign384));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign384), "Mono-384-Verify");
sign384[0] = 0x00;
- Assert ("Mono-384-VerBad", !rsa.VerifyHash (hash, sha1OID, sign384));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign384), "Mono-384-VerBad");
rsa.FromXmlString (MonoXml448);
byte[] sign448 = { 0x9F, 0x62, 0xDF, 0xD4, 0x8B, 0x3E, 0x85, 0xEC, 0xF9, 0xF2, 0x17, 0x1C, 0x2B, 0x18, 0x37, 0xDA, 0xCA, 0x74, 0x5F, 0x85, 0x70, 0x41, 0x44, 0xB3, 0xE5, 0xA3, 0xC8, 0xC7, 0x37, 0x9E, 0x52, 0x16, 0x18, 0x2C, 0xE3, 0x87, 0x1A, 0x34, 0x13, 0x4A, 0x5D, 0xBB, 0x79, 0x27, 0x1C, 0x2A, 0xD2, 0x96, 0x79, 0xC4, 0x26, 0x51, 0x1B, 0x24, 0x12, 0xBC };
- Assert ("Mono-448-Verify", rsa.VerifyHash (hash, sha1OID, sign448));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign448), "Mono-448-Verify");
sign448[0] = 0x00;
- Assert ("Mono-448-VerBad", !rsa.VerifyHash (hash, sha1OID, sign448));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign448), "Mono-448-VerBad");
rsa.FromXmlString (MonoXml512);
byte[] sign512 = { 0x33, 0xBB, 0x7E, 0x0B, 0xC0, 0xB2, 0x9A, 0xC2, 0x2F, 0xF4, 0xBE, 0x1B, 0xDF, 0xD6, 0x79, 0xC1, 0x38, 0x47, 0xEA, 0x05, 0xB2, 0xC0, 0xFA, 0xF8, 0xC9, 0xDC, 0x6D, 0x56, 0xBF, 0xD3, 0xBF, 0xAA, 0xB8, 0x1E, 0x74, 0xE4, 0xF3, 0x38, 0x45, 0xA9, 0x34, 0xD1, 0x5C, 0x0D, 0x0F, 0x56, 0x70, 0x0C, 0x93, 0x6B, 0xD6, 0x80, 0x17, 0xAD, 0x80, 0xF9, 0xD8, 0xFD, 0x1E, 0x6F, 0xF3, 0x5C, 0xB2, 0x78 };
- Assert ("Mono-512-Verify", rsa.VerifyHash (hash, sha1OID, sign512));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign512), "Mono-512-Verify");
sign512[0] = 0x00;
- Assert ("Mono-512-VerBad", !rsa.VerifyHash (hash, sha1OID, sign512));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign512), "Mono-512-VerBad");
rsa.FromXmlString (MonoXml576);
byte[] sign576 = { 0x61, 0x8C, 0xD0, 0xE3, 0x63, 0x95, 0x7C, 0xB6, 0xD8, 0x84, 0x4D, 0xD1, 0x04, 0xDF, 0x1F, 0x4A, 0xCF, 0x69, 0x95, 0x7B, 0x69, 0x8E, 0x09, 0x2A, 0x0F, 0x1B, 0x23, 0xA7, 0x20, 0x31, 0x95, 0x93, 0xD1, 0x67, 0xBC, 0x27, 0x80, 0x41, 0x60, 0xD1, 0xFE, 0x62, 0xB2, 0x17, 0xC9, 0x57, 0x4F, 0x03, 0x40, 0xDB, 0xB3, 0x7E, 0xD2, 0x0C, 0xEA, 0x7D, 0x72, 0x76, 0x64, 0x4F, 0x51, 0x79, 0x43, 0xCC, 0x8F, 0x36, 0x1E, 0x81, 0x43, 0x20, 0xB9, 0xAD };
- Assert ("Mono-576-Verify", rsa.VerifyHash (hash, sha1OID, sign576));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign576), "Mono-576-Verify");
sign576[0] = 0x00;
- Assert ("Mono-576-VerBad", !rsa.VerifyHash (hash, sha1OID, sign576));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign576), "Mono-576-VerBad");
rsa.FromXmlString (MonoXml640);
byte[] sign640 = { 0x4A, 0x6A, 0xED, 0xEC, 0x96, 0x9C, 0x89, 0xD1, 0x41, 0x2E, 0x16, 0x0D, 0xBA, 0xB0, 0x48, 0x92, 0xF9, 0xA6, 0x33, 0x26, 0x0D, 0x6C, 0x99, 0xA9, 0x4E, 0x3B, 0x68, 0x82, 0xAB, 0x94, 0x33, 0x89, 0xEC, 0x8A, 0xCC, 0x32, 0xDD, 0x45, 0x9C, 0x16, 0x5E, 0xCE, 0x5F, 0xF3, 0xDC, 0x5F, 0x09, 0xC7, 0x69, 0xC7, 0xEA, 0x74, 0xAB, 0x79, 0xA7, 0x55, 0xD9, 0xF8, 0xDF, 0x8F, 0x8C, 0x9A, 0xBA, 0xA9, 0x56, 0x86, 0x96, 0x64, 0xE9, 0xC0, 0x21, 0x8C, 0x34, 0x91, 0x31, 0xC2, 0x80, 0xC7, 0x47, 0x6F };
- Assert ("Mono-640-Verify", rsa.VerifyHash (hash, sha1OID, sign640));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign640), "Mono-640-Verify");
sign640[0] = 0x00;
- Assert ("Mono-640-VerBad", !rsa.VerifyHash (hash, sha1OID, sign640));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign640), "Mono-640-VerBad");
rsa.FromXmlString (MonoXml704);
byte[] sign704 = { 0x94, 0xC5, 0x45, 0xCD, 0x9C, 0xA9, 0xBC, 0xDF, 0x9D, 0x04, 0xCE, 0xFD, 0x21, 0xEB, 0x3F, 0xBE, 0x32, 0x56, 0xC3, 0x6B, 0xEF, 0x4E, 0x8F, 0xA9, 0x02, 0x14, 0xC4, 0xF1, 0xFA, 0x9B, 0x35, 0xFE, 0x36, 0x34, 0x03, 0x31, 0xC1, 0xC8, 0xBF, 0xA1, 0x41, 0x03, 0xCB, 0xE1, 0xB9, 0x81, 0x76, 0x60, 0xC9, 0xD1, 0xB4, 0x04, 0x98, 0xA5, 0xDF, 0x4F, 0x37, 0x60, 0xB8, 0x15, 0xF8, 0x22, 0xB7, 0x54, 0x32, 0x87, 0x19, 0x9B, 0xB9, 0xDF, 0xB9, 0x2D, 0x25, 0xA2, 0xAF, 0x04, 0xC1, 0xE0, 0xF0, 0x0B, 0xF2, 0xCC, 0x0E, 0x1F, 0x40, 0xF6, 0x5C, 0xCD };
- Assert ("Mono-704-Verify", rsa.VerifyHash (hash, sha1OID, sign704));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign704), "Mono-704-Verify");
sign704[0] = 0x00;
- Assert ("Mono-704-VerBad", !rsa.VerifyHash (hash, sha1OID, sign704));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign704), "Mono-704-VerBad");
rsa.FromXmlString (MonoXml768);
byte[] sign768 = { 0x28, 0x99, 0xE0, 0xD2, 0xCF, 0xD3, 0x2B, 0x1B, 0xA2, 0x06, 0xC5, 0x17, 0x86, 0x07, 0xC8, 0x49, 0x77, 0x33, 0xEC, 0xFE, 0xC9, 0x15, 0x99, 0x90, 0x4C, 0x6C, 0xED, 0x2C, 0x32, 0xF8, 0xAB, 0x0A, 0xB6, 0xEB, 0x15, 0x08, 0x4A, 0xC1, 0xDD, 0xAD, 0x88, 0x47, 0xAD, 0x3D, 0xA2, 0x4B, 0x94, 0x7E, 0x37, 0x1F, 0x33, 0xFC, 0xC3, 0xFE, 0xC2, 0x27, 0x45, 0x74, 0x8E, 0x3C, 0xC8, 0x68, 0x8C, 0xF4, 0x77, 0xCC, 0xD0, 0x79, 0x37, 0x7E, 0x26, 0x1B, 0xDE, 0xBF, 0x16, 0x3E, 0xAE, 0xB9, 0xEB, 0xA0, 0x00, 0xCE, 0x51, 0x8A, 0x69, 0x12, 0xF5, 0xBE, 0x39, 0x1C, 0x0F, 0x0F, 0xD8, 0x13, 0xDD, 0x6B };
- Assert ("Mono-768-Verify", rsa.VerifyHash (hash, sha1OID, sign768));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign768), "Mono-768-Verify");
sign768[0] = 0x00;
- Assert ("Mono-768-VerBad", !rsa.VerifyHash (hash, sha1OID, sign768));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign768), "Mono-768-VerBad");
rsa.FromXmlString (MonoXml832);
byte[] sign832 = { 0x8D, 0x56, 0xB2, 0x3C, 0x45, 0x47, 0xB8, 0x6F, 0x56, 0x7D, 0x85, 0x4F, 0x3C, 0x14, 0xAC, 0x61, 0x08, 0x8C, 0x6A, 0xF3, 0xAF, 0xCA, 0x65, 0xCC, 0xC3, 0x6F, 0x53, 0x6F, 0x84, 0xC1, 0x9F, 0xFD, 0x66, 0x83, 0xA1, 0x3B, 0xFF, 0x61, 0x41, 0xDB, 0x2C, 0xE5, 0xD5, 0x13, 0x3E, 0x15, 0x7A, 0xBD, 0x1F, 0x44, 0x4C, 0x4F, 0x10, 0xB7, 0x4A, 0x4B, 0x9D, 0xD1, 0xF5, 0xC2, 0x4E, 0x4D, 0xC8, 0xF9, 0x51, 0xC9, 0xF3, 0x04, 0x69, 0x02, 0xAE, 0x7E, 0xC3, 0x76, 0x56, 0x08, 0x8E, 0xF7, 0xA1, 0x25, 0x1B, 0x97, 0x65, 0x8E, 0x3A, 0x98, 0x52, 0xDB, 0x3E, 0xF4, 0x59, 0x5F, 0xEE, 0x6D, 0x78, 0x22, 0x37, 0x2E, 0x79, 0x69, 0x6D, 0x8F, 0xF9, 0xDF };
- Assert ("Mono-832-Verify", rsa.VerifyHash (hash, sha1OID, sign832));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign832), "Mono-832-Verify");
sign832[0] = 0x00;
- Assert ("Mono-832-VerBad", !rsa.VerifyHash (hash, sha1OID, sign832));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign832), "Mono-832-VerBad");
rsa.FromXmlString (MonoXml896);
byte[] sign896 = { 0xAB, 0xD9, 0xE4, 0x5C, 0xAB, 0xF7, 0xE1, 0x06, 0x7F, 0x0C, 0xD6, 0x03, 0xB5, 0xA1, 0xDB, 0x22, 0x3E, 0x85, 0xBE, 0xCD, 0x54, 0x12, 0xD5, 0x11, 0x71, 0xCC, 0xEE, 0x71, 0x4B, 0xA8, 0xB5, 0xAE, 0x04, 0x82, 0x78, 0x72, 0xE8, 0x7B, 0x77, 0x42, 0x58, 0x14, 0xA3, 0xF0, 0xFC, 0xE9, 0x15, 0x98, 0x2E, 0x34, 0x57, 0xAA, 0x95, 0x6F, 0x2E, 0x9B, 0x5B, 0x88, 0xF0, 0x51, 0x26, 0x35, 0x1F, 0x0C, 0x59, 0x51, 0x73, 0x0E, 0xD3, 0x5D, 0x02, 0xAD, 0xB7, 0x1C, 0x94, 0x57, 0x1E, 0xA6, 0x01, 0x19, 0x73, 0x29, 0xBE, 0xDF, 0x77, 0xF2, 0x13, 0x28, 0xBD, 0x50, 0x89, 0x39, 0x6A, 0x1B, 0xEF, 0x66, 0x29, 0x71, 0x55, 0x44, 0x3A, 0x36, 0x89, 0xC1, 0xFE, 0x25, 0x32, 0x9F, 0x65, 0x76, 0xEA, 0x71 };
- Assert ("Mono-896-Verify", rsa.VerifyHash (hash, sha1OID, sign896));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign896), "Mono-896-Verify");
sign896[0] = 0x00;
- Assert ("Mono-896-VerBad", !rsa.VerifyHash (hash, sha1OID, sign896));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign896), "Mono-896-VerBad");
rsa.FromXmlString (MonoXml960);
byte[] sign960 = { 0x7A, 0x13, 0x06, 0xF1, 0xB5, 0x14, 0x78, 0x33, 0xA6, 0x14, 0x40, 0xDC, 0x22, 0xB6, 0xF3, 0xBB, 0xDC, 0xCD, 0x53, 0xAF, 0x05, 0xC5, 0x84, 0x0C, 0xD2, 0x15, 0x5A, 0x04, 0xFC, 0x30, 0x57, 0x64, 0xF4, 0x8B, 0xD6, 0x5D, 0x5B, 0x3D, 0xFC, 0x82, 0x6B, 0xB9, 0xE4, 0xB9, 0x56, 0xB3, 0xCF, 0x2A, 0x6D, 0x14, 0x83, 0x31, 0x9E, 0xFD, 0x55, 0x4B, 0x2C, 0xBD, 0x5A, 0xA8, 0xAC, 0xD6, 0x5D, 0xFA, 0x58, 0xF8, 0x3E, 0x60, 0x32, 0x11, 0xA4, 0x09, 0xC2, 0x01, 0xE7, 0x14, 0xEF, 0xBA, 0x51, 0x57, 0x86, 0xA5, 0x86, 0x28, 0x63, 0x68, 0x33, 0xBF, 0x34, 0xF9, 0x1D, 0x36, 0xC3, 0x6E, 0xCF, 0x97, 0xA5, 0x19, 0xB4, 0x5F, 0x7B, 0x70, 0xB0, 0x72, 0xF2, 0xF2, 0xFF, 0x05, 0xB7, 0x31, 0x5A, 0x5D, 0xC6, 0x88, 0x88, 0x21, 0x97, 0x40, 0x0E, 0x0E };
- Assert ("Mono-960-Verify", rsa.VerifyHash (hash, sha1OID, sign960));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign960), "Mono-960-Verify");
sign960[0] = 0x00;
- Assert ("Mono-960-VerBad", !rsa.VerifyHash (hash, sha1OID, sign960));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign960), "Mono-960-VerBad");
rsa.FromXmlString (MonoXml1024);
byte[] sign1024 = { 0x26, 0x98, 0x40, 0x5F, 0x30, 0x4E, 0x90, 0x20, 0x32, 0x10, 0x64, 0xCF, 0x03, 0xA8, 0x1E, 0x53, 0x20, 0x19, 0x59, 0xCB, 0x08, 0x5F, 0x8D, 0x45, 0x51, 0xEE, 0xDD, 0x71, 0x2E, 0x21, 0x86, 0xB0, 0xC6, 0xE2, 0x6F, 0x2A, 0xF2, 0x8E, 0xBD, 0xDE, 0xAD, 0xA0, 0x56, 0x7E, 0xED, 0x38, 0x4F, 0x8D, 0x3A, 0xC6, 0x8A, 0x15, 0x34, 0x71, 0xDE, 0xC5, 0x60, 0x32, 0x95, 0x38, 0xD7, 0x69, 0x0F, 0x3B, 0xDF, 0xF8, 0x4C, 0x2D, 0x83, 0x58, 0x7E, 0x36, 0x4B, 0x10, 0x4A, 0x8B, 0x23, 0x70, 0x09, 0xBE, 0xCF, 0x02, 0x2E, 0x97, 0xC4, 0x0F, 0x94, 0x42, 0x0B, 0xFA, 0x1F, 0x16, 0x97, 0x25, 0x1C, 0x14, 0x2B, 0x82, 0xD0, 0x7A, 0xC1, 0x2C, 0x2F, 0x72, 0x9C, 0xD9, 0xEE, 0x90, 0x2F, 0x5B, 0xC5, 0xB1, 0x34, 0x73, 0x10, 0xEC, 0x79, 0x97, 0x9A, 0xDA, 0xE2, 0xB4, 0xAE, 0x99, 0xE9, 0xA2, 0xFF, 0xC6 };
- Assert ("Mono-1024-Verify", rsa.VerifyHash (hash, sha1OID, sign1024));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign1024), "Mono-1024-Verify");
sign1024[0] = 0x00;
- Assert ("Mono-1024-VerBad", !rsa.VerifyHash (hash, sha1OID, sign1024));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign1024), "Mono-1024-VerBad");
rsa.FromXmlString (MonoXml1536);
byte[] sign1536 = { 0x33, 0xE2, 0xA4, 0xCE, 0x18, 0xE6, 0xF3, 0x46, 0x0E, 0x32, 0xD1, 0xA6, 0x8A, 0xC3, 0xCA, 0x4B, 0x36, 0x4E, 0x4C, 0xAE, 0x39, 0x95, 0x5A, 0x05, 0x37, 0xBA, 0x0F, 0x19, 0xDC, 0x94, 0x6A, 0x78, 0xDA, 0xEA, 0xF0, 0xA2, 0x80, 0x47, 0xD5, 0xB9, 0xC3, 0x53, 0xC9, 0xDA, 0x0B, 0x29, 0xCA, 0x61, 0x37, 0x7C, 0xD5, 0x5D, 0x99, 0x58, 0xAD, 0x0F, 0xA8, 0xEF, 0x17, 0xFD, 0xA8, 0x55, 0x79, 0xEF, 0x07, 0xD1, 0x63, 0xE0, 0x2C, 0xEF, 0x14, 0x42, 0x72, 0x2D, 0x71, 0xA3, 0xBB, 0x29, 0x87, 0xF8, 0xCC, 0xFB, 0x70, 0xCC, 0x13, 0x70, 0x24, 0xC3, 0x2A, 0x2B, 0xD2, 0x1C, 0x34, 0xD7, 0x85, 0xBC, 0xA4, 0x4E, 0x7B, 0x7E, 0x1C, 0x5B, 0x03, 0x06, 0xB2, 0x01, 0xBF, 0x73, 0x30, 0x77, 0xEB, 0x03, 0x17, 0x24, 0xFE, 0x46, 0xC7, 0x9B, 0xEB, 0x75, 0xF6, 0x56, 0x43, 0x1E, 0x0D, 0x56, 0x05, 0x37, 0x78, 0xB3, 0x76, 0x93, 0x76, 0xFA, 0x73, 0xCD, 0xE5, 0xB1, 0x3C, 0x60, 0xB7, 0xCC, 0x1E, 0x98, 0x89, 0xD8, 0xB4, 0x0A, 0xD3, 0x52, 0xCD, 0xEF, 0xC1, 0xBE, 0xFC, 0xA8, 0x2C, 0xE6, 0x01, 0xD3, 0xB3, 0x05, 0x5C, 0x12, 0x48, 0xD8, 0x20, 0xF9, 0x3B, 0xAD, 0x97, 0xD4, 0xD1, 0x13, 0xD6, 0xA5, 0x31, 0x4E, 0x52, 0x13, 0xBD, 0x5C, 0x00, 0x5C, 0x2A, 0x86, 0xFC, 0x98, 0x8B, 0x93, 0xAE, 0x5A };
- Assert ("Mono-1536-Verify", rsa.VerifyHash (hash, sha1OID, sign1536));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign1536), "Mono-1536-Verify");
sign1536[0] = 0x00;
- Assert ("Mono-1536-VerBad", !rsa.VerifyHash (hash, sha1OID, sign1536));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign1536), "Mono-1536-VerBad");
rsa.FromXmlString (MonoXml2048);
byte[] sign2048 = { 0xA5, 0x70, 0x6B, 0x3C, 0x5E, 0x5D, 0x49, 0x7C, 0xCB, 0xEE, 0xE3, 0x23, 0xF5, 0xD7, 0xEE, 0xF3, 0xA8, 0x8A, 0xED, 0x47, 0x5F, 0x2A, 0x03, 0x72, 0x41, 0x02, 0x1E, 0x5D, 0x93, 0x3B, 0x27, 0x4B, 0x2D, 0x7A, 0x21, 0x50, 0x7B, 0xDC, 0xFB, 0x0F, 0xCB, 0xEB, 0x8E, 0xB5, 0x4C, 0x44, 0x90, 0x39, 0xF0, 0xCB, 0x4A, 0x5E, 0xD7, 0x67, 0x5C, 0x46, 0xC3, 0x3C, 0x94, 0xDC, 0x33, 0x36, 0x36, 0xA5, 0xF3, 0xCE, 0x1F, 0xA7, 0x8F, 0x79, 0xB8, 0x60, 0x94, 0x0F, 0x7A, 0x87, 0x18, 0x12, 0xCD, 0x21, 0x54, 0x05, 0x53, 0xA0, 0x88, 0x1F, 0x61, 0x1F, 0xAB, 0xEC, 0x6D, 0xCF, 0x10, 0xE0, 0x8D, 0x14, 0x5C, 0x6A, 0x46, 0x8C, 0xB9, 0xB6, 0x52, 0x38, 0x1F, 0xAE, 0xF1, 0xB8, 0xB5, 0x9B, 0x3C, 0xE1, 0x6E, 0xBE, 0x21, 0x1B, 0x01, 0x1E, 0xD9, 0x1E, 0x97, 0x78, 0x47, 0xC9, 0x86, 0xC4, 0xE7, 0x58, 0xF8, 0xEB, 0xAC, 0x22, 0x38, 0xD4, 0x2A, 0xE8, 0x1B, 0x40, 0x5F, 0xAF, 0x35, 0xFA, 0x13, 0x30, 0x0E, 0x5C, 0x4C, 0xF5, 0xF1, 0xB3, 0x31, 0x6C, 0x1D, 0x96, 0xFD, 0xAB, 0xC4, 0x0E, 0x16, 0x0A, 0xF9, 0x28, 0x49, 0x59, 0xF1, 0xB6, 0x35, 0x2D, 0x21, 0x69, 0x4F, 0xD0, 0x5B, 0xB7, 0x7E, 0xC3, 0x00, 0xC7, 0xDA, 0x56, 0x48, 0xA0, 0x93, 0x05, 0xB4, 0x6D, 0xEE, 0x2D, 0x6A, 0x60, 0xF6, 0x91, 0x7C, 0xDB, 0xD8, 0xC3, 0xFD, 0x33, 0xBC, 0xC9, 0x68, 0x73, 0xC6, 0x64, 0x49, 0x80, 0x3C, 0xD5, 0x4A, 0xE1, 0x28, 0x5F, 0xE9, 0x2A, 0xA7, 0x1B, 0xA6, 0x38, 0x2A, 0xAE, 0x0A, 0xA8, 0xCC, 0x96, 0x9A, 0xEA, 0xE5, 0xAD, 0xB4, 0xD8, 0x70, 0x2F, 0xFA, 0xAD, 0x17, 0x03, 0x4D, 0xDA, 0x2E, 0x1B, 0x4D, 0x88, 0x82, 0x3E, 0x04, 0x6A, 0xAF, 0x38, 0xC1, 0x4F, 0x1B, 0x9D, 0x07, 0x1A, 0x67, 0x6A };
- Assert ("Mono-2048-Verify", rsa.VerifyHash (hash, sha1OID, sign2048));
+ Assert.IsTrue (rsa.VerifyHash (hash, sha1OID, sign2048), "Mono-2048-Verify");
sign2048[0] = 0x00;
- Assert ("Mono-2048-VerBad", !rsa.VerifyHash (hash, sha1OID, sign2048));
+ Assert.IsFalse (rsa.VerifyHash (hash, sha1OID, sign2048), "Mono-2048-VerBad");
}
// Key Pair Persistence Tests
// http://msdn.microsoft.com/library/en-us/cpguide/html/cpcongeneratingkeysforencryptiondecryption.asp
[Test]
- [Category ("TargetJvmNotSupported")]
public void Persistence_PersistKeyInCsp_False ()
{
CspParameters csp = new CspParameters (1, null, "Persistence_PersistKeyInCsp_False");
string first = rsa1.ToXmlString (true);
// persistance is "on" by default when a CspParameters is supplied
- Assert ("PersistKeyInCsp", rsa1.PersistKeyInCsp);
+ Assert.IsTrue (rsa1.PersistKeyInCsp, "PersistKeyInCsp");
// this means nothing if we don't call Clear !!!
rsa1.PersistKeyInCsp = false;
- Assert ("PersistKeyInCsp", !rsa1.PersistKeyInCsp);
+ Assert.IsFalse (rsa1.PersistKeyInCsp, "PersistKeyInCsp");
// reload using the same container name
RSACryptoServiceProvider rsa2 = new RSACryptoServiceProvider (minKeySize, csp);
string second = rsa2.ToXmlString (true);
- AssertEquals ("Key Pair Same Container", first, second);
+ Assert.AreEqual (first, second, "Key Pair Same Container");
}
[Test]
- [Category ("TargetJvmNotSupported")]
public void Persistence_PersistKeyInCsp_True ()
{
CspParameters csp = new CspParameters (1, null, "Persistence_PersistKeyInCsp_True");
string first = rsa1.ToXmlString (true);
// persistance is "on" by default
- Assert ("PersistKeyInCsp", rsa1.PersistKeyInCsp);
+ Assert.IsTrue (rsa1.PersistKeyInCsp, "PersistKeyInCsp");
// reload using the same container name
RSACryptoServiceProvider rsa2 = new RSACryptoServiceProvider (minKeySize, csp);
string second = rsa2.ToXmlString (true);
- AssertEquals ("Key Pair Same Container", first, second);
+ Assert.AreEqual (first, second, "Key Pair Same Container");
}
[Test]
- [Category ("TargetJvmNotSupported")]
public void Persistence_Delete ()
{
CspParameters csp = new CspParameters (1, null, "Persistence_Delete");
RSACryptoServiceProvider rsa2 = new RSACryptoServiceProvider (minKeySize, csp);
string newKeyPair = rsa2.ToXmlString (true);
- Assert ("Key Pair Deleted", (original != newKeyPair));
+ Assert.IsTrue ((original != newKeyPair), "Key Pair Deleted");
}
-#if NET_1_1
[Test]
public void UseMachineKeyStore_Default ()
{
- Assert ("UseMachineKeyStore(Default)", !RSACryptoServiceProvider.UseMachineKeyStore);
+ Assert.IsFalse (RSACryptoServiceProvider.UseMachineKeyStore, "UseMachineKeyStore(Default)");
}
[Test]
- [Category ("TargetJvmNotSupported")]
public void UseMachineKeyStore ()
{
// note only applicable when CspParameters isn't used - which don't
csp.Flags |= CspProviderFlags.UseMachineKeyStore;
rsa = new RSACryptoServiceProvider (csp);
- Assert ("UseMachineKeyStore", machineKeyPair != rsa.ToXmlString (true));
+ Assert.IsTrue (machineKeyPair != rsa.ToXmlString (true), "UseMachineKeyStore");
}
catch (CryptographicException ce) {
// only root can create the required directory (if inexistant)
catch (UnauthorizedAccessException) {
}
}
-#endif
[Test]
public void PKCS1 ()
rsa = new RSACryptoServiceProvider (minKeySize);
byte[] encdata = rsa.Encrypt (data, false);
byte[] decdata = rsa.Decrypt (encdata, false);
- AssertEquals ("PKCS1", BitConverter.ToString (data), BitConverter.ToString (decdata));
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (decdata), "PKCS1");
}
[Test]
try {
byte[] encdata = rsa.Encrypt (data, true);
byte[] decdata = rsa.Decrypt (encdata, true);
- AssertEquals ("PKCS1", BitConverter.ToString (data), BitConverter.ToString (decdata));
+ Assert.AreEqual (BitConverter.ToString (data), BitConverter.ToString (decdata), "PKCS1");
}
catch (CryptographicException) {
// will fail on MS runtime before Windows XP
{
rsa = new RSACryptoServiceProvider ();
rsa.FromXmlString ("<RSAKeyValue><Modulus>iSObDmmhDgrl4NiLaviFcpv4NdysBWJcqiVz3AQbPdajtXaQQ8VJdfRkixah132yKOFGCWZhHS3EuPMh8dcNwGwta2nh+m2IV6ktzI4+mZ7CSNAsmlDY0JI+H8At1vKvNArlC5jkVGuliYroJeSU/NLPLNYgspi7TtXGy9Rfug8=</Modulus><Exponent>EQ==</Exponent></RSAKeyValue>");
-#if NET_2_0
- Assert ("PublicOnly", rsa.PublicOnly);
-#endif
+ Assert.IsTrue (rsa.PublicOnly, "PublicOnly");
string b64 = @"YgyAhscnTTIcDeLJTZcOYYyHVxNhV6d03jeZYjq0sPMEsfCCbE/NcFyYHD9BTuiduqPplCLbGpfZIZYJ6vAP9m5z4Q9eEw79kmEFCsm8wSKEo/gKiptVpwQ78VOPrWd/wEkTTeeg2nVim3JIsTKGFlV7rKxIWQhGN9aAqgP8nZI=";
byte [] bytes = Convert.FromBase64String (b64);
rsa.Decrypt (bytes, true);
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>");
- AssertNotNull (r.Decrypt (bytes, true));
+ Assert.IsNotNull (r.Decrypt (bytes, true));
}
[Test]
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>");
- AssertNotNull (r.Decrypt (bytes, true));
+ Assert.IsNotNull (r.Decrypt (bytes, true));
}
-#if NET_2_0
+#if !MOBILE
[Test]
[Category ("NotWorking")]
public void CspKeyContainerInfo_NewKeypair ()
{
rsa = new RSACryptoServiceProvider (minKeySize);
CspKeyContainerInfo info = rsa.CspKeyContainerInfo;
- Assert ("Accessible", info.Accessible);
+ Assert.IsTrue (info.Accessible, "Accessible");
// FIXME AssertNotNull ("CryptoKeySecurity", info.CryptoKeySecurity);
- Assert ("Exportable", info.Exportable);
- Assert ("HardwareDevice", !info.HardwareDevice);
- AssertNotNull ("KeyContainerName", info.KeyContainerName);
- AssertEquals ("KeyNumber", KeyNumber.Exchange, info.KeyNumber);
- Assert ("MachineKeyStore", !info.MachineKeyStore);
- Assert ("Protected", !info.Protected);
- Assert ("RandomlyGenerated", info.RandomlyGenerated);
- Assert ("Removable", !info.Removable);
- AssertNotNull ("UniqueKeyContainerName", info.UniqueKeyContainerName);
+ Assert.IsTrue (info.Exportable, "Exportable");
+ Assert.IsFalse (info.HardwareDevice, "HardwareDevice");
+ Assert.IsNotNull (info.KeyContainerName, "KeyContainerName");
+ Assert.AreEqual (KeyNumber.Exchange, info.KeyNumber, "KeyNumber");
+ Assert.IsFalse (info.MachineKeyStore, "MachineKeyStore");
+ Assert.IsFalse (info.Protected, "Protected");
+ Assert.IsTrue (info.RandomlyGenerated, "RandomlyGenerated");
+ Assert.IsFalse (info.Removable, "Removable");
+ Assert.IsNotNull (info.UniqueKeyContainerName, "UniqueKeyContainerName");
}
[Test]
RSAParameters rsap = AllTests.GetRsaKey (true);
rsa.ImportParameters (rsap);
CspKeyContainerInfo info = rsa.CspKeyContainerInfo;
- Assert ("Accessible", info.Accessible);
+ Assert.IsTrue (info.Accessible, "Accessible");
// FIXME AssertNotNull ("CryptoKeySecurity", info.CryptoKeySecurity);
- Assert ("Exportable", info.Exportable);
- Assert ("HardwareDevice", !info.HardwareDevice);
- AssertNotNull ("KeyContainerName", info.KeyContainerName);
- AssertEquals ("KeyNumber", KeyNumber.Exchange, info.KeyNumber);
- Assert ("MachineKeyStore", !info.MachineKeyStore);
- Assert ("Protected", !info.Protected);
- Assert ("RandomlyGenerated", info.RandomlyGenerated);
- Assert ("Removable", !info.Removable);
- AssertNotNull ("UniqueKeyContainerName", info.UniqueKeyContainerName);
+ Assert.IsTrue (info.Exportable, "Exportable");
+ Assert.IsFalse (info.HardwareDevice, "HardwareDevice");
+ Assert.IsNotNull (info.KeyContainerName, "KeyContainerName");
+ Assert.AreEqual (KeyNumber.Exchange, info.KeyNumber, "KeyNumber");
+ Assert.IsFalse (info.MachineKeyStore, "MachineKeyStore");
+ Assert.IsFalse (info.Protected, "Protected");
+ Assert.IsTrue (info.RandomlyGenerated, "RandomlyGenerated");
+ Assert.IsFalse (info.Removable, "Removable");
+ Assert.IsNotNull (info.UniqueKeyContainerName, "UniqueKeyContainerName");
}
[Test]
RSAParameters rsap = AllTests.GetRsaKey (false);
rsa.ImportParameters (rsap);
CspKeyContainerInfo info = rsa.CspKeyContainerInfo;
- Assert ("Accessible", !info.Accessible);
+ Assert.IsFalse (info.Accessible, "Accessible");
// info.CryptoKeySecurity throws a CryptographicException at this stage
// info.Exportable throws a CryptographicException at this stage
- Assert ("HardwareDevice", !info.HardwareDevice);
- AssertNotNull ("KeyContainerName", info.KeyContainerName);
- AssertEquals ("KeyNumber", KeyNumber.Exchange, info.KeyNumber);
- Assert ("MachineKeyStore", !info.MachineKeyStore);
+ Assert.IsFalse (info.HardwareDevice, "HardwareDevice");
+ Assert.IsNotNull (info.KeyContainerName, "KeyContainerName");
+ Assert.AreEqual (KeyNumber.Exchange, info.KeyNumber, "KeyNumber");
+ Assert.IsFalse (info.MachineKeyStore, "MachineKeyStore");
// info.Protected throws a CryptographicException at this stage
- Assert ("RandomlyGenerated", info.RandomlyGenerated);
- Assert ("Removable", !info.Removable);
+ Assert.IsTrue (info.RandomlyGenerated, "RandomlyGenerated");
+ Assert.IsFalse (info.Removable, "Removable");
// info.UniqueKeyContainerName throws a CryptographicException at this stage
}
-
+#endif
[Test]
public void ExportCspBlob_Full ()
{
rsa.ImportParameters (rsap);
byte[] keypair = rsa.ExportCspBlob (true);
- AssertEquals ("07-02-00-00-00-A4-00-00-52-53-41-32-00-04-00-00-11-00-00-00-CB-BD-1D-09-FD-E5-F8-46-59-8F-2A-CA-98-72-53-E2-7F-68-C1-F6-41-9A-7A-52-1F-A5-61-7B-2D-B1-AA-E0-4E-39-98-45-45-B2-34-88-74-53-09-06-9D-64-6A-EE-84-25-3A-D9-B7-B4-E6-3E-72-37-C7-DF-A3-E0-B8-AF-7F-80-8B-5B-8A-9D-71-19-46-EC-E1-60-0D-52-ED-76-48-CD-6F-EB-CE-48-EA-61-AB-02-5C-03-AF-BA-DF-B8-1F-F5-54-74-F0-B6-D6-40-A4-43-10-D4-EE-07-8D-36-F7-71-A8-9D-2B-AC-38-23-9C-CE-82-06-09-2F-F8-BB-99-65-FB-58-2A-BA-41-75-39-1F-9D-45-76-21-25-5B-2D-0A-04-AA-E7-FA-28-7E-3B-1E-5D-6E-23-F0-4E-12-32-F6-84-3D-9E-1A-B8-93-A4-FD-F4-AE-44-9F-EB-99-01-60-B5-A1-10-0B-81-08-C9-B3-B9-B1-81-AE-CF-EE-03-15-46-AF-00-E7-41-A4-A5-16-04-4D-52-52-33-CE-CF-B5-04-32-B4-A3-0D-EA-92-2E-B4-66-16-B4-40-98-86-9D-8B-02-35-20-0F-5A-D0-B1-66-88-D0-42-6C-3F-35-D9-D1-AA-EA-33-12-34-F6-53-F4-27-F0-B1-7F-C9-81-C9-67-1F-3C-C9-AD-74-41-47-0A-91-FC-38-2B-20-2E-9A-2E-69-F7-C1-59-FF-14-74-B7-EA-75-09-49-D9-3E-B1-F2-51-B0-54-9B-AC-D0-A4-83-01-DC-DD-07-EB-5A-9A-D6-FC-23-40-E2-E4-37-03-BA-3E-A6-4C-49-54-3D-DA-36-98-5A-24-F9-39-FE-07-98-84-95-A4-99-1B-0D-22-7A-E4-8A-FD-31-E9-42-E3-8A-6F-8F-3F-80-F9-A7-46-31-4C-A9-56-05-5C-1C-99-7E-8A-3A-BD-AD-61-A9-4C-86-78-F8-B7-51-03-75-F0-0A-FF-90-02-1E-47-F7-39-80-79-25-FB-ED-66-36-EA-98-E6-56-96-0F-2E-9E-4E-2B-40-BF-67-A9-67-B1-83-58-4F-15-32-86-C9-9F-11-E2-39-CD-7F-07-93-50-88-53-34-F7-71-F2-80-B3-23-94-AE-DB-5B-26-8D-19-01-63-BB-DA-4F-6C-B0-C1-B3-1C-5B-C8-4B-3A-46-E4-3F-88-B8-B7-C2-28-94-AF-94-48-CC-CE-A1-E1-FB-DD-3E-A1-74-4F-ED-26-99-93-0A-D2-F5-BE-C3-8D-D3-2C-09-6C-C5-68-AF-6A-E5-44-94-52-A9-F1-76-1C-11-BC-CF-AC-50-59-AD-F3-7F-C9-DA-3E-C9-2E-B8-DC-7F-E3-39-A9-82-C0-A2-0D-87-D6-69-26-39-5C-5E-74-65-C4-6B-8D-99-C7-B3-10-94-B2-41-96-57-01-38-81-84-27-B4-68-06-1E-25-31-3F-F8-CD-C1-30-DB-88-B9-C4-89-F2-FA-41-53-FC-DA-A5", BitConverter.ToString (keypair));
+ Assert.AreEqual ("07-02-00-00-00-A4-00-00-52-53-41-32-00-04-00-00-11-00-00-00-CB-BD-1D-09-FD-E5-F8-46-59-8F-2A-CA-98-72-53-E2-7F-68-C1-F6-41-9A-7A-52-1F-A5-61-7B-2D-B1-AA-E0-4E-39-98-45-45-B2-34-88-74-53-09-06-9D-64-6A-EE-84-25-3A-D9-B7-B4-E6-3E-72-37-C7-DF-A3-E0-B8-AF-7F-80-8B-5B-8A-9D-71-19-46-EC-E1-60-0D-52-ED-76-48-CD-6F-EB-CE-48-EA-61-AB-02-5C-03-AF-BA-DF-B8-1F-F5-54-74-F0-B6-D6-40-A4-43-10-D4-EE-07-8D-36-F7-71-A8-9D-2B-AC-38-23-9C-CE-82-06-09-2F-F8-BB-99-65-FB-58-2A-BA-41-75-39-1F-9D-45-76-21-25-5B-2D-0A-04-AA-E7-FA-28-7E-3B-1E-5D-6E-23-F0-4E-12-32-F6-84-3D-9E-1A-B8-93-A4-FD-F4-AE-44-9F-EB-99-01-60-B5-A1-10-0B-81-08-C9-B3-B9-B1-81-AE-CF-EE-03-15-46-AF-00-E7-41-A4-A5-16-04-4D-52-52-33-CE-CF-B5-04-32-B4-A3-0D-EA-92-2E-B4-66-16-B4-40-98-86-9D-8B-02-35-20-0F-5A-D0-B1-66-88-D0-42-6C-3F-35-D9-D1-AA-EA-33-12-34-F6-53-F4-27-F0-B1-7F-C9-81-C9-67-1F-3C-C9-AD-74-41-47-0A-91-FC-38-2B-20-2E-9A-2E-69-F7-C1-59-FF-14-74-B7-EA-75-09-49-D9-3E-B1-F2-51-B0-54-9B-AC-D0-A4-83-01-DC-DD-07-EB-5A-9A-D6-FC-23-40-E2-E4-37-03-BA-3E-A6-4C-49-54-3D-DA-36-98-5A-24-F9-39-FE-07-98-84-95-A4-99-1B-0D-22-7A-E4-8A-FD-31-E9-42-E3-8A-6F-8F-3F-80-F9-A7-46-31-4C-A9-56-05-5C-1C-99-7E-8A-3A-BD-AD-61-A9-4C-86-78-F8-B7-51-03-75-F0-0A-FF-90-02-1E-47-F7-39-80-79-25-FB-ED-66-36-EA-98-E6-56-96-0F-2E-9E-4E-2B-40-BF-67-A9-67-B1-83-58-4F-15-32-86-C9-9F-11-E2-39-CD-7F-07-93-50-88-53-34-F7-71-F2-80-B3-23-94-AE-DB-5B-26-8D-19-01-63-BB-DA-4F-6C-B0-C1-B3-1C-5B-C8-4B-3A-46-E4-3F-88-B8-B7-C2-28-94-AF-94-48-CC-CE-A1-E1-FB-DD-3E-A1-74-4F-ED-26-99-93-0A-D2-F5-BE-C3-8D-D3-2C-09-6C-C5-68-AF-6A-E5-44-94-52-A9-F1-76-1C-11-BC-CF-AC-50-59-AD-F3-7F-C9-DA-3E-C9-2E-B8-DC-7F-E3-39-A9-82-C0-A2-0D-87-D6-69-26-39-5C-5E-74-65-C4-6B-8D-99-C7-B3-10-94-B2-41-96-57-01-38-81-84-27-B4-68-06-1E-25-31-3F-F8-CD-C1-30-DB-88-B9-C4-89-F2-FA-41-53-FC-DA-A5", BitConverter.ToString (keypair));
}
[Test]
rsa.ImportParameters (rsap);
byte[] pubkey = rsa.ExportCspBlob (false);
- AssertEquals ("06-02-00-00-00-A4-00-00-52-53-41-31-00-04-00-00-11-00-00-00-CB-BD-1D-09-FD-E5-F8-46-59-8F-2A-CA-98-72-53-E2-7F-68-C1-F6-41-9A-7A-52-1F-A5-61-7B-2D-B1-AA-E0-4E-39-98-45-45-B2-34-88-74-53-09-06-9D-64-6A-EE-84-25-3A-D9-B7-B4-E6-3E-72-37-C7-DF-A3-E0-B8-AF-7F-80-8B-5B-8A-9D-71-19-46-EC-E1-60-0D-52-ED-76-48-CD-6F-EB-CE-48-EA-61-AB-02-5C-03-AF-BA-DF-B8-1F-F5-54-74-F0-B6-D6-40-A4-43-10-D4-EE-07-8D-36-F7-71-A8-9D-2B-AC-38-23-9C-CE-82-06-09-2F-F8-BB", BitConverter.ToString (pubkey));
+ Assert.AreEqual ("06-02-00-00-00-A4-00-00-52-53-41-31-00-04-00-00-11-00-00-00-CB-BD-1D-09-FD-E5-F8-46-59-8F-2A-CA-98-72-53-E2-7F-68-C1-F6-41-9A-7A-52-1F-A5-61-7B-2D-B1-AA-E0-4E-39-98-45-45-B2-34-88-74-53-09-06-9D-64-6A-EE-84-25-3A-D9-B7-B4-E6-3E-72-37-C7-DF-A3-E0-B8-AF-7F-80-8B-5B-8A-9D-71-19-46-EC-E1-60-0D-52-ED-76-48-CD-6F-EB-CE-48-EA-61-AB-02-5C-03-AF-BA-DF-B8-1F-F5-54-74-F0-B6-D6-40-A4-43-10-D4-EE-07-8D-36-F7-71-A8-9D-2B-AC-38-23-9C-CE-82-06-09-2F-F8-BB", BitConverter.ToString (pubkey));
}
[Test]
rsa.ImportParameters (rsap);
byte[] pubkey = rsa.ExportCspBlob (false);
- AssertEquals ("06-02-00-00-00-A4-00-00-52-53-41-31-00-04-00-00-11-00-00-00-CB-BD-1D-09-FD-E5-F8-46-59-8F-2A-CA-98-72-53-E2-7F-68-C1-F6-41-9A-7A-52-1F-A5-61-7B-2D-B1-AA-E0-4E-39-98-45-45-B2-34-88-74-53-09-06-9D-64-6A-EE-84-25-3A-D9-B7-B4-E6-3E-72-37-C7-DF-A3-E0-B8-AF-7F-80-8B-5B-8A-9D-71-19-46-EC-E1-60-0D-52-ED-76-48-CD-6F-EB-CE-48-EA-61-AB-02-5C-03-AF-BA-DF-B8-1F-F5-54-74-F0-B6-D6-40-A4-43-10-D4-EE-07-8D-36-F7-71-A8-9D-2B-AC-38-23-9C-CE-82-06-09-2F-F8-BB", BitConverter.ToString (pubkey));
+ Assert.AreEqual ("06-02-00-00-00-A4-00-00-52-53-41-31-00-04-00-00-11-00-00-00-CB-BD-1D-09-FD-E5-F8-46-59-8F-2A-CA-98-72-53-E2-7F-68-C1-F6-41-9A-7A-52-1F-A5-61-7B-2D-B1-AA-E0-4E-39-98-45-45-B2-34-88-74-53-09-06-9D-64-6A-EE-84-25-3A-D9-B7-B4-E6-3E-72-37-C7-DF-A3-E0-B8-AF-7F-80-8B-5B-8A-9D-71-19-46-EC-E1-60-0D-52-ED-76-48-CD-6F-EB-CE-48-EA-61-AB-02-5C-03-AF-BA-DF-B8-1F-F5-54-74-F0-B6-D6-40-A4-43-10-D4-EE-07-8D-36-F7-71-A8-9D-2B-AC-38-23-9C-CE-82-06-09-2F-F8-BB", BitConverter.ToString (pubkey));
}
[Test]
byte[] keypair = rsa.ExportCspBlob (true);
for (int i=0; i < blob.Length; i++)
- AssertEquals (i.ToString (), blob [i], keypair [i]);
+ Assert.AreEqual (blob [i], keypair [i], i.ToString ());
+ }
+
+ [Test]
+ public void ImportCspBlob_Signature_Keypair ()
+ {
+ // from bug #5299
+ byte[] blob = new byte [] {
+ 0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41,
+ 0x32, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0xCB, 0xF3,
+ 0xF0, 0x0C, 0xD7, 0xC1, 0xA8, 0x06, 0x1A, 0xF5, 0x49, 0x4E, 0x7A,
+ 0x02, 0x4A, 0x46, 0xB2, 0x8F, 0xE0, 0x01, 0x5C, 0x89, 0x01, 0x2D,
+ 0x42, 0x5A, 0xEA, 0x16, 0x11, 0x66, 0x48, 0x26, 0x29, 0xAE, 0x2A,
+ 0xAA, 0xD4, 0x3C, 0x27, 0xF6, 0x48, 0x0E, 0x09, 0x25, 0xD0, 0x63,
+ 0x80, 0x74, 0xDA, 0x1B, 0x57, 0x1D, 0x62, 0x83, 0xB9, 0x58, 0x5D,
+ 0x09, 0x4D, 0x0B, 0x1F, 0x3F, 0xC8, 0xB8, 0x99, 0x3B, 0x9A, 0x57,
+ 0x16, 0x18, 0xE8, 0x73, 0x2F, 0x34, 0x96, 0x5C, 0xE6, 0x8F, 0x1E,
+ 0xF8, 0x46, 0x4A, 0x90, 0x16, 0x3F, 0x40, 0x18, 0x53, 0x62, 0x7F,
+ 0x24, 0xB2, 0x3A, 0xFB, 0xA2, 0x80, 0x39, 0x1C, 0x08, 0x6D, 0xFC,
+ 0x6B, 0xCA, 0x0A, 0x14, 0xDD, 0xA9, 0x41, 0x57, 0x25, 0x49, 0x3A,
+ 0x27, 0x9C, 0x25, 0xC4, 0x5E, 0xC5, 0x7B, 0x83, 0x1B, 0x9D, 0xDF,
+ 0x03, 0x24, 0x94, 0x5D, 0x90, 0xD5, 0xEC, 0x7B, 0xD5, 0xCF, 0x66,
+ 0x3D, 0x93, 0x63, 0xD5, 0x1A, 0x9A, 0x9B, 0x46, 0x78, 0x89, 0xD1,
+ 0xC3, 0x38, 0x9A, 0x69, 0x61, 0xFE, 0xA2, 0x0C, 0xD9, 0x73, 0x81,
+ 0x11, 0x28, 0x71, 0x06, 0x69, 0x3D, 0x1A, 0x4E, 0xF4, 0x9D, 0x8A,
+ 0x5C, 0x9A, 0x2F, 0x71, 0x9F, 0x2B, 0x9F, 0xE6, 0xB1, 0xBF, 0x4E,
+ 0x8C, 0xFA, 0x93, 0x04, 0x29, 0xD2, 0x4A, 0x73, 0x85, 0x7A, 0x91,
+ 0x8D, 0x19, 0xCA, 0x1F, 0x2E, 0x5D, 0xD1, 0xAD, 0x70, 0xB5, 0x64,
+ 0x69, 0x5B, 0x09, 0x84, 0x35, 0xB1, 0x31, 0x15, 0x40, 0x6C, 0x0D,
+ 0x31, 0xF3, 0xEA, 0xE4, 0xD7, 0x6D, 0x42, 0xD0, 0xBB, 0x84, 0xDB,
+ 0x73, 0x10, 0x16, 0x0B, 0xDC, 0xE2, 0x62, 0x32, 0xEB, 0x23, 0x19,
+ 0x38, 0x64, 0x6A, 0x3D, 0x5E, 0x65, 0xAD, 0x7B, 0xEC, 0xB6, 0xC0,
+ 0x00, 0x4A, 0x4F, 0x98, 0x35, 0xF3, 0xD7, 0x73, 0xD3, 0x31, 0xDE,
+ 0xB6, 0x85, 0xDA, 0x4C, 0x3D, 0x79, 0x5A, 0x96, 0x07, 0x63, 0x70,
+ 0x34, 0x45, 0xF4, 0x78, 0x25, 0x78, 0x92, 0x3C, 0x56, 0x38, 0xF9,
+ 0xFA, 0x0D, 0xF4, 0x00, 0xD3, 0xD7, 0xBB, 0xA3, 0x97, 0xB4, 0x26,
+ 0xEB, 0x25, 0xA3, 0x1E, 0x34, 0xFC, 0x0E, 0x7F, 0x6A, 0x12, 0x25,
+ 0x25, 0x50, 0x26, 0x8D, 0x10, 0x80, 0xC7, 0xEB, 0x4B, 0x4B, 0x74,
+ 0x09, 0x89, 0x2F, 0xBB, 0x03, 0x02, 0x17, 0xFD, 0x13, 0x71, 0x33,
+ 0xB4, 0x46, 0x49, 0xDD, 0xBE, 0x34, 0x01, 0x37, 0xC3, 0x63, 0x4D,
+ 0xBE, 0x76, 0xAD, 0x62, 0x11, 0x6C, 0xDD, 0x64, 0x47, 0x73, 0x95,
+ 0x92, 0x58, 0xBF, 0xFF, 0xE3, 0x20, 0xD2, 0xB1, 0xEC, 0xA8, 0x03,
+ 0xB8, 0xA7, 0x0E, 0xA5, 0xAE, 0xAF, 0x47, 0x45, 0xED, 0x5F, 0xE1,
+ 0x0B, 0xA8, 0xA3, 0x03, 0xB7, 0x93, 0xA6, 0xD8, 0xAC, 0x71, 0xAB,
+ 0x77, 0x8B, 0xEC, 0x6F, 0x16, 0x0E, 0x1A, 0x2B, 0x2D, 0x31, 0xBD,
+ 0x69, 0xD4, 0x9E, 0x9E, 0x0F, 0xA2, 0xED, 0x94, 0x59, 0x1D, 0x61,
+ 0x0E, 0xE5, 0xD3, 0x19, 0x2B, 0xAD, 0x70, 0x90, 0xAF, 0x51, 0x7F,
+ 0x56, 0x53, 0xC2, 0x86, 0xB4, 0x24, 0xBC, 0xD0, 0x63, 0xAC, 0x4B,
+ 0xE0, 0xE0, 0x6C, 0xF5, 0xF6, 0x21, 0x7D, 0xE9, 0x7C, 0x45, 0x13,
+ 0xE7, 0x87, 0x11, 0x09, 0xCC, 0xA6, 0xB1, 0xCD, 0x49, 0x10, 0x33,
+ 0xBC, 0x07, 0xC8, 0x56, 0xA9, 0x19, 0xC1, 0x86, 0xDF, 0x63, 0xDF,
+ 0xE6, 0x6D, 0xFB, 0x46, 0x31, 0x93, 0x36, 0x3C, 0x8E, 0x6E, 0xB0,
+ 0xC7, 0x66, 0xFC, 0x6C, 0x85, 0x5B, 0xF4, 0xEE, 0x1D, 0x3B, 0xE3,
+ 0x8B, 0xF5, 0xB9, 0x88, 0x48, 0x2F, 0x77, 0x56, 0x82, 0x85, 0x7C,
+ 0xF9, 0xE9, 0x15, 0xA5, 0x8E, 0x46, 0xEA, 0x08, 0xB9, 0xD0, 0x8F,
+ 0x0F, 0x28, 0x1C, 0x96, 0xA1, 0xB3, 0x00, 0x6E, 0x9B, 0x81, 0xBD,
+ 0xD4, 0x54, 0xA4, 0xFD, 0xD5, 0xA7, 0x4B, 0x2E, 0x17, 0x10, 0xED,
+ 0xD2, 0xAA, 0x38, 0x2E, 0x24, 0x7C, 0x59, 0xF4, 0x2D, 0x08, 0x3B,
+ 0x15, 0x05, 0x6A, 0xD8, 0x61, 0x8A, 0xAC, 0xCD, 0x5E, 0x77, 0x4C,
+ 0x8E, 0x0C, 0xEE, 0xD8, 0xEF, 0xD0, 0xBC, 0x1B, 0x14, 0x17, 0xE3,
+ 0x38, 0x27, 0xA1, 0x70, 0x5B, 0x5C, 0xC3, 0xE3, 0x91, 0x1E, 0x01,
+ 0xE3, 0x9A, 0x16, 0x1A, 0x5C, 0x4D, 0xD9, 0x3B, 0x36, 0x7F, 0x0B,
+ 0x93, 0x16
+ };
+ rsa = new RSACryptoServiceProvider ();
+ rsa.ImportCspBlob (blob);
+
+ byte[] keypair = rsa.ExportCspBlob (false);
+ Assert.AreEqual (keypair [5], blob [5], "0x24 signature");
}
[Test]
byte[] pubkey = rsa.ExportCspBlob (false);
for (int i = 0; i < blob.Length; i++)
- AssertEquals (i.ToString (), blob [i], pubkey [i]);
+ Assert.AreEqual (blob [i], pubkey [i], i.ToString ());
}
[Test]
rsa = new RSACryptoServiceProvider (minKeySize);
rsa.ImportCspBlob (blob);
}
-#endif
+
+ [Test] //bug 38054
+ public void NonExportableKeysAreNonExportable ()
+ {
+ var cspParams = new CspParameters();
+ cspParams.KeyContainerName = "TestRSAKey";
+ cspParams.Flags = CspProviderFlags.UseNonExportableKey;
+ var rsa = new RSACryptoServiceProvider(cspParams);
+ Assert.Throws<CryptographicException>(() => rsa.ExportParameters(true));
+ }
}
}
projects / mono.git / blobdiff