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 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using NUnit.Framework;
  31 using System;
  32 using System.IO;
  33 using System.Security.Cryptography;
  34
  35 namespace MonoTests.System.Security.Cryptography {
  36
  37 [TestFixture]
  38 public class DSACryptoServiceProviderTest {
  39
  40         protected DSACryptoServiceProvider dsa;
  41         protected DSACryptoServiceProvider disposed;
  42
  43 //      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>";
  44 //      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>";
  45
  46         static int minKeySize = 512;
  47         private DSACryptoServiceProvider smallDsa;
  48
  49         private bool machineKeyStore;
  50
  51         public DSACryptoServiceProviderTest ()
  52         {
  53                 disposed = new DSACryptoServiceProvider (minKeySize);
  54                 // FX 2.0 beta 1 bug - we must use the key before clearing it
  55                 // http://lab.msdn.microsoft.com/ProductFeedback/viewfeedback.aspx?feedbackid=dc970a7f-b82f-45e5-9d37-fb0ed72e6b41
  56                 int ks = disposed.KeySize;
  57                 disposed.Clear ();
  58                 // do not generate a new keypair for each test
  59                 smallDsa = new DSACryptoServiceProvider (minKeySize);
  60         }
  61
  62         [SetUp]
  63         public void Setup ()
  64         {
  65                 machineKeyStore = DSACryptoServiceProvider.UseMachineKeyStore;
  66         }
  67
  68         [TearDown]
  69         public void TearDown ()
  70         {
  71                 DSACryptoServiceProvider.UseMachineKeyStore = machineKeyStore;
  72         }
  73
  74         public void AssertEquals (string msg, byte[] array1, byte[] array2)
  75         {
  76                 AllTests.AssertEquals (msg, array1, array2);
  77         }
  78
  79         // may also help for DSA descendants
  80         public void AssertEquals (string message, DSAParameters expectedKey, DSAParameters actualKey, bool checkPrivateKey)
  81         {
  82                 Assert.AreEqual (expectedKey.Counter, actualKey.Counter, message + " Counter");
  83                 AssertEquals (message + " G", expectedKey.G, actualKey.G);
  84                 AssertEquals (message + " J", expectedKey.J, actualKey.J);
  85                 AssertEquals (message + " P", expectedKey.P, actualKey.P);
  86                 AssertEquals (message + " Q", expectedKey.Q, actualKey.Q);
  87                 AssertEquals (message + " Seed", expectedKey.Seed, actualKey.Seed);
  88                 AssertEquals (message + " Y", expectedKey.Y, actualKey.Y);
  89                 if (checkPrivateKey)
  90                         AssertEquals (message + " X", expectedKey.X, actualKey.X);
  91         }
  92
  93         [Test]
  94         public void ConstructorEmpty ()
  95         {
  96                 // under Mono:: a new key pair isn't generated
  97                 dsa = new DSACryptoServiceProvider ();
  98                 // test default key size
  99                 Assert.AreEqual (1024, dsa.KeySize, "DSA ConstructorEmpty");
 100                 Assert.IsFalse (dsa.PersistKeyInCsp, "PersistKeyInCsp");
 101                 Assert.IsFalse (dsa.PublicOnly, "PublicOnly");
 102         }
 103
 104         [Test]
 105         public void ConstructorKeySize ()
 106         {
 107                 dsa = new DSACryptoServiceProvider (minKeySize);
 108                 // test default key size
 109                 Assert.AreEqual (minKeySize, dsa.KeySize, "DSA ConstructorKeySize");
 110                 Assert.IsFalse (dsa.PersistKeyInCsp, "PersistKeyInCsp");
 111                 Assert.IsFalse (dsa.PublicOnly, "PublicOnly");
 112         }
 113
 114         [Test]
 115         [Category ("TargetJvmNotSupported")]
 116         public void ConstructorCspParameters ()
 117         {
 118                 CspParameters csp = new CspParameters (13, null, "Mono1024");
 119                 // under MS a new keypair will only be generated the first time
 120                 dsa = new DSACryptoServiceProvider (csp);
 121                 // test default key size
 122                 Assert.AreEqual (1024, dsa.KeySize, "DSA ConstructorCspParameters");
 123                 Assert.IsTrue (dsa.PersistKeyInCsp, "PersistKeyInCsp");
 124                 Assert.IsFalse (dsa.PublicOnly, "PublicOnly");
 125         }
 126
 127         [Test]
 128         [Category ("TargetJvmNotSupported")]
 129         public void ConstructorKeySizeCspParameters ()
 130         {
 131                 CspParameters csp = new CspParameters (13, null, "Mono512");
 132                 dsa = new DSACryptoServiceProvider (minKeySize, csp);
 133                 Assert.AreEqual (minKeySize, dsa.KeySize, "DSA ConstructorCspParameters");
 134                 Assert.IsTrue (dsa.PersistKeyInCsp, "PersistKeyInCsp");
 135                 Assert.IsFalse (dsa.PublicOnly, "PublicOnly");
 136         }
 137
 138         [Test]
 139         [Ignore ("Much too long (with MS as Mono doesn't generates the keypair unless it need it)")]
 140         public void KeyGeneration ()
 141         {
 142                 // Test every valid key size
 143                 KeySizes LegalKeySize = dsa.LegalKeySizes [0];
 144                 for (int i = LegalKeySize.MinSize; i <= LegalKeySize.MaxSize; i += LegalKeySize.SkipSize) {
 145                         dsa = new DSACryptoServiceProvider (i);
 146                         Assert.AreEqual (i, dsa.KeySize, "DSA.KeySize");
 147                         Assert.IsFalse (dsa.PublicOnly, "PublicOnly");
 148                 }
 149         }
 150
 151         [Test]
 152         public void LimitedKeyGeneration ()
 153         {
 154                 // Test smallest valid key size (performance issue)
 155                 using (dsa = new DSACryptoServiceProvider (minKeySize)) {       // MS generates keypair here
 156                         Assert.AreEqual (minKeySize, dsa.KeySize, "BeforeMonoKeyGeneration.KeySize");
 157                         byte[] hash = new byte [20];
 158                         dsa.CreateSignature (hash);                             // mono generates keypair here
 159                         Assert.AreEqual (minKeySize, dsa.KeySize, "AfterMonoKeyGeneration.KeySize");
 160                         Assert.IsFalse (dsa.PublicOnly, "PublicOnly");
 161                 }
 162                 // here Dispose is called (with true)
 163         }
 164
 165         [Test]
 166         [ExpectedException (typeof (CryptographicException))]
 167         public void TooSmallKeyPair ()
 168         {
 169                 dsa = new DSACryptoServiceProvider (384);
 170
 171                 // in 2.0 MS delay the creation of the key pair until it is required
 172                 // (same trick that Mono almost always used ;-) but they also delay
 173                 // the parameter validation (what Mono didn't). So here we must "get"
 174                 // the key (export) to trigger the exception
 175                 dsa.ToXmlString (true);
 176         }
 177
 178         [Test]
 179         [ExpectedException (typeof (CryptographicException))]
 180         public void TooBigKeyPair ()
 181         {
 182                 dsa = new DSACryptoServiceProvider (2048);
 183
 184                 // in 2.0 MS delay the creation of the key pair until it is required
 185                 // (same trick that Mono almost always used ;-) but they also delay
 186                 // the parameter validation (what Mono didn't). So here we must "get"
 187                 // the key (export) to trigger the exception
 188                 dsa.ToXmlString (true);
 189         }
 190
 191         [Test]
 192         public void Properties ()
 193         {
 194                 dsa = new DSACryptoServiceProvider (minKeySize);
 195                 Assert.AreEqual (1, dsa.LegalKeySizes.Length, "LegalKeySize");
 196                 Assert.AreEqual (minKeySize, dsa.LegalKeySizes[0].MinSize, "LegalKeySize.MinSize");
 197                 Assert.AreEqual (1024, dsa.LegalKeySizes[0].MaxSize, "LegalKeySize.MaxSize");
 198                 Assert.AreEqual (64, dsa.LegalKeySizes[0].SkipSize, "LegalKeySize.SkipSize");
 199                 Assert.IsNull (dsa.KeyExchangeAlgorithm, "KeyExchangeAlgorithm");
 200                 Assert.AreEqual ("http://www.w3.org/2000/09/xmldsig#dsa-sha1", dsa.SignatureAlgorithm);
 201                 dsa.Clear ();
 202                 Assert.AreEqual (1, dsa.LegalKeySizes.Length, "LegalKeySize(disposed)");
 203                 Assert.AreEqual (minKeySize, dsa.LegalKeySizes[0].MinSize, "LegalKeySize.MinSize(disposed)");
 204                 Assert.AreEqual (1024, dsa.LegalKeySizes[0].MaxSize, "LegalKeySize.MaxSize(disposed)");
 205                 Assert.AreEqual (64, dsa.LegalKeySizes[0].SkipSize, "LegalKeySize.SkipSize(disposed)");
 206                 Assert.IsNull (dsa.KeyExchangeAlgorithm, "KeyExchangeAlgorithm(disposed)");
 207                 Assert.AreEqual ("http://www.w3.org/2000/09/xmldsig#dsa-sha1", dsa.SignatureAlgorithm);
 208         }
 209
 210         [Test]
 211         [ExpectedException (typeof (ObjectDisposedException))]
 212         public void CreateSignatureDisposed ()
 213         {
 214                 byte[] hash = new byte [20];
 215                 disposed.CreateSignature (hash);
 216         }
 217
 218         [Test]
 219         [ExpectedException (typeof (CryptographicException))]
 220         public void CreateSignatureInvalidHashLength ()
 221         {
 222                 byte[] hash = new byte [19];
 223                 smallDsa.CreateSignature (hash);
 224         }
 225
 226         [Test]
 227         public void CreateSignature ()
 228         {
 229                 byte[] hash = new byte [20];
 230                 // for Mono, no keypair has yet been generated before calling CreateSignature
 231                 smallDsa.CreateSignature (hash);
 232         }
 233
 234         [Test]
 235         public void SignData ()
 236         {
 237                 byte[] data = new byte [128];
 238                 byte[] signature = smallDsa.SignData (data);
 239                 Assert.IsTrue (smallDsa.VerifyData (data, signature), "SignData");
 240         }
 241
 242         [Test]
 243         [ExpectedException (typeof (ObjectDisposedException))]
 244         public void SignDataDisposed ()
 245         {
 246                 byte[] data = new byte [20];
 247                 disposed.SignData (data);
 248         }
 249
 250         [Test]
 251         [ExpectedException (typeof (ObjectDisposedException))]
 252         public void SignHashDisposed ()
 253         {
 254                 byte[] hash = new byte [20];
 255                 disposed.SignHash (hash, "SHA1");
 256         }
 257
 258         [Test]
 259         [ExpectedException (typeof (CryptographicException))]
 260         public void SignHashInvalidAlgorithm ()
 261         {
 262                 byte[] hash = new byte [16];
 263                 smallDsa.SignHash (hash, "MD5");
 264         }
 265
 266         [Test]
 267         [ExpectedException (typeof (ObjectDisposedException))]
 268         public void VerifyDataDisposed ()
 269         {
 270                 byte[] data = new byte [20];
 271                 byte[] sign = new byte [40];
 272                 disposed.VerifyData (data, sign);
 273         }
 274
 275         [Test]
 276         [ExpectedException (typeof (CryptographicException))]
 277         public void VerifyHashInvalidAlgorithm ()
 278         {
 279                 byte[] hash = new byte [16];
 280                 byte[] sign = new byte [40];
 281                 smallDsa.VerifyHash (hash, "MD5", sign);
 282         }
 283
 284         [Test]
 285         [ExpectedException (typeof (ObjectDisposedException))]
 286         public void VerifyHashDisposed ()
 287         {
 288                 byte[] hash = new byte [20];
 289                 byte[] sign = new byte [40];
 290                 disposed.VerifyHash (hash, "SHA1", sign);
 291         }
 292
 293         [Test]
 294         [ExpectedException (typeof (ObjectDisposedException))]
 295         public void VerifySignatureDisposed ()
 296         {
 297                 byte[] hash = new byte [20];
 298                 byte[] sign = new byte [40];
 299                 disposed.VerifySignature (hash, sign);
 300         }
 301
 302         [Test]
 303         [ExpectedException (typeof (CryptographicException))]
 304         public void VerifySignatureInvalidHashLength ()
 305         {
 306                 byte[] hash = new byte [19];
 307                 byte[] sign = new byte [40];
 308                 smallDsa.VerifySignature (hash, sign);
 309         }
 310
 311         [Test]
 312         [ExpectedException (typeof (CryptographicException))]
 313         public void VerifySignatureInvalidSignatureLength ()
 314         {
 315                 byte[] hash = new byte [20];
 316                 byte[] sign = new byte [39];
 317                 smallDsa.VerifySignature (hash, sign);
 318         }
 319
 320         [Test]
 321         public void VerifySignatureWithoutKey ()
 322         {
 323                 byte[] hash = new byte [20];
 324                 byte[] sign = new byte [40];
 325                 DSACryptoServiceProvider emptyDSA = new DSACryptoServiceProvider (minKeySize);
 326                 // Mono hasn't generated a keypair - but it's impossible to
 327                 // verify a signature based on a new just generated keypair
 328                 Assert.IsFalse (emptyDSA.VerifySignature (hash, sign));
 329         }
 330
 331 #if !NET_2_1
 332         [Test]
 333         [Category ("NotWorking")]
 334         public void ImportDisposed ()
 335         {
 336                 DSACryptoServiceProvider import = new DSACryptoServiceProvider (minKeySize);
 337                 import.Clear ();
 338                 import.ImportParameters (AllTests.GetKey (false));
 339                 // no exception from Fx 2.0 +
 340         }
 341 #endif
 342
 343         [Test]
 344         [ExpectedException (typeof (ObjectDisposedException))]
 345         public void ExportDisposed ()
 346         {
 347                 DSAParameters param = disposed.ExportParameters (false);
 348         }
 349
 350         [Test]
 351         [ExpectedException (typeof (CryptographicException))]
 352         public void DSAImportMissingP ()
 353         {
 354                 DSAParameters input = AllTests.GetKey (false);
 355                 input.P = null;
 356                 dsa = new DSACryptoServiceProvider (1024);
 357                 dsa.ImportParameters (input);
 358         }
 359
 360         [Test]
 361         [ExpectedException (typeof (CryptographicException))]
 362         public void DSAImportMissingQ ()
 363         {
 364                 DSAParameters input = AllTests.GetKey (false);
 365                 input.Q = null;
 366                 dsa = new DSACryptoServiceProvider (1024);
 367                 dsa.ImportParameters (input);
 368         }
 369
 370         [Test]
 371         [ExpectedException (typeof (CryptographicException))]
 372         public void DSAImportMissingG ()
 373         {
 374                 DSAParameters input = AllTests.GetKey (false);
 375                 input.G = null;
 376                 dsa = new DSACryptoServiceProvider (1024);
 377                 dsa.ImportParameters (input);
 378         }
 379
 380         [Test]
 381         [ExpectedException (typeof (CryptographicException))]
 382         public void DSAImportMissingY ()
 383         {
 384                 DSAParameters input = AllTests.GetKey (false);
 385                 input.Y = null;
 386                 dsa = new DSACryptoServiceProvider (1024);
 387                 dsa.ImportParameters (input);
 388         }
 389
 390         [Test]
 391         public void DSAImportMissingJ ()
 392         {
 393                 DSAParameters input = AllTests.GetKey (false);
 394                 input.J = null;
 395                 dsa = new DSACryptoServiceProvider (1024);
 396                 dsa.ImportParameters (input);
 397                 Assert.AreEqual (1024, dsa.KeySize, "MissingJ.KeySize");
 398         }
 399
 400         [Test]
 401         public void DSAImportMissingSeed ()
 402         {
 403                 DSAParameters input = AllTests.GetKey (false);
 404                 input.Seed = null;
 405                 dsa = new DSACryptoServiceProvider (1024);
 406                 dsa.ImportParameters (input);
 407                 Assert.AreEqual (1024, dsa.KeySize, "MissingSeed.KeySize");
 408         }
 409
 410         // all keypairs generated by CryptoAPI on Windows
 411         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>";
 412         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>";
 413         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>";
 414         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>";
 415         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>";
 416         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>";
 417         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>";
 418         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>";
 419         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>";
 420
 421         // import/export XML keypairs
 422         // so we know that Mono can use keypairs generated by CryptoAPI
 423         [Test]
 424         public void CapiXmlImportExport ()
 425         {
 426                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 427
 428                 dsa.FromXmlString (CapiXml512);
 429                 Assert.AreEqual (CapiXml512, dsa.ToXmlString (true), "Capi-Xml512");
 430
 431                 dsa.FromXmlString (CapiXml576);
 432                 Assert.AreEqual (CapiXml576, dsa.ToXmlString (true), "Capi-Xml576");
 433
 434                 dsa.FromXmlString (CapiXml640);
 435                 Assert.AreEqual (CapiXml640, dsa.ToXmlString (true), "Capi-Xml640");
 436
 437                 dsa.FromXmlString (CapiXml704);
 438                 Assert.AreEqual (CapiXml704, dsa.ToXmlString (true), "Capi-Xml704");
 439
 440                 dsa.FromXmlString (CapiXml768);
 441                 Assert.AreEqual (CapiXml768, dsa.ToXmlString (true), "Capi-Xml768");
 442
 443                 dsa.FromXmlString (CapiXml832);
 444                 Assert.AreEqual (CapiXml832, dsa.ToXmlString (true), "Capi-Xml832");
 445
 446                 dsa.FromXmlString (CapiXml896);
 447                 Assert.AreEqual (CapiXml896, dsa.ToXmlString (true), "Capi-Xml896");
 448
 449                 dsa.FromXmlString (CapiXml960);
 450                 Assert.AreEqual (CapiXml960, dsa.ToXmlString (true), "Capi-Xml960");
 451
 452                 dsa.FromXmlString (CapiXml1024);
 453                 Assert.AreEqual (CapiXml1024, dsa.ToXmlString (true), "Capi-Xml1024");
 454         }
 455
 456         private void SignAndVerify (string msg, DSACryptoServiceProvider dsa)
 457         {
 458                 byte[] hash = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13 };
 459                 byte[] sign1 = dsa.CreateSignature (hash);
 460                 byte[] sign2 = dsa.SignData (hash, 0, hash.Length);
 461                 byte[] sign3 = dsa.SignData (new MemoryStream (hash));
 462
 463                 // we don't need the private key to verify
 464                 DSAParameters param = dsa.ExportParameters (false);
 465                 DSACryptoServiceProvider key = (DSACryptoServiceProvider) DSA.Create ();
 466                 key.ImportParameters (param);
 467                 // the signature is never the same so the only way to know if
 468                 // it worked is to verify it ourselve (i.e. can't compare)
 469                 bool ok = key.VerifySignature (hash, sign1);
 470                 Assert.IsTrue (ok, msg + "-CreateSignature-VerifySignature");
 471
 472                 ok = key.VerifyHash (hash, null, sign1);
 473                 Assert.IsTrue (ok, msg + "-CreateSignature-VerifyHash");
 474
 475                 ok = key.VerifyData (hash, sign2);
 476                 Assert.IsTrue (ok, msg + "-SignData(byte[])-VerifyData");
 477
 478                 ok = key.VerifyData (hash, sign3);
 479                 Assert.IsTrue (ok, msg + "-SignData(Stream)-VerifyData");
 480         }
 481
 482         // Validate that we can sign with every keypair and verify the signature
 483         // With Mono this means that we can use CAPI keypair to sign and verify.
 484         // For Windows this doesn't mean much.
 485         [Test]
 486         public void CapiSignature ()
 487         {
 488                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 489
 490                 dsa.FromXmlString (CapiXml512);
 491                 SignAndVerify ("Capi-512", dsa);
 492
 493                 dsa.FromXmlString (CapiXml576);
 494                 SignAndVerify ("Capi-576", dsa);
 495
 496                 dsa.FromXmlString (CapiXml640);
 497                 SignAndVerify ("Capi-640", dsa);
 498
 499                 dsa.FromXmlString (CapiXml704);
 500                 SignAndVerify ("Capi-704", dsa);
 501
 502                 dsa.FromXmlString (CapiXml768);
 503                 SignAndVerify ("Capi-768", dsa);
 504
 505                 dsa.FromXmlString (CapiXml832);
 506                 SignAndVerify ("Capi-832", dsa);
 507
 508                 dsa.FromXmlString (CapiXml896);
 509                 SignAndVerify ("Capi-896", dsa);
 510
 511                 dsa.FromXmlString (CapiXml960);
 512                 SignAndVerify ("Capi-960", dsa);
 513
 514                 dsa.FromXmlString (CapiXml1024);
 515                 SignAndVerify ("Capi-1024", dsa);
 516         }
 517
 518         // Validate that we can verify a signature made with CAPI
 519         // With Mono this means that we can verify CAPI signatures.
 520         // For Windows this doesn't mean much.
 521         [Test]
 522         public void CapiVerify ()
 523         {
 524                 byte[] hash = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13 };
 525                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 526
 527                 dsa.FromXmlString (CapiXml512);
 528                 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 };
 529                 Assert.IsTrue (dsa.VerifySignature (hash, sign512), "Capi-512-Verify");
 530                 sign512[0] = 0x00;
 531                 Assert.IsFalse (dsa.VerifySignature (hash, sign512), "Capi-512-VerBad");
 532
 533                 dsa.FromXmlString (CapiXml576);
 534                 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 };
 535                 Assert.IsTrue (dsa.VerifySignature (hash, sign576), "Capi-576-Verify");
 536                 sign576[0] = 0x00;
 537                 Assert.IsFalse (dsa.VerifySignature (hash, sign576), "Capi-576-VerBad");
 538
 539                 dsa.FromXmlString (CapiXml640);
 540                 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 };
 541                 Assert.IsTrue (dsa.VerifySignature (hash, sign640), "Capi-640-Verify");
 542                 sign640[0] = 0x00;
 543                 Assert.IsFalse (dsa.VerifySignature (hash, sign640), "Capi-640-VerBad");
 544
 545                 dsa.FromXmlString (CapiXml704);
 546                 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 };
 547                 Assert.IsTrue (dsa.VerifySignature (hash, sign704), "Capi-704-Verify");
 548                 sign704[0] = 0x00;
 549                 Assert.IsFalse (dsa.VerifySignature (hash, sign704), "Capi-704-VerBad");
 550
 551                 dsa.FromXmlString (CapiXml768);
 552                 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 };
 553                 Assert.IsTrue (dsa.VerifySignature (hash, sign768), "Capi-768-Verify");
 554                 sign768[0] = 0x00;
 555                 Assert.IsFalse (dsa.VerifySignature (hash, sign768), "Capi-768-VerBad");
 556
 557                 dsa.FromXmlString (CapiXml832);
 558                 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 };
 559                 Assert.IsTrue (dsa.VerifySignature (hash, sign832), "Capi-832-Verify");
 560                 sign832[0] = 0x00;
 561                 Assert.IsFalse (dsa.VerifySignature (hash, sign832), "Capi-832-VerBad");
 562
 563                 dsa.FromXmlString (CapiXml896);
 564                 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 };
 565                 Assert.IsTrue (dsa.VerifySignature (hash, sign896), "Capi-896-Verify");
 566                 sign896[0] = 0x00;
 567                 Assert.IsFalse (dsa.VerifySignature (hash, sign896), "Capi-896-VerBad");
 568
 569                 dsa.FromXmlString (CapiXml960);
 570                 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 };
 571                 Assert.IsTrue (dsa.VerifySignature (hash, sign960), "Capi-960-Verify");
 572                 sign960[0] = 0x00;
 573                 Assert.IsFalse (dsa.VerifySignature (hash, sign960), "Capi-960-VerBad");
 574
 575                 dsa.FromXmlString (CapiXml1024);
 576                 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 };
 577                 Assert.IsTrue (dsa.VerifySignature (hash, sign1024), "Capi-1024-Verify");
 578                 sign1024[0] = 0x00;
 579                 Assert.IsFalse (dsa.VerifySignature (hash, sign1024), "Capi-1024-VerBad");
 580         }
 581
 582         // all keypairs generated by Mono on Windows
 583         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>";
 584         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>";
 585         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>";
 586         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>";
 587         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>";
 588         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>";
 589         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>";
 590         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>";
 591         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>";
 592
 593         // import/export XML keypairs
 594         // so we know that Windows (original MS Framework) can use keypairs generated by Mono
 595         [Test]
 596         public void MonoXmlImportExport ()
 597         {
 598                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 599
 600                 dsa.FromXmlString (MonoXml512);
 601                 Assert.AreEqual (MonoXml512, dsa.ToXmlString (true), "Mono-Xml512");
 602
 603                 dsa.FromXmlString (MonoXml576);
 604                 Assert.AreEqual (MonoXml576, dsa.ToXmlString (true), "Mono-Xml576");
 605
 606                 dsa.FromXmlString (MonoXml640);
 607                 Assert.AreEqual (MonoXml640, dsa.ToXmlString (true), "Mono-Xml640");
 608
 609                 dsa.FromXmlString (MonoXml704);
 610                 Assert.AreEqual (MonoXml704, dsa.ToXmlString (true), "Mono-Xml704");
 611
 612                 dsa.FromXmlString (MonoXml768);
 613                 Assert.AreEqual (MonoXml768, dsa.ToXmlString (true), "Mono-Xml768");
 614
 615                 dsa.FromXmlString (MonoXml832);
 616                 Assert.AreEqual (MonoXml832, dsa.ToXmlString (true), "Mono-Xml832");
 617
 618                 dsa.FromXmlString (MonoXml896);
 619                 Assert.AreEqual (MonoXml896, dsa.ToXmlString (true), "Mono-Xml896");
 620
 621                 dsa.FromXmlString (MonoXml960);
 622                 Assert.AreEqual (MonoXml960, dsa.ToXmlString (true), "Mono-Xml960");
 623
 624                 dsa.FromXmlString (MonoXml1024);
 625                 Assert.AreEqual (MonoXml1024, dsa.ToXmlString (true), "Mono-Xml1024");
 626         }
 627
 628         // Validate that we can sign with every keypair and verify the signature
 629         // With Windows this means that we can use Mono keypairs to sign and verify.
 630         // For Mono this doesn't mean much.
 631         [Test]
 632         public void MonoSignature ()
 633         {
 634                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 635
 636                 dsa.FromXmlString (MonoXml512);
 637                 SignAndVerify ("Mono-512", dsa);
 638
 639                 dsa.FromXmlString (MonoXml576);
 640                 SignAndVerify ("Mono-576", dsa);
 641
 642                 dsa.FromXmlString (MonoXml640);
 643                 SignAndVerify ("Mono-640", dsa);
 644
 645                 dsa.FromXmlString (MonoXml704);
 646                 SignAndVerify ("Mono-704", dsa);
 647
 648                 dsa.FromXmlString (MonoXml768);
 649                 SignAndVerify ("Mono-768", dsa);
 650
 651                 dsa.FromXmlString (MonoXml832);
 652                 SignAndVerify ("Mono-832", dsa);
 653
 654                 dsa.FromXmlString (MonoXml896);
 655                 SignAndVerify ("Mono-896", dsa);
 656
 657                 dsa.FromXmlString (MonoXml960);
 658                 SignAndVerify ("Mono-960", dsa);
 659
 660                 dsa.FromXmlString (MonoXml1024);
 661                 SignAndVerify ("Mono-1024", dsa);
 662         }
 663
 664         // Validate that we can verify a signature made with Mono
 665         // With Windows this means that we can verify Mono signatures.
 666         // For Mono this doesn't mean much.
 667         [Test]
 668         public void MonoVerify ()
 669         {
 670                 byte[] hash = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13 };
 671                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 672
 673                 dsa.FromXmlString (MonoXml512);
 674                 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 };
 675                 Assert.IsTrue (dsa.VerifySignature (hash, sign512), "Mono-512-Verify");
 676                 sign512[0] = 0x00;
 677                 Assert.IsFalse (dsa.VerifySignature (hash, sign512), "Mono-512-VerBad");
 678
 679                 dsa.FromXmlString (MonoXml576);
 680                 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 };
 681                 Assert.IsTrue (dsa.VerifySignature (hash, sign576), "Mono-576-Verify");
 682                 sign576[0] = 0x00;
 683                 Assert.IsFalse (dsa.VerifySignature (hash, sign576), "Mono-576-VerBad");
 684
 685                 dsa.FromXmlString (MonoXml640);
 686                 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 };
 687                 Assert.IsTrue (dsa.VerifySignature (hash, sign640), "Mono-640-Verify");
 688                 sign640[0] = 0x00;
 689                 Assert.IsFalse (dsa.VerifySignature (hash, sign640), "Mono-640-VerBad");
 690
 691                 dsa.FromXmlString (MonoXml704);
 692                 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 };
 693                 Assert.IsTrue (dsa.VerifySignature (hash, sign704), "Mono-704-Verify");
 694                 sign704[0] = 0x00;
 695                 Assert.IsFalse (dsa.VerifySignature (hash, sign704), "Mono-704-VerBad");
 696
 697                 dsa.FromXmlString (MonoXml768);
 698                 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 };
 699                 Assert.IsTrue (dsa.VerifySignature (hash, sign768), "Mono-768-Verify");
 700                 sign768[0] = 0x00;
 701                 Assert.IsFalse (dsa.VerifySignature (hash, sign768), "Mono-768-VerBad");
 702
 703                 dsa.FromXmlString (MonoXml832);
 704                 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 };
 705                 Assert.IsTrue (dsa.VerifySignature (hash, sign832), "Mono-832-Verify");
 706                 sign832[0] = 0x00;
 707                 Assert.IsFalse (dsa.VerifySignature (hash, sign832), "Mono-832-VerBad");
 708
 709                 dsa.FromXmlString (MonoXml896);
 710                 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 };
 711                 Assert.IsTrue (dsa.VerifySignature (hash, sign896), "Mono-896-Verify");
 712                 sign896[0] = 0x00;
 713                 Assert.IsFalse (dsa.VerifySignature (hash, sign896), "Mono-896-VerBad");
 714
 715                 dsa.FromXmlString (MonoXml960);
 716                 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 };
 717                 Assert.IsTrue (dsa.VerifySignature (hash, sign960), "Mono-960-Verify");
 718                 sign960[0] = 0x00;
 719                 Assert.IsFalse (dsa.VerifySignature (hash, sign960), "Mono-960-VerBad");
 720
 721                 dsa.FromXmlString (MonoXml1024);
 722                 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 };
 723                 Assert.IsTrue (dsa.VerifySignature (hash, sign1024), "Mono-1024-Verify");
 724                 sign1024[0] = 0x00;
 725                 Assert.IsFalse (dsa.VerifySignature (hash, sign1024), "Mono-1024-VerBad");
 726         }
 727
 728         // Key Pair Persistence Tests
 729         // References
 730         // a.   .Net Framework Cryptography Frequently Asked Questions, Question 8
 731         //      http://www.gotdotnet.com/team/clr/cryptofaq.htm
 732         // b.   Generating Keys for Encryption and Decryption
 733         //      http://msdn.microsoft.com/library/en-us/cpguide/html/cpcongeneratingkeysforencryptiondecryption.asp
 734
 735         [Test]
 736         [Category ("TargetJvmNotSupported")]
 737         public void Persistence_PersistKeyInCsp_False ()
 738         {
 739                 CspParameters csp = new CspParameters (3, null, "Persistence_PersistKeyInCsp_False");
 740                 // MS generates (or load) keypair here
 741                 // Mono load (if it exists) the keypair here
 742                 DSACryptoServiceProvider dsa1 = new DSACryptoServiceProvider (minKeySize, csp);
 743                 // Mono will generate the keypair here (if it doesn't exists)
 744                 string first = dsa1.ToXmlString (true);
 745
 746                 // persistance is "on" by default when a CspParameters is supplied
 747                 Assert.IsTrue (dsa1.PersistKeyInCsp, "PersistKeyInCsp");
 748
 749                 // this means nothing if we don't call Clear !!!
 750                 dsa1.PersistKeyInCsp = false;
 751                 Assert.IsFalse (dsa1.PersistKeyInCsp, "PersistKeyInCsp");
 752
 753                 // reload using the same container name
 754                 DSACryptoServiceProvider dsa2 = new DSACryptoServiceProvider (minKeySize, csp);
 755                 string second = dsa2.ToXmlString (true);
 756
 757                 Assert.AreEqual (first, second, "Key Pair Same Container");
 758         }
 759
 760         [Test]
 761         [Category ("TargetJvmNotSupported")]
 762         public void Persistence_PersistKeyInCsp_True ()
 763         {
 764                 CspParameters csp = new CspParameters (3, null, "Persistence_PersistKeyInCsp_True");
 765                 // MS generates (or load) keypair here
 766                 // Mono load (if it exists) the keypair here
 767                 DSACryptoServiceProvider dsa1 = new DSACryptoServiceProvider (minKeySize, csp);
 768                 // Mono will generate the keypair here (if it doesn't exists)
 769                 string first = dsa1.ToXmlString (true);
 770
 771                 // persistance is "on" by default
 772                 Assert.IsTrue (dsa1.PersistKeyInCsp, "PersistKeyInCsp");
 773
 774                 // reload using the same container name
 775                 DSACryptoServiceProvider dsa2 = new DSACryptoServiceProvider (minKeySize, csp);
 776                 string second = dsa2.ToXmlString (true);
 777
 778                 Assert.AreEqual (first, second, "Key Pair Same Container");
 779         }
 780
 781         [Test]
 782         [Category ("TargetJvmNotSupported")]
 783         public void Persistence_Delete ()
 784         {
 785                 CspParameters csp = new CspParameters (3, null, "Persistence_Delete");
 786                 // MS generates (or load) keypair here
 787                 // Mono load (if it exists) the keypair here
 788                 DSACryptoServiceProvider dsa1 = new DSACryptoServiceProvider (minKeySize, csp);
 789                 // Mono will generate the keypair here (if it doesn't exists)
 790                 string original = dsa1.ToXmlString (true);
 791
 792                 // note: Delete isn't well documented but can be done by
 793                 // flipping the PersistKeyInCsp to false and back to true.
 794                 dsa1.PersistKeyInCsp = false;
 795                 dsa1.Clear ();
 796
 797                 // recreate using the same container name
 798                 DSACryptoServiceProvider dsa2 = new DSACryptoServiceProvider (minKeySize, csp);
 799                 string newKeyPair = dsa2.ToXmlString (true);
 800
 801                 Assert.IsTrue (original != newKeyPair, "Key Pair Deleted");
 802         }
 803
 804         [Test]
 805         public void PersistKey_True ()
 806         {
 807                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider (minKeySize);
 808                 string key = dsa.ToXmlString (true);
 809                 dsa.PersistKeyInCsp = true;
 810                 Assert.AreEqual (key, dsa.ToXmlString (true), "PersistKeyInCsp-True");
 811         }
 812
 813         [Test]
 814         public void PersistKey_False ()
 815         {
 816                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider (minKeySize);
 817                 string key = dsa.ToXmlString (true);
 818                 dsa.PersistKeyInCsp = false;
 819                 Assert.AreEqual (key, dsa.ToXmlString (true), "PersistKeyInCsp-False");
 820         }
 821
 822         [Test]
 823         public void PersistKey_FalseTrue ()
 824         {
 825                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider (minKeySize);
 826                 string key = dsa.ToXmlString (true);
 827                 dsa.PersistKeyInCsp = false;
 828                 dsa.PersistKeyInCsp = true;
 829                 Assert.AreEqual (key, dsa.ToXmlString (true), "PersistKeyInCsp-FalseTrue");
 830         }
 831
 832         [Test]
 833         public void UseMachineKeyStore_Default ()
 834         {
 835                 Assert.IsFalse (DSACryptoServiceProvider.UseMachineKeyStore);
 836         }
 837
 838         [Test]
 839         [Category ("TargetJvmNotSupported")]
 840         public void UseMachineKeyStore ()
 841         {
 842                 // note only applicable when CspParameters isn't used - which don't
 843                 // help much as you can't know the generated key container name
 844                 try {
 845                         DSACryptoServiceProvider.UseMachineKeyStore = true;
 846                         CspParameters csp = new CspParameters (13, null, "UseMachineKeyStore");
 847                         csp.KeyContainerName = "UseMachineKeyStore";
 848                         DSACryptoServiceProvider dsa = new DSACryptoServiceProvider (csp);
 849                         string machineKeyPair = dsa.ToXmlString (true);
 850                         dsa.Clear ();
 851
 852                         DSACryptoServiceProvider.UseMachineKeyStore = false;
 853                         csp = new CspParameters (13, null, "UseMachineKeyStore");
 854                         csp.Flags |= CspProviderFlags.UseMachineKeyStore;
 855                         dsa = new DSACryptoServiceProvider (csp);
 856
 857                         Assert.IsTrue (machineKeyPair != dsa.ToXmlString (true), "UseMachineKeyStore");
 858                 }
 859                 catch (CryptographicException ce) {
 860                         // only root can create the required directory (if inexistant)
 861                         // afterward anyone can use (read from) it
 862                         if (!(ce.InnerException is UnauthorizedAccessException))
 863                                 throw;
 864                 }
 865                 catch (UnauthorizedAccessException) {
 866                 }
 867         }
 868
 869 #if !NET_2_1
 870         [Test]
 871         [Category ("NotWorking")]
 872         public void CspKeyContainerInfo_NewKeypair ()
 873         {
 874                 dsa = new DSACryptoServiceProvider (minKeySize);
 875                 CspKeyContainerInfo info = dsa.CspKeyContainerInfo;
 876                 Assert.IsTrue (info.Accessible, "Accessible");
 877                 // FIXME        AssertNotNull ("CryptoKeySecurity", info.CryptoKeySecurity);
 878                 Assert.IsTrue (info.Exportable, "Exportable");
 879                 Assert.IsFalse (info.HardwareDevice, "HardwareDevice");
 880                 Assert.IsNotNull (info.KeyContainerName, "KeyContainerName");
 881                 Assert.AreEqual (KeyNumber.Signature, info.KeyNumber, "KeyNumber");
 882                 Assert.IsFalse (info.MachineKeyStore, "MachineKeyStore");
 883                 Assert.IsFalse (info.Protected, "Protected");
 884                 Assert.IsNotNull (info.ProviderName, "ProviderName");
 885                 Assert.AreEqual (13, info.ProviderType, "ProviderType");
 886                 Assert.IsTrue (info.RandomlyGenerated, "RandomlyGenerated");
 887                 Assert.IsFalse (info.Removable, "Removable");
 888                 Assert.IsNotNull (info.UniqueKeyContainerName, "UniqueKeyContainerName");
 889         }
 890
 891         [Test]
 892         [Category ("NotWorking")]
 893         public void CspKeyContainerInfo_ImportedKeypair ()
 894         {
 895                 dsa = new DSACryptoServiceProvider (minKeySize);
 896                 DSAParameters rsap = AllTests.GetKey (true);
 897                 dsa.ImportParameters (rsap);
 898                 CspKeyContainerInfo info = dsa.CspKeyContainerInfo;
 899                 Assert.IsTrue (info.Accessible, "Accessible");
 900 // FIXME        AssertNotNull ("CryptoKeySecurity", info.CryptoKeySecurity);
 901                 Assert.IsTrue (info.Exportable, "Exportable");
 902                 Assert.IsFalse (info.HardwareDevice, "HardwareDevice");
 903                 Assert.IsNotNull (info.KeyContainerName, "KeyContainerName");
 904                 Assert.AreEqual (KeyNumber.Signature, info.KeyNumber, "KeyNumber");
 905                 Assert.IsFalse (info.MachineKeyStore, "MachineKeyStore");
 906                 Assert.IsFalse (info.Protected, "Protected");
 907                 Assert.IsNotNull (info.ProviderName, "ProviderName");
 908                 Assert.AreEqual (13, info.ProviderType, "ProviderType");
 909                 Assert.IsTrue (info.RandomlyGenerated, "RandomlyGenerated");
 910                 Assert.IsFalse (info.Removable, "Removable");
 911                 Assert.IsNotNull (info.UniqueKeyContainerName, "UniqueKeyContainerName");
 912         }
 913
 914         [Test]
 915         [Category ("NotWorking")]
 916         // This case wasn't fixed in Nov CTP
 917         public void CspKeyContainerInfo_ImportedPublicKey ()
 918         {
 919                 dsa = new DSACryptoServiceProvider (minKeySize);
 920                 DSAParameters rsap = AllTests.GetKey (false);
 921                 dsa.ImportParameters (rsap);
 922                 CspKeyContainerInfo info = dsa.CspKeyContainerInfo;
 923                 Assert.IsFalse (info.Accessible, "Accessible");
 924                 // info.CryptoKeySecurity throws a CryptographicException at this stage
 925                 // info.Exportable throws a CryptographicException at this stage
 926                 Assert.IsFalse (info.HardwareDevice, "HardwareDevice");
 927                 Assert.IsNotNull (info.KeyContainerName, "KeyContainerName");
 928                 Assert.AreEqual (KeyNumber.Signature, info.KeyNumber, "KeyNumber");
 929                 Assert.IsFalse (info.MachineKeyStore, "MachineKeyStore");
 930                 // info.Protected throws a CryptographicException at this stage
 931                 Assert.IsNotNull (info.ProviderName, "ProviderName");
 932                 Assert.AreEqual (13, info.ProviderType, "ProviderType");
 933                 Assert.IsTrue (info.RandomlyGenerated, "RandomlyGenerated");
 934                 Assert.IsFalse (info.Removable, "Removable");
 935                 // info.UniqueKeyContainerName throws a CryptographicException at this stage
 936         }
 937 #endif
 938
 939         [Test]
 940         public void ExportCspBlob_Full ()
 941         {
 942                 dsa = new DSACryptoServiceProvider (minKeySize);
 943                 DSAParameters dsap = AllTests.GetKey (true);
 944                 dsa.ImportParameters (dsap);
 945
 946                 byte[] keypair = dsa.ExportCspBlob (true);
 947                 Assert.AreEqual ("07-02-00-00-00-22-00-00-44-53-53-32-00-04-00-00-D3-7B-C6-ED-3F-72-44-BD-22-7D-F2-D4-62-FE-7C-E3-75-8F-9C-DE-69-C0-3A-0C-E6-26-5A-46-3D-EF-0D-90-20-C6-F6-45-7C-73-E8-B9-7D-86-27-F7-97-76-C8-1C-8E-8B-CE-26-93-E6-21-53-20-93-58-25-45-1C-46-66-17-10-98-03-96-D0-E5-C8-30-80-72-B6-49-B3-82-95-B3-8D-3A-A5-E5-60-C6-42-3A-33-70-67-30-C5-1C-32-D9-EB-CF-C1-36-B3-F3-24-07-39-86-0D-E9-12-80-73-26-A7-8C-8B-8A-40-AA-51-43-8F-20-DE-D2-9C-F3-B3-51-73-83-62-A0-11-C9-50-93-E1-F0-64-BE-D0-9E-E0-5B-13-47-AA-56-65-62-47-FD-3A-94-B7-1B-E5-35-95-86-14-64-C0-D6-07-96-4C-55-1E-0A-4C-10-C2-B5-E6-FB-74-F9-A5-72-E0-42-96-62-0B-EF-B7-52-36-7D-E3-01-12-85-E6-FE-92-75-40-C2-A6-D0-9D-16-6F-C1-C7-A7-DF-48-80-A2-5D-A0-FD-84-BE-06-AC-CB-32-22-82-D2-D7-7C-69-FC-BC-94-78-2B-11-5B-1C-1E-AF-DB-7A-AA-31-F3-D8-74-84-00-3F-9D-B9-4B-B2-68-7E-F4-1B-C2-83-73-21-78-0F-D5-0F-B0-EB-76-41-F1-23-7A-6A-78-CC-4F-3D-B1-2F-0A-F6-9A-A7-18-C1-2F-F0-B7-73-91-51-6D-9B-B5-B2-03-7C-E0-00-00-00-9B-AF-1B-E9-C1-C7-35-F5-E2-EB-C9-EE-F6-BA-25-6D-6F-39-83-B9", BitConverter.ToString (keypair));
 948         }
 949
 950         [Test]
 951         public void ExportCspBlob_PublicOnly ()
 952         {
 953                 dsa = new DSACryptoServiceProvider (minKeySize);
 954                 DSAParameters dsap = AllTests.GetKey (true);
 955                 dsa.ImportParameters (dsap);
 956
 957                 byte[] pubkey = dsa.ExportCspBlob (false);
 958                 Assert.AreEqual ("06-02-00-00-00-22-00-00-44-53-53-31-00-04-00-00-D3-7B-C6-ED-3F-72-44-BD-22-7D-F2-D4-62-FE-7C-E3-75-8F-9C-DE-69-C0-3A-0C-E6-26-5A-46-3D-EF-0D-90-20-C6-F6-45-7C-73-E8-B9-7D-86-27-F7-97-76-C8-1C-8E-8B-CE-26-93-E6-21-53-20-93-58-25-45-1C-46-66-17-10-98-03-96-D0-E5-C8-30-80-72-B6-49-B3-82-95-B3-8D-3A-A5-E5-60-C6-42-3A-33-70-67-30-C5-1C-32-D9-EB-CF-C1-36-B3-F3-24-07-39-86-0D-E9-12-80-73-26-A7-8C-8B-8A-40-AA-51-43-8F-20-DE-D2-9C-F3-B3-51-73-83-62-A0-11-C9-50-93-E1-F0-64-BE-D0-9E-E0-5B-13-47-AA-56-65-62-47-FD-3A-94-B7-1B-E5-35-95-86-14-64-C0-D6-07-96-4C-55-1E-0A-4C-10-C2-B5-E6-FB-74-F9-A5-72-E0-42-96-62-0B-EF-B7-52-36-7D-E3-01-12-85-E6-FE-92-75-40-C2-A6-D0-9D-16-6F-C1-C7-A7-DF-48-80-A2-5D-A0-FD-84-BE-06-AC-CB-32-22-82-D2-D7-7C-69-FC-BC-94-78-2B-11-5B-1C-1E-AF-DB-7A-AA-31-F3-D8-74-84-00-3F-9D-B9-4B-B2-68-7E-F4-1B-C2-83-73-21-78-0F-D5-0F-B0-EB-76-41-F1-23-7A-6A-78-CC-4F-3D-BB-C7-03-89-C4-0B-66-86-80-D5-AA-34-E8-14-71-F9-29-BE-B9-EE-34-B1-5F-A2-C8-4D-CD-CF-0E-8E-A4-2E-D4-65-8C-27-FF-C1-41-26-F9-0E-E5-11-C9-CC-3E-45-87-EC-49-BA-7C-83-91-DE-70-E8-27-1C-47-EB-1D-E2-37-62-2F-AA-5B-30-80-8B-80-00-55-F4-64-C2-BE-5A-D3-54-4A-E7-0B-95-00-F4-BA-72-CD-F8-22-E6-30-4E-F6-BD-BE-3F-00-52-7F-E2-57-5F-C0-BE-82-C0-50-07-1C-7D-89-56-49-CE-28-52-8C-11-B1-D1-51-51-12-B2-E0-00-00-00-9B-AF-1B-E9-C1-C7-35-F5-E2-EB-C9-EE-F6-BA-25-6D-6F-39-83-B9", BitConverter.ToString (pubkey));
 959         }
 960
 961         [Test]
 962         [ExpectedException (typeof (CryptographicException))]
 963         public void ExportCspBlob_MissingPrivateKey ()
 964         {
 965                 dsa = new DSACryptoServiceProvider (minKeySize);
 966                 DSAParameters dsap = AllTests.GetKey (false);
 967                 dsa.ImportParameters (dsap);
 968
 969                 dsa.ExportCspBlob (true);
 970         }
 971
 972         [Test]
 973         public void ExportCspBlob_MissingPrivateKey_PublicOnly ()
 974         {
 975                 dsa = new DSACryptoServiceProvider (minKeySize);
 976                 DSAParameters dsap = AllTests.GetKey (false);
 977                 dsa.ImportParameters (dsap);
 978
 979                 byte[] pubkey = dsa.ExportCspBlob (false);
 980                 Assert.AreEqual ("06-02-00-00-00-22-00-00-44-53-53-31-00-04-00-00-D3-7B-C6-ED-3F-72-44-BD-22-7D-F2-D4-62-FE-7C-E3-75-8F-9C-DE-69-C0-3A-0C-E6-26-5A-46-3D-EF-0D-90-20-C6-F6-45-7C-73-E8-B9-7D-86-27-F7-97-76-C8-1C-8E-8B-CE-26-93-E6-21-53-20-93-58-25-45-1C-46-66-17-10-98-03-96-D0-E5-C8-30-80-72-B6-49-B3-82-95-B3-8D-3A-A5-E5-60-C6-42-3A-33-70-67-30-C5-1C-32-D9-EB-CF-C1-36-B3-F3-24-07-39-86-0D-E9-12-80-73-26-A7-8C-8B-8A-40-AA-51-43-8F-20-DE-D2-9C-F3-B3-51-73-83-62-A0-11-C9-50-93-E1-F0-64-BE-D0-9E-E0-5B-13-47-AA-56-65-62-47-FD-3A-94-B7-1B-E5-35-95-86-14-64-C0-D6-07-96-4C-55-1E-0A-4C-10-C2-B5-E6-FB-74-F9-A5-72-E0-42-96-62-0B-EF-B7-52-36-7D-E3-01-12-85-E6-FE-92-75-40-C2-A6-D0-9D-16-6F-C1-C7-A7-DF-48-80-A2-5D-A0-FD-84-BE-06-AC-CB-32-22-82-D2-D7-7C-69-FC-BC-94-78-2B-11-5B-1C-1E-AF-DB-7A-AA-31-F3-D8-74-84-00-3F-9D-B9-4B-B2-68-7E-F4-1B-C2-83-73-21-78-0F-D5-0F-B0-EB-76-41-F1-23-7A-6A-78-CC-4F-3D-BB-C7-03-89-C4-0B-66-86-80-D5-AA-34-E8-14-71-F9-29-BE-B9-EE-34-B1-5F-A2-C8-4D-CD-CF-0E-8E-A4-2E-D4-65-8C-27-FF-C1-41-26-F9-0E-E5-11-C9-CC-3E-45-87-EC-49-BA-7C-83-91-DE-70-E8-27-1C-47-EB-1D-E2-37-62-2F-AA-5B-30-80-8B-80-00-55-F4-64-C2-BE-5A-D3-54-4A-E7-0B-95-00-F4-BA-72-CD-F8-22-E6-30-4E-F6-BD-BE-3F-00-52-7F-E2-57-5F-C0-BE-82-C0-50-07-1C-7D-89-56-49-CE-28-52-8C-11-B1-D1-51-51-12-B2-E0-00-00-00-9B-AF-1B-E9-C1-C7-35-F5-E2-EB-C9-EE-F6-BA-25-6D-6F-39-83-B9", BitConverter.ToString (pubkey));
 981         }
 982
 983         [Test]
 984         public void ImportCspBlob_Keypair ()
 985         {
 986                 byte[] blob = new byte [336] { 0x07, 0x02, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x44, 0x53, 0x53, 0x32, 0x00, 0x04, 0x00, 0x00, 0xD3,
 987                         0x7B, 0xC6, 0xED, 0x3F, 0x72, 0x44, 0xBD, 0x22, 0x7D, 0xF2, 0xD4, 0x62, 0xFE, 0x7C, 0xE3, 0x75, 0x8F, 0x9C, 0xDE, 0x69, 0xC0, 0x3A,
 988                         0x0C, 0xE6, 0x26, 0x5A, 0x46, 0x3D, 0xEF, 0x0D, 0x90, 0x20, 0xC6, 0xF6, 0x45, 0x7C, 0x73, 0xE8, 0xB9, 0x7D, 0x86, 0x27, 0xF7, 0x97,
 989                         0x76, 0xC8, 0x1C, 0x8E, 0x8B, 0xCE, 0x26, 0x93, 0xE6, 0x21, 0x53, 0x20, 0x93, 0x58, 0x25, 0x45, 0x1C, 0x46, 0x66, 0x17, 0x10, 0x98,
 990                         0x03, 0x96, 0xD0, 0xE5, 0xC8, 0x30, 0x80, 0x72, 0xB6, 0x49, 0xB3, 0x82, 0x95, 0xB3, 0x8D, 0x3A, 0xA5, 0xE5, 0x60, 0xC6, 0x42, 0x3A,
 991                         0x33, 0x70, 0x67, 0x30, 0xC5, 0x1C, 0x32, 0xD9, 0xEB, 0xCF, 0xC1, 0x36, 0xB3, 0xF3, 0x24, 0x07, 0x39, 0x86, 0x0D, 0xE9, 0x12, 0x80,
 992                         0x73, 0x26, 0xA7, 0x8C, 0x8B, 0x8A, 0x40, 0xAA, 0x51, 0x43, 0x8F, 0x20, 0xDE, 0xD2, 0x9C, 0xF3, 0xB3, 0x51, 0x73, 0x83, 0x62, 0xA0,
 993                         0x11, 0xC9, 0x50, 0x93, 0xE1, 0xF0, 0x64, 0xBE, 0xD0, 0x9E, 0xE0, 0x5B, 0x13, 0x47, 0xAA, 0x56, 0x65, 0x62, 0x47, 0xFD, 0x3A, 0x94,
 994                         0xB7, 0x1B, 0xE5, 0x35, 0x95, 0x86, 0x14, 0x64, 0xC0, 0xD6, 0x07, 0x96, 0x4C, 0x55, 0x1E, 0x0A, 0x4C, 0x10, 0xC2, 0xB5, 0xE6, 0xFB,
 995                         0x74, 0xF9, 0xA5, 0x72, 0xE0, 0x42, 0x96, 0x62, 0x0B, 0xEF, 0xB7, 0x52, 0x36, 0x7D, 0xE3, 0x01, 0x12, 0x85, 0xE6, 0xFE, 0x92, 0x75,
 996                         0x40, 0xC2, 0xA6, 0xD0, 0x9D, 0x16, 0x6F, 0xC1, 0xC7, 0xA7, 0xDF, 0x48, 0x80, 0xA2, 0x5D, 0xA0, 0xFD, 0x84, 0xBE, 0x06, 0xAC, 0xCB,
 997                         0x32, 0x22, 0x82, 0xD2, 0xD7, 0x7C, 0x69, 0xFC, 0xBC, 0x94, 0x78, 0x2B, 0x11, 0x5B, 0x1C, 0x1E, 0xAF, 0xDB, 0x7A, 0xAA, 0x31, 0xF3,
 998                         0xD8, 0x74, 0x84, 0x00, 0x3F, 0x9D, 0xB9, 0x4B, 0xB2, 0x68, 0x7E, 0xF4, 0x1B, 0xC2, 0x83, 0x73, 0x21, 0x78, 0x0F, 0xD5, 0x0F, 0xB0,
 999                         0xEB, 0x76, 0x41, 0xF1, 0x23, 0x7A, 0x6A, 0x78, 0xCC, 0x4F, 0x3D, 0xB1, 0x2F, 0x0A, 0xF6, 0x9A, 0xA7, 0x18, 0xC1, 0x2F, 0xF0, 0xB7,
1000                         0x73, 0x91, 0x51, 0x6D, 0x9B, 0xB5, 0xB2, 0x03, 0x7C, 0xE0, 0x00, 0x00, 0x00, 0x9B, 0xAF, 0x1B, 0xE9, 0xC1, 0xC7, 0x35, 0xF5, 0xE2,
1001                         0xEB, 0xC9, 0xEE, 0xF6, 0xBA, 0x25, 0x6D, 0x6F, 0x39, 0x83, 0xB9 };
1002                 dsa = new DSACryptoServiceProvider (minKeySize);
1003                 dsa.ImportCspBlob (blob);
1004
1005                 byte[] keypair = dsa.ExportCspBlob (true);
1006                 for (int i = 0; i < blob.Length; i++)
1007                         Assert.AreEqual (blob[i], keypair[i], i.ToString ());
1008         }
1009
1010         [Test]
1011         public void ExportCspBlob_PublicKey ()
1012         {
1013                 byte[] blob = new byte [444] { 0x06, 0x02, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x44, 0x53, 0x53, 0x31, 0x00, 0x04, 0x00, 0x00, 0xD3,
1014                         0x7B, 0xC6, 0xED, 0x3F, 0x72, 0x44, 0xBD, 0x22, 0x7D, 0xF2, 0xD4, 0x62, 0xFE, 0x7C, 0xE3, 0x75, 0x8F, 0x9C, 0xDE, 0x69, 0xC0, 0x3A,
1015                         0x0C, 0xE6, 0x26, 0x5A, 0x46, 0x3D, 0xEF, 0x0D, 0x90, 0x20, 0xC6, 0xF6, 0x45, 0x7C, 0x73, 0xE8, 0xB9, 0x7D, 0x86, 0x27, 0xF7, 0x97,
1016                         0x76, 0xC8, 0x1C, 0x8E, 0x8B, 0xCE, 0x26, 0x93, 0xE6, 0x21, 0x53, 0x20, 0x93, 0x58, 0x25, 0x45, 0x1C, 0x46, 0x66, 0x17, 0x10, 0x98,
1017                         0x03, 0x96, 0xD0, 0xE5, 0xC8, 0x30, 0x80, 0x72, 0xB6, 0x49, 0xB3, 0x82, 0x95, 0xB3, 0x8D, 0x3A, 0xA5, 0xE5, 0x60, 0xC6, 0x42, 0x3A,
1018                         0x33, 0x70, 0x67, 0x30, 0xC5, 0x1C, 0x32, 0xD9, 0xEB, 0xCF, 0xC1, 0x36, 0xB3, 0xF3, 0x24, 0x07, 0x39, 0x86, 0x0D, 0xE9, 0x12, 0x80,
1019                         0x73, 0x26, 0xA7, 0x8C, 0x8B, 0x8A, 0x40, 0xAA, 0x51, 0x43, 0x8F, 0x20, 0xDE, 0xD2, 0x9C, 0xF3, 0xB3, 0x51, 0x73, 0x83, 0x62, 0xA0,
1020                         0x11, 0xC9, 0x50, 0x93, 0xE1, 0xF0, 0x64, 0xBE, 0xD0, 0x9E, 0xE0, 0x5B, 0x13, 0x47, 0xAA, 0x56, 0x65, 0x62, 0x47, 0xFD, 0x3A, 0x94,
1021                         0xB7, 0x1B, 0xE5, 0x35, 0x95, 0x86, 0x14, 0x64, 0xC0, 0xD6, 0x07, 0x96, 0x4C, 0x55, 0x1E, 0x0A, 0x4C, 0x10, 0xC2, 0xB5, 0xE6, 0xFB,
1022                         0x74, 0xF9, 0xA5, 0x72, 0xE0, 0x42, 0x96, 0x62, 0x0B, 0xEF, 0xB7, 0x52, 0x36, 0x7D, 0xE3, 0x01, 0x12, 0x85, 0xE6, 0xFE, 0x92, 0x75,
1023                         0x40, 0xC2, 0xA6, 0xD0, 0x9D, 0x16, 0x6F, 0xC1, 0xC7, 0xA7, 0xDF, 0x48, 0x80, 0xA2, 0x5D, 0xA0, 0xFD, 0x84, 0xBE, 0x06, 0xAC, 0xCB,
1024                         0x32, 0x22, 0x82, 0xD2, 0xD7, 0x7C, 0x69, 0xFC, 0xBC, 0x94, 0x78, 0x2B, 0x11, 0x5B, 0x1C, 0x1E, 0xAF, 0xDB, 0x7A, 0xAA, 0x31, 0xF3,
1025                         0xD8, 0x74, 0x84, 0x00, 0x3F, 0x9D, 0xB9, 0x4B, 0xB2, 0x68, 0x7E, 0xF4, 0x1B, 0xC2, 0x83, 0x73, 0x21, 0x78, 0x0F, 0xD5, 0x0F, 0xB0,
1026                         0xEB, 0x76, 0x41, 0xF1, 0x23, 0x7A, 0x6A, 0x78, 0xCC, 0x4F, 0x3D, 0xBB, 0xC7, 0x03, 0x89, 0xC4, 0x0B, 0x66, 0x86, 0x80, 0xD5, 0xAA,
1027                         0x34, 0xE8, 0x14, 0x71, 0xF9, 0x29, 0xBE, 0xB9, 0xEE, 0x34, 0xB1, 0x5F, 0xA2, 0xC8, 0x4D, 0xCD, 0xCF, 0x0E, 0x8E, 0xA4, 0x2E, 0xD4,
1028                         0x65, 0x8C, 0x27, 0xFF, 0xC1, 0x41, 0x26, 0xF9, 0x0E, 0xE5, 0x11, 0xC9, 0xCC, 0x3E, 0x45, 0x87, 0xEC, 0x49, 0xBA, 0x7C, 0x83, 0x91,
1029                         0xDE, 0x70, 0xE8, 0x27, 0x1C, 0x47, 0xEB, 0x1D, 0xE2, 0x37, 0x62, 0x2F, 0xAA, 0x5B, 0x30, 0x80, 0x8B, 0x80, 0x00, 0x55, 0xF4, 0x64,
1030                         0xC2, 0xBE, 0x5A, 0xD3, 0x54, 0x4A, 0xE7, 0x0B, 0x95, 0x00, 0xF4, 0xBA, 0x72, 0xCD, 0xF8, 0x22, 0xE6, 0x30, 0x4E, 0xF6, 0xBD, 0xBE,
1031                         0x3F, 0x00, 0x52, 0x7F, 0xE2, 0x57, 0x5F, 0xC0, 0xBE, 0x82, 0xC0, 0x50, 0x07, 0x1C, 0x7D, 0x89, 0x56, 0x49, 0xCE, 0x28, 0x52, 0x8C,
1032                         0x11, 0xB1, 0xD1, 0x51, 0x51, 0x12, 0xB2, 0xE0, 0x00, 0x00, 0x00, 0x9B, 0xAF, 0x1B, 0xE9, 0xC1, 0xC7, 0x35, 0xF5, 0xE2, 0xEB, 0xC9,
1033                         0xEE, 0xF6, 0xBA, 0x25, 0x6D, 0x6F, 0x39, 0x83, 0xB9 };
1034                 dsa = new DSACryptoServiceProvider (minKeySize);
1035                 dsa.ImportCspBlob (blob);
1036
1037                 byte[] pubkey = dsa.ExportCspBlob (false);
1038                 for (int i = 0; i < blob.Length; i++)
1039                         Assert.AreEqual (blob[i], pubkey[i], i.ToString ());
1040         }
1041
1042         [Test]
1043         [ExpectedException (typeof (ArgumentNullException))]
1044         public void ImportCspBlob_Null ()
1045         {
1046                 dsa = new DSACryptoServiceProvider (minKeySize);
1047                 dsa.ImportCspBlob (null);
1048         }
1049
1050         [Test]
1051         [ExpectedException (typeof (CryptographicException))]
1052         public void ImportCspBlob_Bad ()
1053         {
1054                 byte[] blob = new byte [148]; // valid size for public key
1055                 dsa = new DSACryptoServiceProvider (minKeySize);
1056                 dsa.ImportCspBlob (blob);
1057         }
1058 }
1059
1060 }