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