mcs/class/corlib/Test/System.Security.Cryptography/DSACryptoServiceProviderTest.cs

   1 //
   2 // DSACryptoServiceProviderTest.cs, NUnit Test Cases for DSACryptoServiceProvider
   3 //
   4 // Author:
   5 //      Sebastien Pouliot <sebastien@ximian.com>
   6 //
   7 // (C) 2002, 2003 Motus Technologies Inc. (http://www.motus.com)
   8 // (C) 2004 Novell (http://www.novell.com)
   9 //
  10
  11 using NUnit.Framework;
  12 using System;
  13 using System.IO;
  14 using System.Security.Cryptography;
  15
  16 namespace MonoTests.System.Security.Cryptography {
  17
  18 [TestFixture]
  19 public class DSACryptoServiceProviderTest : Assertion {
  20
  21         protected DSACryptoServiceProvider dsa;
  22         protected DSACryptoServiceProvider disposed;
  23
  24 //      static string xmlPrivate = "<DSAKeyValue><P>s/Oc0t4gj0NRqkCKi4ynJnOAEukNhjkHJPOzNsHP69kyHMUwZ3AzOkLGYOWlOo2zlYKzSbZygDDI5dCWA5gQF2ZGHEUlWJMgUyHmkybOi44cyHaX9yeGfbnoc3xF9sYgkA3vPUZaJuYMOsBp3pyPdeN8/mLU8n0ivURyP+3Ge9M=</P><Q>qkcTW+Ce0L5k8OGTUMkRoGKDc1E=</Q><G>PU/MeGp6I/FBduuwD9UPeCFzg8Ib9H5osku5nT8AhHTY8zGqetuvHhxbESt4lLz8aXzX0oIiMsusBr6E/aBdooBI36fHwW8WndCmwkB1kv7mhRIB4302UrfvC2KWQuBypfl0++a1whBMCh5VTJYH1sBkFIaVNeUbt5Q6/UdiZVY=</G><Y>shJRUdGxEYxSKM5JVol9HAdQwIK+wF9X4n9SAD++vfZOMOYi+M1yuvQAlQvnSlTTWr7CZPRVAICLgDBbqi9iN+Id60ccJ+hw3pGDfLpJ7IdFPszJEeUO+SZBwf8njGXULqSODs/NTciiX7E07rm+KflxFOg0qtWAhmYLxIkDx7s=</Y><J>AAAAAQ6LSuRiYdsocZ6rgyqIOpE1/uCO1PfEn758Lg2VW6OHJTYHNC30s0gSTG/Jt3oHYX+S8vrtNYb8kRJ/ipgcofGq2Qo/cYKP7RX2K6EJwSfWInhsNMr1JmzuK0lUKkXXXVo15fL8O2/16uEWMg==</J><Seed>uYM5b20luvbuyevi9TXHwekbr5s=</Seed><PgenCounter>4A==</PgenCounter><X>fAOytZttUZFzt/AvwRinmvYKL7E=</X></DSAKeyValue>";
  25 //      static string xmlPublic = "<DSAKeyValue><P>s/Oc0t4gj0NRqkCKi4ynJnOAEukNhjkHJPOzNsHP69kyHMUwZ3AzOkLGYOWlOo2zlYKzSbZygDDI5dCWA5gQF2ZGHEUlWJMgUyHmkybOi44cyHaX9yeGfbnoc3xF9sYgkA3vPUZaJuYMOsBp3pyPdeN8/mLU8n0ivURyP+3Ge9M=</P><Q>qkcTW+Ce0L5k8OGTUMkRoGKDc1E=</Q><G>PU/MeGp6I/FBduuwD9UPeCFzg8Ib9H5osku5nT8AhHTY8zGqetuvHhxbESt4lLz8aXzX0oIiMsusBr6E/aBdooBI36fHwW8WndCmwkB1kv7mhRIB4302UrfvC2KWQuBypfl0++a1whBMCh5VTJYH1sBkFIaVNeUbt5Q6/UdiZVY=</G><Y>shJRUdGxEYxSKM5JVol9HAdQwIK+wF9X4n9SAD++vfZOMOYi+M1yuvQAlQvnSlTTWr7CZPRVAICLgDBbqi9iN+Id60ccJ+hw3pGDfLpJ7IdFPszJEeUO+SZBwf8njGXULqSODs/NTciiX7E07rm+KflxFOg0qtWAhmYLxIkDx7s=</Y><J>AAAAAQ6LSuRiYdsocZ6rgyqIOpE1/uCO1PfEn758Lg2VW6OHJTYHNC30s0gSTG/Jt3oHYX+S8vrtNYb8kRJ/ipgcofGq2Qo/cYKP7RX2K6EJwSfWInhsNMr1JmzuK0lUKkXXXVo15fL8O2/16uEWMg==</J><Seed>uYM5b20luvbuyevi9TXHwekbr5s=</Seed><PgenCounter>4A==</PgenCounter></DSAKeyValue>";
  26
  27         static int minKeySize = 512;
  28         private DSACryptoServiceProvider smallDsa;
  29
  30         private bool machineKeyStore;
  31
  32         [SetUp]
  33         public void Setup ()
  34         {
  35                 machineKeyStore = DSACryptoServiceProvider.UseMachineKeyStore;
  36                 if (disposed == null) {
  37                         disposed = new DSACryptoServiceProvider (minKeySize);
  38                         disposed.Clear ();
  39                 }
  40                 // do not generate a new keypair for each test
  41                 if (smallDsa == null)
  42                         smallDsa = new DSACryptoServiceProvider (minKeySize);
  43         }
  44
  45         [TearDown]
  46         public void TearDown ()
  47         {
  48                 DSACryptoServiceProvider.UseMachineKeyStore = machineKeyStore;
  49         }
  50
  51         public void AssertEquals (string msg, byte[] array1, byte[] array2)
  52         {
  53                 AllTests.AssertEquals (msg, array1, array2);
  54         }
  55
  56         // may also help for DSA descendants
  57         public void AssertEquals (string message, DSAParameters expectedKey, DSAParameters actualKey, bool checkPrivateKey)
  58         {
  59                 AssertEquals (message + " Counter", expectedKey.Counter, actualKey.Counter);
  60                 AssertEquals (message + " G", expectedKey.G, actualKey.G);
  61                 AssertEquals (message + " J", expectedKey.J, actualKey.J);
  62                 AssertEquals (message + " P", expectedKey.P, actualKey.P);
  63                 AssertEquals (message + " Q", expectedKey.Q, actualKey.Q);
  64                 AssertEquals (message + " Seed", expectedKey.Seed, actualKey.Seed);
  65                 AssertEquals (message + " Y", expectedKey.Y, actualKey.Y);
  66                 if (checkPrivateKey)
  67                         AssertEquals (message + " X", expectedKey.X, actualKey.X);
  68         }
  69
  70         [Test]
  71         public void ConstructorEmpty ()
  72         {
  73                 // under Mono:: a new key pair isn't generated
  74                 dsa = new DSACryptoServiceProvider ();
  75                 // test default key size
  76                 AssertEquals ("DSA ConstructorEmpty", 1024, dsa.KeySize);
  77                 Assert ("PersistKeyInCsp", !dsa.PersistKeyInCsp);
  78         }
  79
  80         [Test]
  81         public void ConstructorKeySize ()
  82         {
  83                 dsa = new DSACryptoServiceProvider (minKeySize);
  84                 // test default key size
  85                 AssertEquals ("DSA ConstructorKeySize", minKeySize, dsa.KeySize);
  86                 Assert ("PersistKeyInCsp", !dsa.PersistKeyInCsp);
  87         }
  88
  89         [Test]
  90         public void ConstructorCspParameters ()
  91         {
  92                 CspParameters csp = new CspParameters (13, null, "Mono1024");
  93                 // under MS a new keypair will only be generated the first time
  94                 dsa = new DSACryptoServiceProvider (csp);
  95                 // test default key size
  96                 AssertEquals ("DSA ConstructorCspParameters", 1024, dsa.KeySize);
  97                 Assert ("PersistKeyInCsp", dsa.PersistKeyInCsp);
  98         }
  99
 100         [Test]
 101         public void ConstructorKeySizeCspParameters ()
 102         {
 103                 CspParameters csp = new CspParameters (13, null, "Mono512");
 104                 dsa = new DSACryptoServiceProvider (minKeySize, csp);
 105                 AssertEquals ("DSA ConstructorCspParameters", minKeySize, dsa.KeySize);
 106                 Assert ("PersistKeyInCsp", dsa.PersistKeyInCsp);
 107         }
 108
 109         [Test]
 110         [Ignore ("Much too long (with MS as Mono doesn't generates the keypair unless it need it)")]
 111         public void KeyGeneration ()
 112         {
 113                 // Test every valid key size
 114                 KeySizes LegalKeySize = dsa.LegalKeySizes [0];
 115                 for (int i = LegalKeySize.MinSize; i <= LegalKeySize.MaxSize; i += LegalKeySize.SkipSize) {
 116                         dsa = new DSACryptoServiceProvider (i);
 117                         AssertEquals ("DSA.KeySize", i, dsa.KeySize);
 118                 }
 119         }
 120
 121         [Test]
 122         public void LimitedKeyGeneration ()
 123         {
 124                 // Test smallest valid key size (performance issue)
 125                 using (dsa = new DSACryptoServiceProvider (minKeySize)) {       // MS generates keypair here
 126                         AssertEquals ("BeforeMonoKeyGeneration.KeySize", minKeySize, dsa.KeySize);
 127                         byte[] hash = new byte [20];
 128                         dsa.CreateSignature (hash);                             // mono generates keypair here
 129                         AssertEquals ("AfterMonoKeyGeneration.KeySize", minKeySize, dsa.KeySize);
 130                 }
 131                 // here Dispose is called (with true)
 132         }
 133
 134         [Test]
 135         [ExpectedException (typeof (CryptographicException))]
 136         public void TooSmallKeyPair ()
 137         {
 138                 dsa = new DSACryptoServiceProvider (384);
 139         }
 140
 141         [Test]
 142         [ExpectedException (typeof (CryptographicException))]
 143         public void TooBigKeyPair ()
 144         {
 145                 dsa = new DSACryptoServiceProvider (2048);
 146         }
 147
 148         [Test]
 149         public void Properties ()
 150         {
 151                 dsa = new DSACryptoServiceProvider (minKeySize);
 152                 AssertEquals ("LegalKeySize", 1, dsa.LegalKeySizes.Length);
 153                 AssertEquals ("LegalKeySize.MinSize", minKeySize, dsa.LegalKeySizes [0].MinSize);
 154                 AssertEquals ("LegalKeySize.MaxSize", 1024, dsa.LegalKeySizes [0].MaxSize);
 155                 AssertEquals ("LegalKeySize.SkipSize", 64, dsa.LegalKeySizes [0].SkipSize);
 156                 AssertNull ("KeyExchangeAlgorithm", dsa.KeyExchangeAlgorithm);
 157                 AssertEquals ("SignatureAlgorithm", "http://www.w3.org/2000/09/xmldsig#dsa-sha1", dsa.SignatureAlgorithm);
 158                 dsa.Clear ();
 159                 AssertEquals ("LegalKeySize(disposed)", 1, dsa.LegalKeySizes.Length);
 160                 AssertEquals ("LegalKeySize.MinSize(disposed)", minKeySize, dsa.LegalKeySizes [0].MinSize);
 161                 AssertEquals ("LegalKeySize.MaxSize(disposed)", 1024, dsa.LegalKeySizes [0].MaxSize);
 162                 AssertEquals ("LegalKeySize.SkipSize(disposed)", 64, dsa.LegalKeySizes [0].SkipSize);
 163                 AssertNull ("KeyExchangeAlgorithm(disposed)", dsa.KeyExchangeAlgorithm);
 164                 AssertEquals ("SignatureAlgorithm(disposed)", "http://www.w3.org/2000/09/xmldsig#dsa-sha1", dsa.SignatureAlgorithm);
 165         }
 166
 167         [Test]
 168         [ExpectedException (typeof (ObjectDisposedException))]
 169         public void CreateSignatureDisposed ()
 170         {
 171                 byte[] hash = new byte [20];
 172                 disposed.CreateSignature (hash);
 173         }
 174
 175         [Test]
 176         [ExpectedException (typeof (CryptographicException))]
 177         public void CreateSignatureInvalidHashLength ()
 178         {
 179                 byte[] hash = new byte [19];
 180                 smallDsa.CreateSignature (hash);
 181         }
 182
 183         [Test]
 184         public void CreateSignature ()
 185         {
 186                 byte[] hash = new byte [20];
 187                 // for Mono, no keypair has yet been generated before calling CreateSignature
 188                 smallDsa.CreateSignature (hash);
 189         }
 190
 191         [Test]
 192         public void SignData ()
 193         {
 194                 byte[] data = new byte [128];
 195                 byte[] signature = smallDsa.SignData (data);
 196                 Assert ("SignData", smallDsa.VerifyData (data, signature));
 197         }
 198
 199         [Test]
 200         [ExpectedException (typeof (ObjectDisposedException))]
 201         public void SignDataDisposed ()
 202         {
 203                 byte[] data = new byte [20];
 204                 disposed.SignData (data);
 205         }
 206
 207         [Test]
 208         [ExpectedException (typeof (ObjectDisposedException))]
 209         public void SignHashDisposed ()
 210         {
 211                 byte[] hash = new byte [20];
 212                 disposed.SignHash (hash, "SHA1");
 213         }
 214
 215         [Test]
 216         [ExpectedException (typeof (CryptographicException))]
 217         public void SignHashInvalidAlgorithm ()
 218         {
 219                 byte[] hash = new byte [16];
 220                 smallDsa.SignHash (hash, "MD5");
 221         }
 222
 223         [Test]
 224         [ExpectedException (typeof (ObjectDisposedException))]
 225         public void VerifyDataDisposed ()
 226         {
 227                 byte[] data = new byte [20];
 228                 byte[] sign = new byte [40];
 229                 disposed.VerifyData (data, sign);
 230         }
 231
 232         [Test]
 233         [ExpectedException (typeof (CryptographicException))]
 234         public void VerifyHashInvalidAlgorithm ()
 235         {
 236                 byte[] hash = new byte [16];
 237                 byte[] sign = new byte [40];
 238                 smallDsa.VerifyHash (hash, "MD5", sign);
 239         }
 240
 241         [Test]
 242         [ExpectedException (typeof (ObjectDisposedException))]
 243         public void VerifyHashDisposed ()
 244         {
 245                 byte[] hash = new byte [20];
 246                 byte[] sign = new byte [40];
 247                 disposed.VerifyHash (hash, "SHA1", sign);
 248         }
 249
 250         [Test]
 251         [ExpectedException (typeof (ObjectDisposedException))]
 252         public void VerifySignatureDisposed ()
 253         {
 254                 byte[] hash = new byte [20];
 255                 byte[] sign = new byte [40];
 256                 disposed.VerifySignature (hash, sign);
 257         }
 258
 259         [Test]
 260         [ExpectedException (typeof (CryptographicException))]
 261         public void VerifySignatureInvalidHashLength ()
 262         {
 263                 byte[] hash = new byte [19];
 264                 byte[] sign = new byte [40];
 265                 smallDsa.VerifySignature (hash, sign);
 266         }
 267
 268         [Test]
 269         [ExpectedException (typeof (CryptographicException))]
 270         public void VerifySignatureInvalidSignatureLength ()
 271         {
 272                 byte[] hash = new byte [20];
 273                 byte[] sign = new byte [39];
 274                 smallDsa.VerifySignature (hash, sign);
 275         }
 276
 277         [Test]
 278         [Ignore ("Running this test breaks all further DSA tests on MS runtime!")]
 279         public void VerifySignatureWithoutKey ()
 280         {
 281                 byte[] hash = new byte [20];
 282                 byte[] sign = new byte [40];
 283                 // Mono hasn't generated a keypair - but it's impossible to
 284                 // verify a signature based on a new just generated keypair
 285                 Assert ("VerifySignature(WithoutKey)", !smallDsa.VerifySignature (hash, sign));
 286         }
 287
 288         [Test]
 289         [ExpectedException (typeof (ObjectDisposedException))]
 290         public void ImportDisposed ()
 291         {
 292                 disposed.ImportParameters (AllTests.GetKey (false));
 293         }
 294
 295         [Test]
 296         [ExpectedException (typeof (ObjectDisposedException))]
 297         public void ExportDisposed ()
 298         {
 299                 DSAParameters param = disposed.ExportParameters (false);
 300         }
 301
 302         [Test]
 303         [ExpectedException (typeof (CryptographicException))]
 304         public void DSAImportMissingP ()
 305         {
 306                 DSAParameters input = AllTests.GetKey (false);
 307                 input.P = null;
 308                 dsa = new DSACryptoServiceProvider (1024);
 309                 dsa.ImportParameters (input);
 310         }
 311
 312         [Test]
 313         [ExpectedException (typeof (CryptographicException))]
 314         public void DSAImportMissingQ ()
 315         {
 316                 DSAParameters input = AllTests.GetKey (false);
 317                 input.Q = null;
 318                 dsa = new DSACryptoServiceProvider (1024);
 319                 dsa.ImportParameters (input);
 320         }
 321
 322         [Test]
 323         [ExpectedException (typeof (CryptographicException))]
 324         public void DSAImportMissingG ()
 325         {
 326                 DSAParameters input = AllTests.GetKey (false);
 327                 input.G = null;
 328                 dsa = new DSACryptoServiceProvider (1024);
 329                 dsa.ImportParameters (input);
 330         }
 331
 332         [Test]
 333         [ExpectedException (typeof (CryptographicException))]
 334         [Ignore ("MS runtime throws a System.ExecutionEngineException then exit the application")]
 335         public void DSAImportMissingY ()
 336         {
 337                 DSAParameters input = AllTests.GetKey (false);
 338                 input.Y = null;
 339                 dsa = new DSACryptoServiceProvider (1024);
 340                 dsa.ImportParameters (input);
 341         }
 342
 343         [Test]
 344         public void DSAImportMissingJ ()
 345         {
 346                 DSAParameters input = AllTests.GetKey (false);
 347                 input.J = null;
 348                 dsa = new DSACryptoServiceProvider (1024);
 349                 dsa.ImportParameters (input);
 350                 AssertEquals ("MissingJ.KeySize", 1024, dsa.KeySize);
 351         }
 352
 353         [Test]
 354         public void DSAImportMissingSeed ()
 355         {
 356                 DSAParameters input = AllTests.GetKey (false);
 357                 input.Seed = null;
 358                 dsa = new DSACryptoServiceProvider (1024);
 359                 dsa.ImportParameters (input);
 360                 AssertEquals ("MissingSeed.KeySize", 1024, dsa.KeySize);
 361         }
 362
 363         // all keypairs generated by CryptoAPI on Windows
 364         string CapiXml512 = "<DSAKeyValue><P>tWcdz18IhYs8k1vagB94wR/sgHSANmmVlSstfMBWbIwthyT2AV64LkMLeCOdflYFEXgpmpTx5UIGGgEx8/EEuw==</P><Q>6E7WKEXRY+ASYA6nkBUP25fgz88=</Q><G>QPykdzvQ997BxXBZ+xFM10jzvZ3G73T9Aj6y2bMNdKd3/GfZwbvQui83YoRfFnYumJmV6c4cfCN1Tuf6n6jCuA==</G><Y>jrNR5BBEzW9aD9WjeJ7us0ityN8mpcqBVbHCAAWIjc0BvlY1AacPQ8xN3kKyHHKpPgMwNuFXHwks6VO68Y0etw==</Y><J>x+c7udpLkcx0I6LX2+HjLn/VHTdPr2XH9Dk4fBUnVrrjYKPVYQCIavHKFCY=</J><Seed>7qAsSVCQRpmFIfhyhYdtMybIvLI=</Seed><PgenCounter>AYU=</PgenCounter><X>DSWG2qNYTBMXD6k5j9AeCaxSVp4=</X></DSAKeyValue>";
 365         string CapiXml576 = "<DSAKeyValue><P>/UpVL7nsgTsT+HzOidLQgSi9Rk8sn+jBl/RH9OzoSJhmLKM4cCl/mz3LAZNWqDS9kqDlTohYfPTVdsKA79U3uHx+xeUpk6UH</P><Q>mR7th6PKwfpwBBzp1MUGy36jxuc=</Q><G>oWjhXviie9LYZxoSCZuc45kQG+1iIJm3Omeik06b0jM9ZtVtHCXjuHRohEZfuBck8HRUxreSRT895kXzhN3/hYcqLnGMPbiZ</G><Y>kC1DnEs3hW30JtYLRQ3d46sp++6oNIjz9ncAZz6VEQg6GqjLieigAg/5ikzHjUS3Ps9xVOgGGpjSFTMSYrEl/K3obPNNFPWi</Y><J>AAAAAad4wklEWIys2shSp+zpfpu0K+/li8cJMK8K5oneqwedsMPT/ciDPVgrJYtS1WrwDoIHIAo=</J><Seed>LuRNAo/Lj+cbWgE6JB57C+8tB1I=</Seed><PgenCounter>cQ==</PgenCounter><X>h3vfdRLRPghNCXKzITtcpJo3W+U=</X></DSAKeyValue>";
 366         string CapiXml640 = "<DSAKeyValue><P>1SjEwMEXKJFpmQip/SFhqQHoi3SWgXAbMA6ZMVVL/34O9CqUY2shx9E839i4mTh+euvyF9A6UhUuVRFJ8HMFpPeBqbbzrVtynU2USW74h2U=</P><Q>rYvCtKnZiH28AoErTfKCAex11YM=</Q><G>K5iAfQ50aEpTtkuHN/WQCa7bysGBT3vbPkRVUcYX0GAxZSIrXqvQJVh74FQnttk0AkSSqc1Bj3aH8DG0Ie3pqFDfyWoj4ZHh7DaqjHIUlTs=</G><Y>aqEzlNdCktrAI4PF1DNYFkPTFbjO+ittp78dThOJOaDitM0OhkdujSzwvwRQ25phVbsxlVpGesxpqI3dA6Y13v2Xbek9P+1WkS1iPZt88f8=</Y><J>AAAAATpvI+WRt+RdcSC/hd9pO+yvd8fYY+NLh+F951dEuZfulWl09ARuzwc5BHu3x2IO/NbUc3Eru82RBBmhzA==</J><Seed>QMvwX0OS+ANLT263MGWecWwQOfs=</Seed><PgenCounter>Ag==</PgenCounter><X>Gu8/RsqX34sOnfNU71OZCmL2pMw=</X></DSAKeyValue>";
 367         string CapiXml704 = "<DSAKeyValue><P>v8CmmIBAKfifPNhkHtkBk9FdS5U4gq8Ex/L+0tVR1Izh7t9C2d0C1ZNbaTOTDGKV7TKOLIOXQ/sYVa3Sa033cWrfk/Z1veHd+49Xk7JjEiKnMipfXtXp8Q==</P><Q>qctfxht2I8ZbZF6f+jT4DNON00U=</Q><G>nQ4ao+mLFUD8XRr4bhVbk5siffsbCauzOQNZlWQMfHjuSTfD8+MKzhgXb/A+a0CQRBXvYu+2R8VmyRET93IlwkppXgxldSwUd3xlng/3O9ogbF06zHVjHg==</G><Y>d82MybaKc5FselhGYpGm/XROSyAsSs/blDzQAnjyPfKWdbXSaHLjyeficMmipi60/nH5ShnCnMrc22Bm9hOpMaMfhidMX6Uh5YB9EKy7Cdb6587/y6EiLA==</Y><J>AAAAASEbOtcd7wjAzuiD9qyOTA4xEKFPgOup5SuDH6FZ9FXAH+NePtGeBpXKIaLj2shrkKhsJmY5pVza/yVE9L74ajqcK2kw</J><Seed>8W3wrLCmjs81ekM3Jz3D9fxfAuw=</Seed><PgenCounter>wA==</PgenCounter><X>UWQ3ZFd/Eg2OzY9Fin/aCGLHNbQ=</X></DSAKeyValue>";
 368         string CapiXml768 = "<DSAKeyValue><P>wOca55yVYJveGqx8w3acAV/LNyLmo9eAXKxnIXyEsjB+LoGjJRvJbqMy0NP9VR6qv12iZaVs/32A2y6iHMeVnQWxSnu9ieeM+Gwwh4Xg1beOeHsI4FKBH+ZTgYiNRGXT</P><Q>uPrZhRYtl7IOc38ZQnKd3StxCO8=</Q><G>S8cg4PHBvNOQ/c7zYYJTS991U5O2OibCsaOLUKFlUhkf+9DUDvJIauSzeWbQVkb6ta5oOapRbUNPfjY6OlZWHMnlBXAUpme2UBoz1IMUY2xM6Q4JKrxMv6NLCHoMhnP6</G><Y>rb/X/sFw7f0JOnSD2ygUzFFU57iIxYwRl8t8lUZ2lJ0oBdw2zy75Oud4S7vB56Xo0JJAEFSUQFobpAWpxqZ/5qLP0PzhxhjwN+Dv9S5hpcaicJrIbHKdx8A7O6P5QcR2</Y><J>AAAAAQr2+OH8gZynYhX5wG8T9iWuMu6LsLuQsbYoDcbCbMdwDRr1bNYjR1NPZNfuDtVlzXFY1nOSG67wW7HZIWYMYBBCRKbE5oK16O8VI04=</J><Seed>xjnQGEAsKqfluAuJCCs8hG3pDI8=</Seed><PgenCounter>nA==</PgenCounter><X>erfJ6egI1OnM1z1IRFhJaFN+B3w=</X></DSAKeyValue>";
 369         string CapiXml832 = "<DSAKeyValue><P>pbJGnzQS8MnlCD9/odKjNmFsFxdOpsaVld2k3yNxbvJGRNPhAm3jXXL+1lAlSanpsBDRzEZfd8QQO1W5dZ3J0D9nLY15Pf49UhMvduYvEzgqofdMWxi0Wc+lfsivsa1/7tgfzVE2Jc0=</P><Q>7XixpXVHZk2vrfb8wng8Ek80sWk=</Q><G>RQKfUz7so8P76ax7pz4l8mSBwlXZbdwc0+ASgXa7lS2o1r/RsNrrrAWrLvMKQP6Nzg48uuDiI4QCoyFoi3ToiqPlV63fl4JSxQgHSCRh2VHg+iG+4fujqAPEfDWsQZGH84/jZLSpw+4=</G><Y>CakyawTgUySuImok8j6zg6y6xizp1NlPBlVmIzggP8rpaATvnapyk2T8jPsMHFsNWFiRbCQapXBvVp2Vqc2w+VOuTi2C0evjbcGT3ZdEAJoxyVkwy3I8P2hHtXtwy1c67kOADAAZZ0c=</Y><J>sp/uZOuB11am784e30URbuizTkAPUXDvQT6FyZGEIEreZGavkCOhOs8+vZ2eevYSPsr8eFC8XaMK+mOa13AQb60kYPuGPAgpw8OJnL/gwMemEbHs</J><Seed>zXDB6meB3EeaXj4xYLDxXdvJzxo=</Seed><PgenCounter>Af4=</PgenCounter><X>6APt5R3qKDQSvI04R6ibq0gRHMo=</X></DSAKeyValue>";
 370         string CapiXml896 = "<DSAKeyValue><P>tdSKUdac07x6tSb7I/HuZeLTzdP5Ft0ngwcabST3LVPvC9VlczcYidHAMObeTuuL5eu+OGFr8//FmzANMkl2QlBu6L79dNraHb2TeUAApt6YYMfLJgzqXpHRzlxR33Uhox4PY3OAS1W1yNU3DvPQow==</P><Q>0eJqRrUp4/23i5geDgMmjFViKQ0=</Q><G>nWUPHcBQUpy1Wnxz4y+EI/LcfrAMP/quhxJRdcxiTpdsI/OHZXaBnieHjcrGsuOgBAfifapiEUj3mWN2wk5H3wZpxi6TDIXrweWcWIuWpB33Xr1ZHM5TYPmrFfimbav/xJh3Cd9j8wi1eackodrEQw==</G><Y>nja1XNP1H/fNsL5nKymZelvlBP7NPOTVaFp+2L3a6mVamGdl37CHMHlLzXIXYMsaAyf6pGMivwjj2caSu7wwzNdAbavWnagXSSU6pXNnAMHWS266j642xc030/pavBLU/hCV7N5VZ/EapLBUEqqpcg==</Y><J>3cghxRYCKhtnphhsgfHs90NqrPkMx4iIXMNcomAmrJdthiGPTfADM+4AykVs3KDUcEQtkU8eUiZsiDqDdKkCxFwtpdvpp7bViKPjnzl0j7yxf3Fcb2GRW033Rqo=</J><Seed>zrLLYcXgs+SWccZ5R0EeaO41l+w=</Seed><PgenCounter>Byc=</PgenCounter><X>Vbs8rxlLRHVAm5x1UdQXblNT610=</X></DSAKeyValue>";
 371         string CapiXml960 = "<DSAKeyValue><P>8I6EDGOIko1Fm6r6nBWqLS7A4RhYwfdUilJINLJpsvZ7z0qa4MqqLFB57H3Iok/YLe8Z4SSqrLJDqH4Rxl28rNAOcVBuTiCHx5GNuetfeqF2knFLCg4caJIwI51AbzSJEiBp7tlGyNHdu46XOMFukdC8jkozTbzJ</P><Q>rS9PUEwcN0vYzIcmgon339LAqrE=</Q><G>X33SudRcEMlrtB5xDndktK4UNJOVPuT14ypK4JLB8DTQRqYMkHUqNnTRCYMurOJGsbNP4ebjqp4eCMyQ+zHmEKNNi6AZulFzUvzkdbfBkN8HJYJQC9tdp9U445BUF5lnIsKvv18d9gFbcUvL8aFRmNVY0M9NtSdb</G><Y>fjKb8Z7LZ1ylNo1Yzc904XRFf/AsnORT2l4+1ruPZPPlaRkGRfF8sD/B/6We+rYOJg68F8ngBmCwkzy9QfV4lkeB6n1sco03h7Zd/B6cMjC6tqAThdh70xk9CTyk46fL61qN032HfdF1ca2OqkuDdnfpbIBg0EUt</Y><J>AAAAAWOWpJWt08loRNc8cCf2Dl94/2aRbebis+SxRwqSiF77iEsMlsndA+hLX+6UOE4fFuFm7x38o6iUB1poYI0TaxQrDeaFjovIiPOovcofuP8efHiIeMR6cnugvYWXkC3ZsZASK0g=</J><Seed>iS3sRFr6k97343rVRZLsZVN0Brw=</Seed><PgenCounter>UA==</PgenCounter><X>B5SpH6Fd1S/3GuiHgkZJZLKQcFk=</X></DSAKeyValue>";
 372         string CapiXml1024 = "<DSAKeyValue><P>rHUuNzvl+8HhyXeXhVePoCZPX7oBr0gIWgMBU067L+hN3AvLw2372iSgnb8cT0wbFjgcJYUfmJcsQfGJCz+ngGeVKFkqPZCrlG6VuAY3mYZ5VZY68q4EtsM4YtqjRNLDIiTdAtHYdMdWnraK58Z/Z688Drbkp0m4PgDEj+VvgcU=</P><Q>+1Qjw//auFyRrXKm3I/ehy5uph0=</Q><G>g++njdKHRxHdhIUjbd2wEsV+q0KJRiiXCbHyxBPb0L4Ahv8vG2SxQftdHwBIEuh8cOKG9/bPmvsmjPdTigbZUKhA4QmH4hhTVa0f1dtJepylCJcwvEmFDG38sw2J95XSAodPBfeuLxOBYrpLXZry5fi6P0m3BgSEqSHjCQfHQok=</G><Y>Ee57vjhzaJi+iHTfVvURccywtV7sauK997+wsk3XH6GC85htoAG42qeHKB93wtA67IuIh6gH6Mt6+RA6jQ1P+OEoCTGHUR2Fu0qhBHGU/AsNXKrrtaDc0a+abcEeZxU1ENhz7D2eOxm/ohp/If2mt2FZ/VtUOt9eOEtOCtRbyaI=</Y><J>r6nCxn/CLCgxXOgQH5c4kjyMoFg/XUB7xNFFHfI6MXI26h3astfAkHzcSJvl5lmM9iLHxgOMIviYXfWFLD++M3rglElCw7BnHccKWtQGxmg1ToFOAjC7UaCejLcDI0i7HX6WdO0YY1ZcqA2U</J><Seed>SpWGXImjbDvjqh5E64HkgSLEMtM=</Seed><PgenCounter>Bc0=</PgenCounter><X>f4PsM9PtzRlhvoLemk9NS5KZq3Q=</X></DSAKeyValue>";
 373
 374         // import/export XML keypairs
 375         // so we know that Mono can use keypairs generated by CryptoAPI
 376         [Test]
 377         public void CapiXmlImportExport ()
 378         {
 379                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 380
 381                 dsa.FromXmlString (CapiXml512);
 382                 AssertEquals ("Capi-Xml512", CapiXml512, dsa.ToXmlString (true));
 383
 384                 dsa.FromXmlString (CapiXml576);
 385                 AssertEquals ("Capi-Xml576", CapiXml576, dsa.ToXmlString (true));
 386
 387                 dsa.FromXmlString (CapiXml640);
 388                 AssertEquals ("Capi-Xml640", CapiXml640, dsa.ToXmlString (true));
 389
 390                 dsa.FromXmlString (CapiXml704);
 391                 AssertEquals ("Capi-Xml704", CapiXml704, dsa.ToXmlString (true));
 392
 393                 dsa.FromXmlString (CapiXml768);
 394                 AssertEquals ("Capi-Xml768", CapiXml768, dsa.ToXmlString (true));
 395
 396                 dsa.FromXmlString (CapiXml832);
 397                 AssertEquals ("Capi-Xml832", CapiXml832, dsa.ToXmlString (true));
 398
 399                 dsa.FromXmlString (CapiXml896);
 400                 AssertEquals ("Capi-Xml896", CapiXml896, dsa.ToXmlString (true));
 401
 402                 dsa.FromXmlString (CapiXml960);
 403                 AssertEquals ("Capi-Xml960", CapiXml960, dsa.ToXmlString (true));
 404
 405                 dsa.FromXmlString (CapiXml1024);
 406                 AssertEquals ("Capi-Xml1024", CapiXml1024, dsa.ToXmlString (true));
 407         }
 408
 409         private void SignAndVerify (string msg, DSACryptoServiceProvider dsa)
 410         {
 411                 byte[] hash = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13 };
 412                 byte[] sign1 = dsa.CreateSignature (hash);
 413                 byte[] sign2 = dsa.SignData (hash, 0, hash.Length);
 414                 byte[] sign3 = dsa.SignData (new MemoryStream (hash));
 415
 416                 // we don't need the private key to verify
 417                 DSAParameters param = dsa.ExportParameters (false);
 418                 DSACryptoServiceProvider key = (DSACryptoServiceProvider) DSA.Create ();
 419                 key.ImportParameters (param);
 420                 // the signature is never the same so the only way to know if
 421                 // it worked is to verify it ourselve (i.e. can't compare)
 422                 bool ok = key.VerifySignature (hash, sign1);
 423                 Assert (msg + "-CreateSignature-VerifySignature", ok);
 424
 425                 ok = key.VerifyHash (hash, null, sign1);
 426                 Assert (msg + "-CreateSignature-VerifyHash", ok);
 427
 428                 ok = key.VerifyData (hash, sign2);
 429                 Assert (msg + "-SignData(byte[])-VerifyData", ok);
 430
 431                 ok = key.VerifyData (hash, sign3);
 432                 Assert (msg + "-SignData(Stream)-VerifyData", ok);
 433         }
 434
 435         // Validate that we can sign with every keypair and verify the signature
 436         // With Mono this means that we can use CAPI keypair to sign and verify.
 437         // For Windows this doesn't mean much.
 438         [Test]
 439         public void CapiSignature ()
 440         {
 441                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 442
 443                 dsa.FromXmlString (CapiXml512);
 444                 SignAndVerify ("Capi-512", dsa);
 445
 446                 dsa.FromXmlString (CapiXml576);
 447                 SignAndVerify ("Capi-576", dsa);
 448
 449                 dsa.FromXmlString (CapiXml640);
 450                 SignAndVerify ("Capi-640", dsa);
 451
 452                 dsa.FromXmlString (CapiXml704);
 453                 SignAndVerify ("Capi-704", dsa);
 454
 455                 dsa.FromXmlString (CapiXml768);
 456                 SignAndVerify ("Capi-768", dsa);
 457
 458                 dsa.FromXmlString (CapiXml832);
 459                 SignAndVerify ("Capi-832", dsa);
 460
 461                 dsa.FromXmlString (CapiXml896);
 462                 SignAndVerify ("Capi-896", dsa);
 463
 464                 dsa.FromXmlString (CapiXml960);
 465                 SignAndVerify ("Capi-960", dsa);
 466
 467                 dsa.FromXmlString (CapiXml1024);
 468                 SignAndVerify ("Capi-1024", dsa);
 469         }
 470
 471         // Validate that we can verify a signature made with CAPI
 472         // With Mono this means that we can verify CAPI signatures.
 473         // For Windows this doesn't mean much.
 474         [Test]
 475         public void CapiVerify ()
 476         {
 477                 byte[] hash = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13 };
 478                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 479
 480                 dsa.FromXmlString (CapiXml512);
 481                 byte[] sign512 = { 0xCA, 0x11, 0xA4, 0xCD, 0x5B, 0xBA, 0xA1, 0xC9, 0x8C, 0xEF, 0x9A, 0xB8, 0x84, 0x09, 0x96, 0xD0, 0x1B, 0x39, 0x6D, 0x1C, 0xE1, 0xB2, 0x0E, 0xD3, 0xCE, 0xCF, 0x6A, 0x48, 0xDC, 0x22, 0x40, 0xDC, 0xCD, 0x61, 0x25, 0x7F, 0x9E, 0x1B, 0x79, 0x89 };
 482                 Assert ("Capi-512-Verify", dsa.VerifySignature (hash, sign512));
 483                 sign512[0] = 0x00;
 484                 Assert ("Capi-512-VerBad", !dsa.VerifySignature (hash, sign512));
 485
 486                 dsa.FromXmlString (CapiXml576);
 487                 byte[] sign576 = { 0x10, 0x77, 0xE9, 0x4C, 0x29, 0xB0, 0xF4, 0x0E, 0x3B, 0xB7, 0x8E, 0x3A, 0x40, 0x22, 0x63, 0x70, 0xF3, 0xA5, 0xB7, 0x4A, 0x5C, 0x85, 0xB5, 0xF3, 0x4B, 0x1C, 0x4A, 0x92, 0xDD, 0x1D, 0xED, 0x63, 0x26, 0xC2, 0x42, 0x20, 0xBE, 0x33, 0x55, 0x57 };
 488                 Assert ("Capi-576-Verify", dsa.VerifySignature (hash, sign576));
 489                 sign576[0] = 0x00;
 490                 Assert ("Capi-576-VerBad", !dsa.VerifySignature (hash, sign576));
 491
 492                 dsa.FromXmlString (CapiXml640);
 493                 byte[] sign640 = { 0x4C, 0x04, 0xAC, 0xE0, 0x84, 0x04, 0x5A, 0x1D, 0x9D, 0x61, 0xA1, 0x62, 0xBE, 0x11, 0xEA, 0x0D, 0x1C, 0x21, 0xC7, 0x55, 0x2C, 0x7C, 0x84, 0x4F, 0x22, 0xE9, 0xA1, 0xF1, 0x2C, 0x83, 0x13, 0x90, 0xAE, 0x36, 0xFD, 0x59, 0x32, 0x21, 0xAE, 0x0F };
 494                 Assert ("Capi-640-Verify", dsa.VerifySignature (hash, sign640));
 495                 sign640[0] = 0x00;
 496                 Assert ("Capi-640-VerBad", !dsa.VerifySignature (hash, sign640));
 497
 498                 dsa.FromXmlString (CapiXml704);
 499                 byte[] sign704 = { 0xA2, 0x75, 0x32, 0xE0, 0x4B, 0xCA, 0x92, 0x51, 0x84, 0xAC, 0x7C, 0xDE, 0x97, 0xB8, 0xC3, 0x25, 0xD7, 0xF8, 0xA7, 0xE0, 0x76, 0x42, 0x7E, 0x5E, 0x5E, 0x3F, 0x82, 0xDB, 0x87, 0xBF, 0xC9, 0xCC, 0xD9, 0xA2, 0x8E, 0xA2, 0xFE, 0xD3, 0x48, 0x30 };
 500                 Assert ("Capi-704-Verify", dsa.VerifySignature (hash, sign704));
 501                 sign704[0] = 0x00;
 502                 Assert ("Capi-704-VerBad", !dsa.VerifySignature (hash, sign704));
 503
 504                 dsa.FromXmlString (CapiXml768);
 505                 byte[] sign768 = { 0x92, 0x27, 0x89, 0x4B, 0xB2, 0xDF, 0xE9, 0x98, 0x5A, 0xC5, 0x78, 0x5E, 0xBD, 0x51, 0x6D, 0x10, 0x30, 0xEC, 0x14, 0x95, 0x6E, 0xEB, 0xA6, 0x5F, 0x3E, 0x47, 0x47, 0x86, 0x19, 0xD0, 0xF2, 0x9B, 0x70, 0x98, 0x97, 0x07, 0x04, 0x0C, 0x13, 0xC6 };
 506                 Assert ("Capi-768-Verify", dsa.VerifySignature (hash, sign768));
 507                 sign768[0] = 0x00;
 508                 Assert ("Capi-768-VerBad", !dsa.VerifySignature (hash, sign768));
 509
 510                 dsa.FromXmlString (CapiXml832);
 511                 byte[] sign832 = { 0xC7, 0x10, 0x86, 0x86, 0x4A, 0x19, 0xBC, 0x8E, 0xC5, 0x0E, 0x53, 0xC0, 0x9E, 0x70, 0x2C, 0xFD, 0x4B, 0x9B, 0xBD, 0x79, 0x46, 0x8E, 0x9F, 0x64, 0x41, 0xF9, 0xBB, 0xDD, 0x3B, 0x93, 0x63, 0x82, 0x7B, 0x9B, 0x5B, 0x12, 0x9B, 0xAA, 0x90, 0xAD };
 512                 Assert ("Capi-832-Verify", dsa.VerifySignature (hash, sign832));
 513                 sign832[0] = 0x00;
 514                 Assert ("Capi-832-VerBad", !dsa.VerifySignature (hash, sign832));
 515
 516                 dsa.FromXmlString (CapiXml896);
 517                 byte[] sign896 = { 0x7F, 0x0F, 0x5F, 0xC4, 0x44, 0x38, 0x65, 0xD7, 0x0B, 0x03, 0xD1, 0xAC, 0x77, 0xA2, 0xA2, 0x47, 0x37, 0x37, 0x42, 0xA2, 0x97, 0x23, 0xDA, 0x7F, 0xEC, 0xD5, 0x78, 0x3D, 0x5E, 0xDA, 0xA0, 0x02, 0xD6, 0x2D, 0x4B, 0xFA, 0x79, 0x7B, 0x7A, 0x87 };
 518                 Assert ("Capi-896-Verify", dsa.VerifySignature (hash, sign896));
 519                 sign896[0] = 0x00;
 520                 Assert ("Capi-896-VerBad", !dsa.VerifySignature (hash, sign896));
 521
 522                 dsa.FromXmlString (CapiXml960);
 523                 byte[] sign960 = { 0x63, 0x77, 0x39, 0xE5, 0x03, 0xD2, 0x33, 0xF5, 0xFE, 0x16, 0xE4, 0x7E, 0x49, 0x4E, 0x72, 0xA0, 0x1B, 0x8D, 0x4D, 0xEC, 0x55, 0x15, 0x72, 0x1C, 0x22, 0x37, 0x4B, 0x64, 0xEB, 0x02, 0x3E, 0xC5, 0xCF, 0x32, 0x07, 0xC5, 0xD3, 0xA2, 0x02, 0x0A };
 524                 Assert ("Capi-960-Verify", dsa.VerifySignature (hash, sign960));
 525                 sign960[0] = 0x00;
 526                 Assert ("Capi-960-VerBad", !dsa.VerifySignature (hash, sign960));
 527
 528                 dsa.FromXmlString (CapiXml1024);
 529                 byte[] sign1024 = { 0x1C, 0x5A, 0x9D, 0x82, 0xDD, 0xE0, 0xF5, 0x65, 0x74, 0x48, 0xFB, 0xD6, 0x27, 0x92, 0x98, 0xEA, 0xC6, 0x7F, 0x4F, 0x7C, 0x49, 0xFC, 0xCF, 0x46, 0xEB, 0x62, 0x27, 0x05, 0xFC, 0x9C, 0x40, 0x74, 0x5B, 0x13, 0x7E, 0x76, 0x9C, 0xE4, 0xF6, 0x53 };
 530                 Assert ("Capi-1024-Verify", dsa.VerifySignature (hash, sign1024));
 531                 sign1024[0] = 0x00;
 532                 Assert ("Capi-1024-VerBad", !dsa.VerifySignature (hash, sign1024));
 533         }
 534
 535         // all keypairs generated by Mono on Windows
 536         string MonoXml512 = "<DSAKeyValue><P>zh9f0jwaZU7uk9A2YZkKDiAt3Rk/UFieBrs9CtvrWDNjmZyB8OZtwdt5qoZxxk/ZQdhnQPyY4Wfb2AXfcNw1oQ==</P><Q>qRl9bdSR4U2HEJ75f8v/h9ofAXs=</Q><G>aZZELrF/gAWcJnITv2pCzpwbP4d1OppRyEko5Ub6HJYL4Ez4TPTtveW+6ni90Kqq6Hbfc1x26MaU+c7s8GsTBw==</G><Y>j4sRCjiN0vdibzB0EuHFdDmB1nb8YmjEMtLzU2A7icqVbo+obwAIofNSaEW5bSc1nSGL1AFD2WIa49U6yewxXg==</Y><J>AAAAATgMk/+kNvZLy1QCT75cuivedK6Iz+bZ2g/ncnvBjjb5oM9PFxAZU+MNI57g</J><Seed>tEXsCuDb0lrfypB5kTI5iTWPqSA=</Seed><PgenCounter>xg==</PgenCounter><X>nd+0VT69+NJ0l4DuQDnOwCDR30A=</X></DSAKeyValue>";
 537         string MonoXml576 = "<DSAKeyValue><P>+IVgSLz5ciuK8w5Wq56zX5ZDU/A4XrwTUngLmG4SyjtHLZUVS4npZ/gaJk02oSl4E1WUKL8yKDy1p3jewbH5bAScuprQpXr5</P><Q>01NXNM+IZtv6fl8Zr64daxJHAqk=</Q><G>ZrM3QjPyuINgj38UEqi1APX3zz7jsoCUNnslCjVgzhS0q9L44FcKPxW9WW+uh/N2PxcSqDMCd3yFvbzzgHG8+Te12UT00BHW</G><Y>CUHNKbeRzIBQncxOhaC7pKz0Gscx5zhO++BTvGRDKkOUBbvO+kf52Y+q1Hmp0OS+I3tDFU80V7Lmt5UpPw4DyzSuqukkI6Uy</Y><J>AAAAAS0PAQxeB0hDGlnmieeuKG1X8KsogV8rdq8fI9Glhu44LfGZmzBNsBCrqHSMBVVFWTerdjg=</J><Seed>eUE4tvz2nInFOGDhfMFO90p+d1o=</Seed><PgenCounter>8Q==</PgenCounter><X>iAWUFn8TSUh5GYNLB2YLyzg6KxE=</X></DSAKeyValue>";
 538         string MonoXml640 = "<DSAKeyValue><P>7aE8g2fajUuMRVNVdblVtOqoFjWao0gPvS9z/rZAtfcJhZ/Q75PFUUKhBz/zMClT0O6GY695LErNUQvIH9bfgrM5Mywk5tRDV2FN61kWg00=</P><Q>ppaB4BvQvi/PtUi60y6cO55BGS8=</Q><G>g+ImQPN/hbRDu/A23Wv9MMVHRUgMGaPySPeOtdKad96iycTS0ddC/Odo7fvg11+ukiauD7Sec4UQPNGFHoT0vozAcg6SDmX4KgM4M5QDsl8=</G><Y>lsItHPOgvebvDU7o+Cns17Q1+EZ3ySG2DXQ5RyZ8zB4UmBfsC8Lnz5EliGZqej/D5OJSAjNfIx9hh+Jd6ENBNNyWDZnLIwYi5WuwhxFZ+vY=</Y><J>AAAAAW0sBVV2lXw4OIn3UIqYPzE+ith31rrZ0OnTlqYElQqSXub7Sf20ILEIYGQ3CZ2so4t1qmebmjK+cwAGdA==</J><Seed>fecSUnEdYuJJP2pIGw89Apu74Qs=</Seed><PgenCounter>Rg==</PgenCounter><X>nDBo1S2rT/XfwdHFVa7LcVoNCuE=</X></DSAKeyValue>";
 539         string MonoXml704 = "<DSAKeyValue><P>lWVVsk//enAqLcmFBuw68MRuF4OBENHlnS9Fcy6idae43Di/yRkNxURLcjKAgDne6a0fPvAXMa7iyOm8r1GO6DtdR3xepApufnhQrn982lZY2D2Uzufkxw==</P><Q>3tFuyT6SXpfM746TBeufyWcVxjU=</Q><G>d5x4zOlwNSNk+nzF6rMl3iU81NHm7Org+ZjV00haTRcud1nSn9qlPMmh1Iyu2eDb/hVFYSHVriR6JL9uhnHRFgDmG0Gq3rLYjP9HwSc0bSZJhpnvMh+plg==</G><Y>gMyp9cb1b+PiJVjHm1JXyMRpPQaqXAwv9aZ/3ALUMla5xWbs8eOX0xKb03F9SiOyrrOLl7FU1NV3aPAqlxRVAEoDWfs59kwFuvtxTNCPMA9yUe9LIPmESg==</Y><J>q6TNHPV5sVaSSavn0P3kpQ/dEnw6r+Kf6vA8f1A6XwsufncwAAjLgkDD5tglPcUzuqSBNbpGnZgXHpD7mXvORGzJEm4=</J><Seed>U4J0gynSch6aQjtYthQvOrZ5FDo=</Seed><PgenCounter>2g==</PgenCounter><X>yYzu1dTYzh9veG5e+Uph0fJdOLo=</X></DSAKeyValue>";
 540         string MonoXml768 = "<DSAKeyValue><P>rpEwOnT4y+tJvCg9LvuQ+PxB12r1ZghEaF7fiGh46ip2GsMfotb24tE58YpzTqiaJT3H/w5Ps7MZKE42322dX1oV9kRSmr/EYYS9GdUbnKCtfa+sA1x0FwDZgqaCZ3pV</P><Q>5eRCKf4gMUCAToisFaJsn0xQ6IM=</Q><G>bKVUkTMOgonH9RzGI1FXbLgemhVq2qSpwVce7f3qjGDPnw7uzXfLPqvMc3WYRGLB99gps+8SNdJ7pdxIprAyGG0ovl0Fq1X7Xwk9RQBqdbxnx+tLCXhkgLV/OpEnJGqs</G><Y>eX3lNXsbmfeg2Ac4dzTqQMowXV22ydnoXtOE2EggOE60WcHxiNql0yLUvFfRIdf0PnJa7/EfqzAxc1U6dHGljNWwH8mvsJXKQ/ps5fa8v5UveAzg73chUparNM9d7WAp</Y><J>wmR011Gh0XpjfIpTczt/J4pQq5L9IqrhxeQHPgRTC5/xL4Lh8cheAlVDrF8RqgnE6VgSCTOOfeq+7ySLNTdrWA3xweyS5s+lpqQEHA==</J><Seed>yWTv1DNaxQxqdKMdwPCzpP1dz6Q=</Seed><PgenCounter>PQ==</PgenCounter><X>5bS76Q72Mkw8/c9q8VZJY8XQ3vs=</X></DSAKeyValue>";
 541         string MonoXml832 = "<DSAKeyValue><P>/8mh+RcX8QTo1cxuXYuSs4FihZ9IiKocX/M1gHCtsK9vWHBH+JoRPJ0huuQLp0qZzK0BncPyJdkST+HCnOuWEzBBunf2cebtAl6Bm3LYldzCdig7ptrlHsVBSOzSnBsEfl6VAGvFEw0=</P><Q>3j2ihzDNHb2OIm/Ly+928iz6r2M=</Q><G>ctmj3nFuBvbVYJo9sxmOvmnRsd+Z4bVc+ieb450uRdA+IsXSqfTN1phHUt7DQmFxBALi0ygg7PX1V+0JkZf4Ui1/lMPdznA6H+UJzV0GgJpCNwsYfrZbNFddm+wunRMuz6uTB57UKxM=</G><Y>cI8rpi0L89rBytXQCl/HFlsoTrogdzcj7/yYgzDRqnuINUA7lUJ1Vzj803p9IKQg6pNb0jRKwHcYnHAg/Lb3yWJcQHsZWvdfAG3vR/P8LM15BiXnAGuur7X8zRa1E9/vqcn77GCsuuI=</Y><J>AAAAASakjFeNPQ1kUYa8c77CkoEGZCAfG5+31W/00Tnu8QkgZMjGaUp/4vzvzgAn+KuZh0lRYbxi4IHpCEvgji7Cr+w3AFLdtRK63TwvJFkWLqx8N64MhA==</J><Seed>cblDQQ0wbr/Tpb/Pu3IcICApHx8=</Seed><PgenCounter>jQ==</PgenCounter><X>uVVaaWQdHK6O4mlrLXUouHTQQbo=</X></DSAKeyValue>";
 542         string MonoXml896 = "<DSAKeyValue><P>x0mhnUZKcKqmCMpbvWfF67pBkQeJSm9I8S0BZISyeSpt9CS9qSnZlCyA+bRPA6BURXl6cPkDKMosHvkN40TWR8nj0zx5ggKmWFDZC7FaIXlvrhs4ALwNMC6Ji376r0EhZIpl+rGaOFM9uz+ya7fasQ==</P><Q>7PE0XlOwB9mi8PKk6HjW5bsU2Ds=</Q><G>r1DKk6xGIRWkE0PdC6kqsAECOZ2Q1VKZow+5xLCMAUlH+172fl4ViXw1Ihk6LTj5BYCb5NLxTO26naUoxQfY5FT/C3e9k17UWVBI7cPpNJNmIQGY2N/enI01tGWSZO5THyaXI0mvG2mI0Io8kG+E3Q==</G><Y>N+v4DSXxsSteaPQxu6eOBdhWpd2N1eV/A0RZYAcoWXb2uF8L3foq4Ake+VXgLRWDExkhBQurWBQxrD4vJbdgHeI/yKkmHL6IATDkuv0KPkZ8gMqJJPszk5UhxHxTo9+NiYKlGZO6qhJYV9MRbcpQqQ==</Y><J>11EYG/P5XTPQRJSyHboxKKol7zCm/0BnWvjsdBaPC3bHh2g6GR6uOE0uPZ+FJLVvP8iqClvWbxQF8pm/yKRaZa3SaJZjk1DNuEQZOkkxWqkti8MC2mIAXdCwlRA=</J><Seed>8nTVIayazWuhjpKfKkYnDz/Y3Yk=</Seed><PgenCounter>sAE=</PgenCounter><X>0nvKIkkjg3yHb0rw9eLM2nPExdk=</X></DSAKeyValue>";
 543         string MonoXml960 = "<DSAKeyValue><P>rvLpyJmoSI71LUh2slfZmfafcV/iJj2PbR+hN80NL4YAyw22T8zG4s2q5Ez1eBN+34ob48+f2UJsvSDJrFCFWHvrifgGWkUmssDBA8iIP2oAZ8jy9YdJ0QoOa2DPi9IsK6Xo0p1IsexsPpxzHzAahs86e1tBSqob</P><Q>/lEFkFT1So7tFkYuLb03uWAlekE=</Q><G>WhRVK0LJInEG5DM42yxmrgq4J8DS4uofTyD3VEAHlKWVmE7okNDrqGI+kVvMOtePVrHsl6asIlSIk+U27QW6F8opsS2vb+ior/WcFT4HjcKgGScFk4ZTVijFFejM4pLV3FuR83nSVxn4p/HzheLX6sCISWD4Pdrp</G><Y>jHV8rnyQZLWf/6DfDUpWqRjvmU2F4EqiExYJwmfwkauwar8uzfmLCzrpMYvhF1NQ8OVyP7vYkgF2QFuMBG7X0HFNLji4mrF7DNkeUB+2LAkecpCWCgpIbPoOPXVQqe/bJgYf+8ttozbQmJTAqaGrJ2tTxweqiYCm</Y><J>sBtkEkGWVMPWdkg1WH25Q+gISLVadvRnXn4dC6n/FTqFHunYTWyh+FuLGA1l899fubwBZNrMGVhLhWdEv0wan6v0SPHQ2iz4EW5LeO/sEyXUfxhoVT7MwkMwTcMYhRmkwCFfmg==</J><Seed>aY7TaL00Rm9qsE3eU2cu3auWHVs=</Seed><PgenCounter>dw==</PgenCounter><X>kUX5eEVEaWpgm5DtHifImDLuSb8=</X></DSAKeyValue>";
 544         string MonoXml1024 = "<DSAKeyValue><P>rD4HJ6rTF7dEz2RvHhnqREpu8fW0Fs8181CHqEqgUuAKG3x8euMTHlIt+kZ95RT1chLXGBRhOWT2YTgq04cTczatZhrxSWnI8hz1eHbZvRAGQ6ZP2FMvvWyJMgWnU7D5aShUM3LOqM1TgHumGwSYXhBvbj42Jjzbn80ULPkLmOU=</P><Q>pwiHLGzrt+FSJ0+IwTiS7/N3/Ls=</Q><G>OWdsYYZ0u/p6vvBrI0X+KTubx2dXG396w01dYIshLAwA4EsoDskusyr8mG4bvxFKLzGCt2ZjC7QImSKO8Y72TmNeYmmbeDc9IYENk7LuBzd8WboCRIt2gZ/KTh26TkiN8072ZVOqRZn3I35SFkUUn6PVng6EXkuhJ8EzLyvXev4=</G><Y>EcNLWKf9FJX5OUB0ON7aNASSH1SxzqvYCK8uP4H3y2LyRo7fi1JvDi/BUSyhCxfvRMG8O5QUi2yAXfNFWqEVnGUxlwNUzpx4UwKF+vYZAcnU8Wb0RJ++VT+O2NN9wou1Ys4p/gWYNsi4fk0nm8Hjx9ae5VyMXSQHEhQuUxwxWw0=</Y><J>AAAAAQf7wobrNXeeDP58+AEbzO7Gl5pTvqHfipR8ttv5yuOTahOrQFOKbH3ZpVLDF6jJsj2TMJLKsFaZsOcuEgVONT8R0nOAWbskUMxYV72492RwWylTKolkcbRyhonRbpOUFdE6xrztzijDeYRObA==</J><Seed>jiFLa4UqlTqHrUk69fHpjjc9Fe0=</Seed><PgenCounter>JQE=</PgenCounter><X>i+yoBF9nTiYNVeONGl8+/7gf1LQ=</X></DSAKeyValue>";
 545
 546         // import/export XML keypairs
 547         // so we know that Windows (original MS Framework) can use keypairs generated by Mono
 548         [Test]
 549         public void MonoXmlImportExport ()
 550         {
 551                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 552
 553                 dsa.FromXmlString (MonoXml512);
 554                 AssertEquals ("Mono-Xml512", MonoXml512, dsa.ToXmlString (true));
 555
 556                 dsa.FromXmlString (MonoXml576);
 557                 AssertEquals ("Mono-Xml576", MonoXml576, dsa.ToXmlString (true));
 558
 559                 dsa.FromXmlString (MonoXml640);
 560                 AssertEquals ("Mono-Xml640", MonoXml640, dsa.ToXmlString (true));
 561
 562                 dsa.FromXmlString (MonoXml704);
 563                 AssertEquals ("Mono-Xml704", MonoXml704, dsa.ToXmlString (true));
 564
 565                 dsa.FromXmlString (MonoXml768);
 566                 AssertEquals ("Mono-Xml768", MonoXml768, dsa.ToXmlString (true));
 567
 568                 dsa.FromXmlString (MonoXml832);
 569                 AssertEquals ("Mono-Xml832", MonoXml832, dsa.ToXmlString (true));
 570
 571                 dsa.FromXmlString (MonoXml896);
 572                 AssertEquals ("Mono-Xml896", MonoXml896, dsa.ToXmlString (true));
 573
 574                 dsa.FromXmlString (MonoXml960);
 575                 AssertEquals ("Mono-Xml960", MonoXml960, dsa.ToXmlString (true));
 576
 577                 dsa.FromXmlString (MonoXml1024);
 578                 AssertEquals ("Mono-Xml1024", MonoXml1024, dsa.ToXmlString (true));
 579         }
 580
 581         // Validate that we can sign with every keypair and verify the signature
 582         // With Windows this means that we can use Mono keypairs to sign and verify.
 583         // For Mono this doesn't mean much.
 584         [Test]
 585         public void MonoSignature ()
 586         {
 587                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 588
 589                 dsa.FromXmlString (MonoXml512);
 590                 SignAndVerify ("Mono-512", dsa);
 591
 592                 dsa.FromXmlString (MonoXml576);
 593                 SignAndVerify ("Mono-576", dsa);
 594
 595                 dsa.FromXmlString (MonoXml640);
 596                 SignAndVerify ("Mono-640", dsa);
 597
 598                 dsa.FromXmlString (MonoXml704);
 599                 SignAndVerify ("Mono-704", dsa);
 600
 601                 dsa.FromXmlString (MonoXml768);
 602                 SignAndVerify ("Mono-768", dsa);
 603
 604                 dsa.FromXmlString (MonoXml832);
 605                 SignAndVerify ("Mono-832", dsa);
 606
 607                 dsa.FromXmlString (MonoXml896);
 608                 SignAndVerify ("Mono-896", dsa);
 609
 610                 dsa.FromXmlString (MonoXml960);
 611                 SignAndVerify ("Mono-960", dsa);
 612
 613                 dsa.FromXmlString (MonoXml1024);
 614                 SignAndVerify ("Mono-1024", dsa);
 615         }
 616
 617         // Validate that we can verify a signature made with Mono
 618         // With Windows this means that we can verify Mono signatures.
 619         // For Mono this doesn't mean much.
 620         [Test]
 621         public void MonoVerify ()
 622         {
 623                 byte[] hash = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13 };
 624                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 625
 626                 dsa.FromXmlString (MonoXml512);
 627                 byte[] sign512 = { 0x53, 0x44, 0x0A, 0xD7, 0x43, 0x3C, 0x1F, 0xC7, 0xCE, 0x9C, 0xAE, 0xDC, 0xFC, 0x61, 0xD5, 0xCE, 0xC9, 0x5C, 0x8D, 0x13, 0x0F, 0x66, 0x15, 0xCB, 0x9F, 0x94, 0x19, 0x18, 0x63, 0x40, 0x6D, 0x3E, 0x16, 0xA8, 0x3E, 0x9B, 0x8A, 0xC2, 0xA5, 0x38 };
 628                 Assert ("Mono-512-Verify", dsa.VerifySignature (hash, sign512));
 629                 sign512[0] = 0x00;
 630                 Assert ("Mono-512-VerBad", !dsa.VerifySignature (hash, sign512));
 631
 632                 dsa.FromXmlString (MonoXml576);
 633                 byte[] sign576 = { 0xAC, 0xC8, 0xA3, 0x22, 0x3D, 0x77, 0xE1, 0x13, 0xFD, 0x65, 0x72, 0xE0, 0xA5, 0xF5, 0x94, 0xD6, 0x70, 0x70, 0x40, 0xA9, 0x10, 0x1E, 0x1D, 0xEA, 0x51, 0x68, 0x32, 0x2A, 0x24, 0x47, 0x22, 0x8D, 0xC0, 0xD0, 0x8A, 0x5A, 0x0E, 0x98, 0x5F, 0x2C };
 634                 Assert ("Mono-576-Verify", dsa.VerifySignature (hash, sign576));
 635                 sign576[0] = 0x00;
 636                 Assert ("Mono-576-VerBad", !dsa.VerifySignature (hash, sign576));
 637
 638                 dsa.FromXmlString (MonoXml640);
 639                 byte[] sign640 = { 0x5E, 0x6E, 0x1F, 0x38, 0xCA, 0x0D, 0x01, 0x01, 0xBE, 0x5E, 0x8B, 0xAB, 0xCE, 0xD2, 0x42, 0x80, 0x4A, 0xBD, 0x74, 0x60, 0x56, 0x4B, 0x16, 0x4A, 0x71, 0xBC, 0xC3, 0x82, 0xE1, 0x54, 0x0D, 0xB0, 0x67, 0xB6, 0xB6, 0x71, 0x46, 0xA9, 0x01, 0x44 };
 640                 Assert ("Mono-640-Verify", dsa.VerifySignature (hash, sign640));
 641                 sign640[0] = 0x00;
 642                 Assert ("Mono-640-VerBad", !dsa.VerifySignature (hash, sign640));
 643
 644                 dsa.FromXmlString (MonoXml704);
 645                 byte[] sign704 = { 0x27, 0x33, 0x45, 0xC5, 0x41, 0xC7, 0xD6, 0x5D, 0x68, 0x32, 0x50, 0x4C, 0xB3, 0x4B, 0x59, 0xCF, 0x49, 0xD1, 0x61, 0x82, 0xCF, 0x73, 0x20, 0x20, 0x3E, 0x09, 0xA3, 0x49, 0xAA, 0x22, 0x1D, 0x1D, 0x27, 0xBA, 0x9F, 0xDD, 0xE2, 0x7D, 0xCD, 0x82 };
 646                 Assert ("Mono-704-Verify", dsa.VerifySignature (hash, sign704));
 647                 sign704[0] = 0x00;
 648                 Assert ("Mono-704-VerBad", !dsa.VerifySignature (hash, sign704));
 649
 650                 dsa.FromXmlString (MonoXml768);
 651                 byte[] sign768 = { 0xCA, 0x53, 0x91, 0x99, 0xAE, 0x1B, 0x97, 0xE5, 0x3B, 0x08, 0x78, 0x92, 0xD1, 0x2E, 0x0D, 0xAC, 0xB7, 0x82, 0xFB, 0xA3, 0x84, 0xEE, 0x9B, 0x5E, 0x12, 0x6C, 0x16, 0x6D, 0x97, 0xC1, 0xCF, 0x9A, 0xA9, 0xCF, 0x6A, 0x6E, 0x08, 0x45, 0xA7, 0x19 };
 652                 Assert ("Mono-768-Verify", dsa.VerifySignature (hash, sign768));
 653                 sign768[0] = 0x00;
 654                 Assert ("Mono-768-VerBad", !dsa.VerifySignature (hash, sign768));
 655
 656                 dsa.FromXmlString (MonoXml832);
 657                 byte[] sign832 = { 0x7F, 0x1C, 0xC5, 0xA4, 0xDB, 0x95, 0x27, 0xD3, 0x23, 0x6E, 0xCE, 0xBC, 0xC0, 0x9D, 0x82, 0x02, 0x6E, 0xA0, 0x80, 0x5D, 0x53, 0x54, 0x3D, 0x1B, 0x1C, 0x54, 0xDD, 0x1F, 0xD5, 0x7E, 0x07, 0x60, 0xDD, 0x2A, 0xB2, 0x96, 0x3C, 0x36, 0xB3, 0x60 };
 658                 Assert ("Mono-832-Verify", dsa.VerifySignature (hash, sign832));
 659                 sign832[0] = 0x00;
 660                 Assert ("Mono-832-VerBad", !dsa.VerifySignature (hash, sign832));
 661
 662                 dsa.FromXmlString (MonoXml896);
 663                 byte[] sign896 = { 0x36, 0x90, 0xA2, 0x4C, 0xDA, 0xDC, 0x6C, 0xF3, 0x83, 0xFE, 0xA8, 0x14, 0xFB, 0x01, 0x69, 0x5F, 0xFA, 0xFA, 0x71, 0xA6, 0x6F, 0xBE, 0x96, 0xB7, 0x11, 0xE7, 0xDE, 0xC7, 0x71, 0x10, 0x83, 0xEE, 0x34, 0x18, 0x4E, 0x88, 0xC1, 0xE0, 0xF9, 0x0A };
 664                 Assert ("Mono-896-Verify", dsa.VerifySignature (hash, sign896));
 665                 sign896[0] = 0x00;
 666                 Assert ("Mono-896-VerBad", !dsa.VerifySignature (hash, sign896));
 667
 668                 dsa.FromXmlString (MonoXml960);
 669                 byte[] sign960 = { 0xCE, 0xE8, 0x52, 0x32, 0x9B, 0x30, 0xB5, 0x22, 0x6C, 0x21, 0x34, 0xC6, 0x09, 0xD8, 0xA8, 0x6D, 0x00, 0x87, 0x0F, 0x87, 0x21, 0x50, 0x18, 0x99, 0xED, 0x2A, 0xD3, 0xA5, 0x82, 0x8D, 0x38, 0x63, 0x21, 0xDA, 0xE1, 0x94, 0x65, 0xE1, 0x6E, 0x72 };
 670                 Assert ("Mono-960-Verify", dsa.VerifySignature (hash, sign960));
 671                 sign960[0] = 0x00;
 672                 Assert ("Mono-960-VerBad", !dsa.VerifySignature (hash, sign960));
 673
 674                 dsa.FromXmlString (MonoXml1024);
 675                 byte[] sign1024 = { 0x67, 0x73, 0x4D, 0x6C, 0x0E, 0xB2, 0x85, 0xC6, 0x97, 0x5F, 0x09, 0x42, 0xEA, 0xDB, 0xC6, 0xE1, 0x6D, 0x84, 0xA0, 0x15, 0x63, 0x6C, 0xE3, 0x83, 0xA5, 0xCB, 0x58, 0xC6, 0x51, 0x3C, 0xB4, 0xD2, 0x6B, 0xA0, 0x70, 0xCE, 0xD9, 0x8D, 0x96, 0xCA };
 676                 Assert ("Mono-1024-Verify", dsa.VerifySignature (hash, sign1024));
 677                 sign1024[0] = 0x00;
 678                 Assert ("Mono-1024-VerBad", !dsa.VerifySignature (hash, sign1024));
 679         }
 680
 681         // Key Pair Persistence Tests
 682         // References
 683         // a.   .Net Framework Cryptography Frequently Asked Questions, Question 8
 684         //      http://www.gotdotnet.com/team/clr/cryptofaq.htm
 685         // b.   Generating Keys for Encryption and Decryption
 686         //      http://msdn.microsoft.com/library/en-us/cpguide/html/cpcongeneratingkeysforencryptiondecryption.asp
 687
 688         [Test]
 689         public void Persistence_PersistKeyInCsp_False ()
 690         {
 691                 CspParameters csp = new CspParameters (3, null, "Persistence_PersistKeyInCsp_False");
 692                 // MS generates (or load) keypair here
 693                 // Mono load (if it exists) the keypair here
 694                 DSACryptoServiceProvider dsa1 = new DSACryptoServiceProvider (minKeySize, csp);
 695                 // Mono will generate the keypair here (if it doesn't exists)
 696                 string first = dsa1.ToXmlString (true);
 697
 698                 // persistance is "on" by default when a CspParameters is supplied
 699                 Assert ("PersistKeyInCsp", dsa1.PersistKeyInCsp);
 700
 701                 // this means nothing if we don't call Clear !!!
 702                 dsa1.PersistKeyInCsp = false;
 703                 Assert ("PersistKeyInCsp", !dsa1.PersistKeyInCsp);
 704
 705                 // reload using the same container name
 706                 DSACryptoServiceProvider dsa2 = new DSACryptoServiceProvider (minKeySize, csp);
 707                 string second = dsa2.ToXmlString (true);
 708
 709                 AssertEquals ("Key Pair Same Container", first, second);
 710         }
 711
 712         [Test]
 713         public void Persistence_PersistKeyInCsp_True ()
 714         {
 715                 CspParameters csp = new CspParameters (3, null, "Persistence_PersistKeyInCsp_True");
 716                 // MS generates (or load) keypair here
 717                 // Mono load (if it exists) the keypair here
 718                 DSACryptoServiceProvider dsa1 = new DSACryptoServiceProvider (minKeySize, csp);
 719                 // Mono will generate the keypair here (if it doesn't exists)
 720                 string first = dsa1.ToXmlString (true);
 721
 722                 // persistance is "on" by default
 723                 Assert ("PersistKeyInCsp", dsa1.PersistKeyInCsp);
 724
 725                 // reload using the same container name
 726                 DSACryptoServiceProvider dsa2 = new DSACryptoServiceProvider (minKeySize, csp);
 727                 string second = dsa2.ToXmlString (true);
 728
 729                 AssertEquals ("Key Pair Same Container", first, second);
 730         }
 731
 732         [Test]
 733         public void Persistence_Delete ()
 734         {
 735                 CspParameters csp = new CspParameters (3, null, "Persistence_Delete");
 736                 // MS generates (or load) keypair here
 737                 // Mono load (if it exists) the keypair here
 738                 DSACryptoServiceProvider dsa1 = new DSACryptoServiceProvider (minKeySize, csp);
 739                 // Mono will generate the keypair here (if it doesn't exists)
 740                 string original = dsa1.ToXmlString (true);
 741
 742                 // note: Delete isn't well documented but can be done by
 743                 // flipping the PersistKeyInCsp to false and back to true.
 744                 dsa1.PersistKeyInCsp = false;
 745                 dsa1.Clear ();
 746
 747                 // recreate using the same container name
 748                 DSACryptoServiceProvider dsa2 = new DSACryptoServiceProvider (minKeySize, csp);
 749                 string newKeyPair = dsa2.ToXmlString (true);
 750
 751                 Assert ("Key Pair Deleted", (original != newKeyPair));
 752         }
 753
 754         [Test]
 755         public void PersistKey_True ()
 756         {
 757                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider (minKeySize);
 758                 string key = dsa.ToXmlString (true);
 759                 dsa.PersistKeyInCsp = true;
 760                 AssertEquals ("PersistKeyInCsp-True", key, dsa.ToXmlString (true));
 761         }
 762
 763         [Test]
 764         public void PersistKey_False ()
 765         {
 766                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider (minKeySize);
 767                 string key = dsa.ToXmlString (true);
 768                 dsa.PersistKeyInCsp = false;
 769                 AssertEquals ("PersistKeyInCsp-False", key, dsa.ToXmlString (true));
 770         }
 771
 772         [Test]
 773         public void PersistKey_FalseTrue ()
 774         {
 775                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider (minKeySize);
 776                 string key = dsa.ToXmlString (true);
 777                 dsa.PersistKeyInCsp = false;
 778                 dsa.PersistKeyInCsp = true;
 779                 AssertEquals ("PersistKeyInCsp-FalseTrue", key, dsa.ToXmlString (true));
 780         }
 781
 782 #if NET_1_1
 783         [Test]
 784         public void UseMachineKeyStore_Default ()
 785         {
 786                 Assert ("UseMachineKeyStore(Default)", !DSACryptoServiceProvider.UseMachineKeyStore);
 787         }
 788
 789         [Test]
 790         public void UseMachineKeyStore ()
 791         {
 792                 // note only applicable when CspParameters isn't used - which don't
 793                 // help much as you can't know the generated key container name
 794                 DSACryptoServiceProvider.UseMachineKeyStore = true;
 795                 CspParameters csp = new CspParameters (13, null, "UseMachineKeyStore");
 796                 csp.KeyContainerName = "UseMachineKeyStore";
 797                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider (csp);
 798                 string machineKeyPair = dsa.ToXmlString (true);
 799                 dsa.Clear ();
 800
 801                 DSACryptoServiceProvider.UseMachineKeyStore = false;
 802                 csp = new CspParameters (13, null, "UseMachineKeyStore");
 803                 csp.Flags |= CspProviderFlags.UseMachineKeyStore;
 804                 dsa = new DSACryptoServiceProvider (csp);
 805
 806                 Assert ("UseMachineKeyStore", machineKeyPair != dsa.ToXmlString (true));
 807         }
 808 #endif
 809 }
 810
 811 }