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         [Category ("NotWorking")]
 350         public void ImportDisposed ()
 351         {
 352                 DSACryptoServiceProvider import = new DSACryptoServiceProvider (minKeySize);
 353                 import.Clear ();
 354                 import.ImportParameters (AllTests.GetKey (false));
 355                 // no exception from Fx 2.0 +
 356         }
 357 #else
 358         [Test]
 359         [ExpectedException (typeof (ObjectDisposedException))]
 360         public void ImportDisposed ()
 361         {
 362                 disposed.ImportParameters (AllTests.GetKey (false));
 363         }
 364 #endif
 365
 366         [Test]
 367         [ExpectedException (typeof (ObjectDisposedException))]
 368         public void ExportDisposed ()
 369         {
 370                 DSAParameters param = disposed.ExportParameters (false);
 371         }
 372
 373         [Test]
 374         [ExpectedException (typeof (CryptographicException))]
 375         public void DSAImportMissingP ()
 376         {
 377                 DSAParameters input = AllTests.GetKey (false);
 378                 input.P = null;
 379                 dsa = new DSACryptoServiceProvider (1024);
 380                 dsa.ImportParameters (input);
 381         }
 382
 383         [Test]
 384         [ExpectedException (typeof (CryptographicException))]
 385         public void DSAImportMissingQ ()
 386         {
 387                 DSAParameters input = AllTests.GetKey (false);
 388                 input.Q = null;
 389                 dsa = new DSACryptoServiceProvider (1024);
 390                 dsa.ImportParameters (input);
 391         }
 392
 393         [Test]
 394         [ExpectedException (typeof (CryptographicException))]
 395         public void DSAImportMissingG ()
 396         {
 397                 DSAParameters input = AllTests.GetKey (false);
 398                 input.G = null;
 399                 dsa = new DSACryptoServiceProvider (1024);
 400                 dsa.ImportParameters (input);
 401         }
 402
 403         [Test]
 404         [ExpectedException (typeof (CryptographicException))]
 405 #if ! NET_2_0
 406         [Category ("NotDotNet")] // MS runtime throws a System.ExecutionEngineException then exit the application
 407 #endif
 408         public void DSAImportMissingY ()
 409         {
 410                 DSAParameters input = AllTests.GetKey (false);
 411                 input.Y = null;
 412                 dsa = new DSACryptoServiceProvider (1024);
 413                 dsa.ImportParameters (input);
 414         }
 415
 416         [Test]
 417         public void DSAImportMissingJ ()
 418         {
 419                 DSAParameters input = AllTests.GetKey (false);
 420                 input.J = null;
 421                 dsa = new DSACryptoServiceProvider (1024);
 422                 dsa.ImportParameters (input);
 423                 AssertEquals ("MissingJ.KeySize", 1024, dsa.KeySize);
 424         }
 425
 426         [Test]
 427         public void DSAImportMissingSeed ()
 428         {
 429                 DSAParameters input = AllTests.GetKey (false);
 430                 input.Seed = null;
 431                 dsa = new DSACryptoServiceProvider (1024);
 432                 dsa.ImportParameters (input);
 433                 AssertEquals ("MissingSeed.KeySize", 1024, dsa.KeySize);
 434         }
 435
 436         // all keypairs generated by CryptoAPI on Windows
 437         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>";
 438         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>";
 439         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>";
 440         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>";
 441         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>";
 442         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>";
 443         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>";
 444         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>";
 445         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>";
 446
 447         // import/export XML keypairs
 448         // so we know that Mono can use keypairs generated by CryptoAPI
 449         [Test]
 450         public void CapiXmlImportExport ()
 451         {
 452                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 453
 454                 dsa.FromXmlString (CapiXml512);
 455                 AssertEquals ("Capi-Xml512", CapiXml512, dsa.ToXmlString (true));
 456
 457                 dsa.FromXmlString (CapiXml576);
 458                 AssertEquals ("Capi-Xml576", CapiXml576, dsa.ToXmlString (true));
 459
 460                 dsa.FromXmlString (CapiXml640);
 461                 AssertEquals ("Capi-Xml640", CapiXml640, dsa.ToXmlString (true));
 462
 463                 dsa.FromXmlString (CapiXml704);
 464                 AssertEquals ("Capi-Xml704", CapiXml704, dsa.ToXmlString (true));
 465
 466                 dsa.FromXmlString (CapiXml768);
 467                 AssertEquals ("Capi-Xml768", CapiXml768, dsa.ToXmlString (true));
 468
 469                 dsa.FromXmlString (CapiXml832);
 470                 AssertEquals ("Capi-Xml832", CapiXml832, dsa.ToXmlString (true));
 471
 472                 dsa.FromXmlString (CapiXml896);
 473                 AssertEquals ("Capi-Xml896", CapiXml896, dsa.ToXmlString (true));
 474
 475                 dsa.FromXmlString (CapiXml960);
 476                 AssertEquals ("Capi-Xml960", CapiXml960, dsa.ToXmlString (true));
 477
 478                 dsa.FromXmlString (CapiXml1024);
 479                 AssertEquals ("Capi-Xml1024", CapiXml1024, dsa.ToXmlString (true));
 480         }
 481
 482         private void SignAndVerify (string msg, DSACryptoServiceProvider dsa)
 483         {
 484                 byte[] hash = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13 };
 485                 byte[] sign1 = dsa.CreateSignature (hash);
 486                 byte[] sign2 = dsa.SignData (hash, 0, hash.Length);
 487                 byte[] sign3 = dsa.SignData (new MemoryStream (hash));
 488
 489                 // we don't need the private key to verify
 490                 DSAParameters param = dsa.ExportParameters (false);
 491                 DSACryptoServiceProvider key = (DSACryptoServiceProvider) DSA.Create ();
 492                 key.ImportParameters (param);
 493                 // the signature is never the same so the only way to know if
 494                 // it worked is to verify it ourselve (i.e. can't compare)
 495                 bool ok = key.VerifySignature (hash, sign1);
 496                 Assert (msg + "-CreateSignature-VerifySignature", ok);
 497
 498                 ok = key.VerifyHash (hash, null, sign1);
 499                 Assert (msg + "-CreateSignature-VerifyHash", ok);
 500
 501                 ok = key.VerifyData (hash, sign2);
 502                 Assert (msg + "-SignData(byte[])-VerifyData", ok);
 503
 504                 ok = key.VerifyData (hash, sign3);
 505                 Assert (msg + "-SignData(Stream)-VerifyData", ok);
 506         }
 507
 508         // Validate that we can sign with every keypair and verify the signature
 509         // With Mono this means that we can use CAPI keypair to sign and verify.
 510         // For Windows this doesn't mean much.
 511         [Test]
 512         public void CapiSignature ()
 513         {
 514                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 515
 516                 dsa.FromXmlString (CapiXml512);
 517                 SignAndVerify ("Capi-512", dsa);
 518
 519                 dsa.FromXmlString (CapiXml576);
 520                 SignAndVerify ("Capi-576", dsa);
 521
 522                 dsa.FromXmlString (CapiXml640);
 523                 SignAndVerify ("Capi-640", dsa);
 524
 525                 dsa.FromXmlString (CapiXml704);
 526                 SignAndVerify ("Capi-704", dsa);
 527
 528                 dsa.FromXmlString (CapiXml768);
 529                 SignAndVerify ("Capi-768", dsa);
 530
 531                 dsa.FromXmlString (CapiXml832);
 532                 SignAndVerify ("Capi-832", dsa);
 533
 534                 dsa.FromXmlString (CapiXml896);
 535                 SignAndVerify ("Capi-896", dsa);
 536
 537                 dsa.FromXmlString (CapiXml960);
 538                 SignAndVerify ("Capi-960", dsa);
 539
 540                 dsa.FromXmlString (CapiXml1024);
 541                 SignAndVerify ("Capi-1024", dsa);
 542         }
 543
 544         // Validate that we can verify a signature made with CAPI
 545         // With Mono this means that we can verify CAPI signatures.
 546         // For Windows this doesn't mean much.
 547         [Test]
 548         public void CapiVerify ()
 549         {
 550                 byte[] hash = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13 };
 551                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 552
 553                 dsa.FromXmlString (CapiXml512);
 554                 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 };
 555                 Assert ("Capi-512-Verify", dsa.VerifySignature (hash, sign512));
 556                 sign512[0] = 0x00;
 557                 Assert ("Capi-512-VerBad", !dsa.VerifySignature (hash, sign512));
 558
 559                 dsa.FromXmlString (CapiXml576);
 560                 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 };
 561                 Assert ("Capi-576-Verify", dsa.VerifySignature (hash, sign576));
 562                 sign576[0] = 0x00;
 563                 Assert ("Capi-576-VerBad", !dsa.VerifySignature (hash, sign576));
 564
 565                 dsa.FromXmlString (CapiXml640);
 566                 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 };
 567                 Assert ("Capi-640-Verify", dsa.VerifySignature (hash, sign640));
 568                 sign640[0] = 0x00;
 569                 Assert ("Capi-640-VerBad", !dsa.VerifySignature (hash, sign640));
 570
 571                 dsa.FromXmlString (CapiXml704);
 572                 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 };
 573                 Assert ("Capi-704-Verify", dsa.VerifySignature (hash, sign704));
 574                 sign704[0] = 0x00;
 575                 Assert ("Capi-704-VerBad", !dsa.VerifySignature (hash, sign704));
 576
 577                 dsa.FromXmlString (CapiXml768);
 578                 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 };
 579                 Assert ("Capi-768-Verify", dsa.VerifySignature (hash, sign768));
 580                 sign768[0] = 0x00;
 581                 Assert ("Capi-768-VerBad", !dsa.VerifySignature (hash, sign768));
 582
 583                 dsa.FromXmlString (CapiXml832);
 584                 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 };
 585                 Assert ("Capi-832-Verify", dsa.VerifySignature (hash, sign832));
 586                 sign832[0] = 0x00;
 587                 Assert ("Capi-832-VerBad", !dsa.VerifySignature (hash, sign832));
 588
 589                 dsa.FromXmlString (CapiXml896);
 590                 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 };
 591                 Assert ("Capi-896-Verify", dsa.VerifySignature (hash, sign896));
 592                 sign896[0] = 0x00;
 593                 Assert ("Capi-896-VerBad", !dsa.VerifySignature (hash, sign896));
 594
 595                 dsa.FromXmlString (CapiXml960);
 596                 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 };
 597                 Assert ("Capi-960-Verify", dsa.VerifySignature (hash, sign960));
 598                 sign960[0] = 0x00;
 599                 Assert ("Capi-960-VerBad", !dsa.VerifySignature (hash, sign960));
 600
 601                 dsa.FromXmlString (CapiXml1024);
 602                 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 };
 603                 Assert ("Capi-1024-Verify", dsa.VerifySignature (hash, sign1024));
 604                 sign1024[0] = 0x00;
 605                 Assert ("Capi-1024-VerBad", !dsa.VerifySignature (hash, sign1024));
 606         }
 607
 608         // all keypairs generated by Mono on Windows
 609         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>";
 610         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>";
 611         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>";
 612         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>";
 613         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>";
 614         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>";
 615         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>";
 616         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>";
 617         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>";
 618
 619         // import/export XML keypairs
 620         // so we know that Windows (original MS Framework) can use keypairs generated by Mono
 621         [Test]
 622         public void MonoXmlImportExport ()
 623         {
 624                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 625
 626                 dsa.FromXmlString (MonoXml512);
 627                 AssertEquals ("Mono-Xml512", MonoXml512, dsa.ToXmlString (true));
 628
 629                 dsa.FromXmlString (MonoXml576);
 630                 AssertEquals ("Mono-Xml576", MonoXml576, dsa.ToXmlString (true));
 631
 632                 dsa.FromXmlString (MonoXml640);
 633                 AssertEquals ("Mono-Xml640", MonoXml640, dsa.ToXmlString (true));
 634
 635                 dsa.FromXmlString (MonoXml704);
 636                 AssertEquals ("Mono-Xml704", MonoXml704, dsa.ToXmlString (true));
 637
 638                 dsa.FromXmlString (MonoXml768);
 639                 AssertEquals ("Mono-Xml768", MonoXml768, dsa.ToXmlString (true));
 640
 641                 dsa.FromXmlString (MonoXml832);
 642                 AssertEquals ("Mono-Xml832", MonoXml832, dsa.ToXmlString (true));
 643
 644                 dsa.FromXmlString (MonoXml896);
 645                 AssertEquals ("Mono-Xml896", MonoXml896, dsa.ToXmlString (true));
 646
 647                 dsa.FromXmlString (MonoXml960);
 648                 AssertEquals ("Mono-Xml960", MonoXml960, dsa.ToXmlString (true));
 649
 650                 dsa.FromXmlString (MonoXml1024);
 651                 AssertEquals ("Mono-Xml1024", MonoXml1024, dsa.ToXmlString (true));
 652         }
 653
 654         // Validate that we can sign with every keypair and verify the signature
 655         // With Windows this means that we can use Mono keypairs to sign and verify.
 656         // For Mono this doesn't mean much.
 657         [Test]
 658         public void MonoSignature ()
 659         {
 660                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 661
 662                 dsa.FromXmlString (MonoXml512);
 663                 SignAndVerify ("Mono-512", dsa);
 664
 665                 dsa.FromXmlString (MonoXml576);
 666                 SignAndVerify ("Mono-576", dsa);
 667
 668                 dsa.FromXmlString (MonoXml640);
 669                 SignAndVerify ("Mono-640", dsa);
 670
 671                 dsa.FromXmlString (MonoXml704);
 672                 SignAndVerify ("Mono-704", dsa);
 673
 674                 dsa.FromXmlString (MonoXml768);
 675                 SignAndVerify ("Mono-768", dsa);
 676
 677                 dsa.FromXmlString (MonoXml832);
 678                 SignAndVerify ("Mono-832", dsa);
 679
 680                 dsa.FromXmlString (MonoXml896);
 681                 SignAndVerify ("Mono-896", dsa);
 682
 683                 dsa.FromXmlString (MonoXml960);
 684                 SignAndVerify ("Mono-960", dsa);
 685
 686                 dsa.FromXmlString (MonoXml1024);
 687                 SignAndVerify ("Mono-1024", dsa);
 688         }
 689
 690         // Validate that we can verify a signature made with Mono
 691         // With Windows this means that we can verify Mono signatures.
 692         // For Mono this doesn't mean much.
 693         [Test]
 694         public void MonoVerify ()
 695         {
 696                 byte[] hash = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13 };
 697                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider ();
 698
 699                 dsa.FromXmlString (MonoXml512);
 700                 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 };
 701                 Assert ("Mono-512-Verify", dsa.VerifySignature (hash, sign512));
 702                 sign512[0] = 0x00;
 703                 Assert ("Mono-512-VerBad", !dsa.VerifySignature (hash, sign512));
 704
 705                 dsa.FromXmlString (MonoXml576);
 706                 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 };
 707                 Assert ("Mono-576-Verify", dsa.VerifySignature (hash, sign576));
 708                 sign576[0] = 0x00;
 709                 Assert ("Mono-576-VerBad", !dsa.VerifySignature (hash, sign576));
 710
 711                 dsa.FromXmlString (MonoXml640);
 712                 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 };
 713                 Assert ("Mono-640-Verify", dsa.VerifySignature (hash, sign640));
 714                 sign640[0] = 0x00;
 715                 Assert ("Mono-640-VerBad", !dsa.VerifySignature (hash, sign640));
 716
 717                 dsa.FromXmlString (MonoXml704);
 718                 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 };
 719                 Assert ("Mono-704-Verify", dsa.VerifySignature (hash, sign704));
 720                 sign704[0] = 0x00;
 721                 Assert ("Mono-704-VerBad", !dsa.VerifySignature (hash, sign704));
 722
 723                 dsa.FromXmlString (MonoXml768);
 724                 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 };
 725                 Assert ("Mono-768-Verify", dsa.VerifySignature (hash, sign768));
 726                 sign768[0] = 0x00;
 727                 Assert ("Mono-768-VerBad", !dsa.VerifySignature (hash, sign768));
 728
 729                 dsa.FromXmlString (MonoXml832);
 730                 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 };
 731                 Assert ("Mono-832-Verify", dsa.VerifySignature (hash, sign832));
 732                 sign832[0] = 0x00;
 733                 Assert ("Mono-832-VerBad", !dsa.VerifySignature (hash, sign832));
 734
 735                 dsa.FromXmlString (MonoXml896);
 736                 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 };
 737                 Assert ("Mono-896-Verify", dsa.VerifySignature (hash, sign896));
 738                 sign896[0] = 0x00;
 739                 Assert ("Mono-896-VerBad", !dsa.VerifySignature (hash, sign896));
 740
 741                 dsa.FromXmlString (MonoXml960);
 742                 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 };
 743                 Assert ("Mono-960-Verify", dsa.VerifySignature (hash, sign960));
 744                 sign960[0] = 0x00;
 745                 Assert ("Mono-960-VerBad", !dsa.VerifySignature (hash, sign960));
 746
 747                 dsa.FromXmlString (MonoXml1024);
 748                 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 };
 749                 Assert ("Mono-1024-Verify", dsa.VerifySignature (hash, sign1024));
 750                 sign1024[0] = 0x00;
 751                 Assert ("Mono-1024-VerBad", !dsa.VerifySignature (hash, sign1024));
 752         }
 753
 754         // Key Pair Persistence Tests
 755         // References
 756         // a.   .Net Framework Cryptography Frequently Asked Questions, Question 8
 757         //      http://www.gotdotnet.com/team/clr/cryptofaq.htm
 758         // b.   Generating Keys for Encryption and Decryption
 759         //      http://msdn.microsoft.com/library/en-us/cpguide/html/cpcongeneratingkeysforencryptiondecryption.asp
 760
 761         [Test]
 762         public void Persistence_PersistKeyInCsp_False ()
 763         {
 764                 CspParameters csp = new CspParameters (3, null, "Persistence_PersistKeyInCsp_False");
 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 when a CspParameters is supplied
 772                 Assert ("PersistKeyInCsp", dsa1.PersistKeyInCsp);
 773
 774                 // this means nothing if we don't call Clear !!!
 775                 dsa1.PersistKeyInCsp = false;
 776                 Assert ("PersistKeyInCsp", !dsa1.PersistKeyInCsp);
 777
 778                 // reload using the same container name
 779                 DSACryptoServiceProvider dsa2 = new DSACryptoServiceProvider (minKeySize, csp);
 780                 string second = dsa2.ToXmlString (true);
 781
 782                 AssertEquals ("Key Pair Same Container", first, second);
 783         }
 784
 785         [Test]
 786         public void Persistence_PersistKeyInCsp_True ()
 787         {
 788                 CspParameters csp = new CspParameters (3, null, "Persistence_PersistKeyInCsp_True");
 789                 // MS generates (or load) keypair here
 790                 // Mono load (if it exists) the keypair here
 791                 DSACryptoServiceProvider dsa1 = new DSACryptoServiceProvider (minKeySize, csp);
 792                 // Mono will generate the keypair here (if it doesn't exists)
 793                 string first = dsa1.ToXmlString (true);
 794
 795                 // persistance is "on" by default
 796                 Assert ("PersistKeyInCsp", dsa1.PersistKeyInCsp);
 797
 798                 // reload using the same container name
 799                 DSACryptoServiceProvider dsa2 = new DSACryptoServiceProvider (minKeySize, csp);
 800                 string second = dsa2.ToXmlString (true);
 801
 802                 AssertEquals ("Key Pair Same Container", first, second);
 803         }
 804
 805         [Test]
 806         public void Persistence_Delete ()
 807         {
 808                 CspParameters csp = new CspParameters (3, null, "Persistence_Delete");
 809                 // MS generates (or load) keypair here
 810                 // Mono load (if it exists) the keypair here
 811                 DSACryptoServiceProvider dsa1 = new DSACryptoServiceProvider (minKeySize, csp);
 812                 // Mono will generate the keypair here (if it doesn't exists)
 813                 string original = dsa1.ToXmlString (true);
 814
 815                 // note: Delete isn't well documented but can be done by
 816                 // flipping the PersistKeyInCsp to false and back to true.
 817                 dsa1.PersistKeyInCsp = false;
 818                 dsa1.Clear ();
 819
 820                 // recreate using the same container name
 821                 DSACryptoServiceProvider dsa2 = new DSACryptoServiceProvider (minKeySize, csp);
 822                 string newKeyPair = dsa2.ToXmlString (true);
 823
 824                 Assert ("Key Pair Deleted", (original != newKeyPair));
 825         }
 826
 827         [Test]
 828         public void PersistKey_True ()
 829         {
 830                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider (minKeySize);
 831                 string key = dsa.ToXmlString (true);
 832                 dsa.PersistKeyInCsp = true;
 833                 AssertEquals ("PersistKeyInCsp-True", key, dsa.ToXmlString (true));
 834         }
 835
 836         [Test]
 837         public void PersistKey_False ()
 838         {
 839                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider (minKeySize);
 840                 string key = dsa.ToXmlString (true);
 841                 dsa.PersistKeyInCsp = false;
 842                 AssertEquals ("PersistKeyInCsp-False", key, dsa.ToXmlString (true));
 843         }
 844
 845         [Test]
 846         public void PersistKey_FalseTrue ()
 847         {
 848                 DSACryptoServiceProvider dsa = new DSACryptoServiceProvider (minKeySize);
 849                 string key = dsa.ToXmlString (true);
 850                 dsa.PersistKeyInCsp = false;
 851                 dsa.PersistKeyInCsp = true;
 852                 AssertEquals ("PersistKeyInCsp-FalseTrue", key, dsa.ToXmlString (true));
 853         }
 854
 855 #if NET_1_1
 856         [Test]
 857         public void UseMachineKeyStore_Default ()
 858         {
 859                 Assert ("UseMachineKeyStore(Default)", !DSACryptoServiceProvider.UseMachineKeyStore);
 860         }
 861
 862         [Test]
 863         public void UseMachineKeyStore ()
 864         {
 865                 // note only applicable when CspParameters isn't used - which don't
 866                 // help much as you can't know the generated key container name
 867                 try {
 868                         DSACryptoServiceProvider.UseMachineKeyStore = true;
 869                         CspParameters csp = new CspParameters (13, null, "UseMachineKeyStore");
 870                         csp.KeyContainerName = "UseMachineKeyStore";
 871                         DSACryptoServiceProvider dsa = new DSACryptoServiceProvider (csp);
 872                         string machineKeyPair = dsa.ToXmlString (true);
 873                         dsa.Clear ();
 874
 875                         DSACryptoServiceProvider.UseMachineKeyStore = false;
 876                         csp = new CspParameters (13, null, "UseMachineKeyStore");
 877                         csp.Flags |= CspProviderFlags.UseMachineKeyStore;
 878                         dsa = new DSACryptoServiceProvider (csp);
 879
 880                         Assert ("UseMachineKeyStore", machineKeyPair != dsa.ToXmlString (true));
 881                 }
 882                 catch (CryptographicException ce) {
 883                         // only root can create the required directory (if inexistant)
 884                         // afterward anyone can use (read from) it
 885                         if (!(ce.InnerException is UnauthorizedAccessException))
 886                                 throw;
 887                 }
 888         }
 889 #endif
 890
 891 #if NET_2_0
 892         [Test]
 893         [Category ("NotWorking")]
 894         public void CspKeyContainerInfo_NewKeypair ()
 895         {
 896                 dsa = new DSACryptoServiceProvider (minKeySize);
 897                 CspKeyContainerInfo info = dsa.CspKeyContainerInfo;
 898                 Assert ("Accessible", info.Accessible);\r
 899 // FIXME        AssertNotNull ("CryptoKeySecurity", info.CryptoKeySecurity);\r
 900                 Assert ("Exportable", info.Exportable);\r
 901                 Assert ("HardwareDevice", !info.HardwareDevice);
 902                 AssertNotNull ("KeyContainerName", info.KeyContainerName);
 903                 AssertEquals ("KeyNumber", KeyNumber.Signature, info.KeyNumber);
 904                 Assert ("MachineKeyStore", !info.MachineKeyStore);
 905                 Assert ("Protected", !info.Protected);
 906                 AssertNotNull ("ProviderName", info.ProviderName);
 907                 AssertEquals ("ProviderType", 13, info.ProviderType);
 908                 Assert ("RandomlyGenerated", info.RandomlyGenerated);
 909                 Assert ("Removable", !info.Removable);\r
 910                 AssertNotNull ("UniqueKeyContainerName", info.UniqueKeyContainerName);
 911         }
 912
 913         [Test]
 914         [Category ("NotWorking")]
 915         public void CspKeyContainerInfo_ImportedKeypair ()
 916         {
 917                 dsa = new DSACryptoServiceProvider (minKeySize);
 918                 DSAParameters rsap = AllTests.GetKey (true);
 919                 dsa.ImportParameters (rsap);
 920                 CspKeyContainerInfo info = dsa.CspKeyContainerInfo;
 921                 Assert ("Accessible", info.Accessible);\r
 922 // FIXME        AssertNotNull ("CryptoKeySecurity", info.CryptoKeySecurity);\r
 923                 Assert ("Exportable", info.Exportable);
 924                 Assert ("HardwareDevice", !info.HardwareDevice);
 925                 AssertNotNull ("KeyContainerName", info.KeyContainerName);
 926                 AssertEquals ("KeyNumber", KeyNumber.Signature, info.KeyNumber);
 927                 Assert ("MachineKeyStore", !info.MachineKeyStore);
 928                 Assert ("Protected", !info.Protected);
 929                 AssertNotNull ("ProviderName", info.ProviderName);
 930                 AssertEquals ("ProviderType", 13, info.ProviderType);
 931                 Assert ("RandomlyGenerated", info.RandomlyGenerated);
 932                 Assert ("Removable", !info.Removable);
 933                 AssertNotNull ("UniqueKeyContainerName", info.UniqueKeyContainerName);
 934         }
 935
 936         [Test]
 937         [Category ("NotWorking")]\r
 938         // This case wasn't fixed in Nov CTP\r
 939         public void CspKeyContainerInfo_ImportedPublicKey ()
 940         {
 941                 dsa = new DSACryptoServiceProvider (minKeySize);
 942                 DSAParameters rsap = AllTests.GetKey (false);
 943                 dsa.ImportParameters (rsap);
 944                 CspKeyContainerInfo info = dsa.CspKeyContainerInfo;
 945                 Assert ("Accessible", !info.Accessible);\r
 946                 // info.CryptoKeySecurity throws a CryptographicException at this stage\r
 947                 // info.Exportable throws a CryptographicException at this stage
 948                 Assert ("HardwareDevice", !info.HardwareDevice);
 949                 AssertNotNull ("KeyContainerName", info.KeyContainerName);
 950                 AssertEquals ("KeyNumber", KeyNumber.Signature, info.KeyNumber);
 951                 Assert ("MachineKeyStore", !info.MachineKeyStore);
 952                 // info.Protected throws a CryptographicException at this stage
 953                 AssertNotNull ("ProviderName", info.ProviderName);
 954                 AssertEquals ("ProviderType", 13, info.ProviderType);
 955                 Assert ("RandomlyGenerated", info.RandomlyGenerated);
 956                 Assert ("Removable", !info.Removable);
 957                 // info.UniqueKeyContainerName throws a CryptographicException at this stage
 958         }
 959
 960         [Test]
 961         [Category ("NotWorking")]
 962         public void ExportCspBlob_Full ()
 963         {
 964                 dsa = new DSACryptoServiceProvider (minKeySize);
 965                 DSAParameters dsap = AllTests.GetKey (true);
 966                 dsa.ImportParameters (dsap);
 967
 968                 byte[] keypair = dsa.ExportCspBlob (true);
 969                 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));
 970         }
 971
 972         [Test]
 973         [Category ("NotWorking")]
 974         public void ExportCspBlob_PublicOnly ()
 975         {
 976                 dsa = new DSACryptoServiceProvider (minKeySize);
 977                 DSAParameters dsap = AllTests.GetKey (true);
 978                 dsa.ImportParameters (dsap);
 979
 980                 byte[] pubkey = dsa.ExportCspBlob (false);
 981                 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));
 982         }
 983
 984         [Test]
 985         [ExpectedException (typeof (CryptographicException))]
 986         [Category ("NotWorking")]
 987         public void ExportCspBlob_MissingPrivateKey ()
 988         {
 989                 dsa = new DSACryptoServiceProvider (minKeySize);
 990                 DSAParameters dsap = AllTests.GetKey (false);
 991                 dsa.ImportParameters (dsap);
 992
 993                 dsa.ExportCspBlob (true);
 994         }
 995
 996         [Test]
 997         [Category ("NotWorking")]
 998         public void ExportCspBlob_MissingPrivateKey_PublicOnly ()
 999         {
1000                 dsa = new DSACryptoServiceProvider (minKeySize);
1001                 DSAParameters dsap = AllTests.GetKey (false);
1002                 dsa.ImportParameters (dsap);
1003
1004                 byte[] pubkey = dsa.ExportCspBlob (false);
1005                 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));
1006         }
1007
1008         [Test]
1009         [Category ("NotWorking")]
1010         public void ImportCspBlob_Keypair ()
1011         {
1012                 byte[] blob = new byte [336] { 0x07, 0x02, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x44, 0x53, 0x53, 0x32, 0x00, 0x04, 0x00, 0x00, 0xD3,
1013                         0x7B, 0xC6, 0xED, 0x3F, 0x72, 0x44, 0xBD, 0x22, 0x7D, 0xF2, 0xD4, 0x62, 0xFE, 0x7C, 0xE3, 0x75, 0x8F, 0x9C, 0xDE, 0x69, 0xC0, 0x3A,
1014                         0x0C, 0xE6, 0x26, 0x5A, 0x46, 0x3D, 0xEF, 0x0D, 0x90, 0x20, 0xC6, 0xF6, 0x45, 0x7C, 0x73, 0xE8, 0xB9, 0x7D, 0x86, 0x27, 0xF7, 0x97,
1015                         0x76, 0xC8, 0x1C, 0x8E, 0x8B, 0xCE, 0x26, 0x93, 0xE6, 0x21, 0x53, 0x20, 0x93, 0x58, 0x25, 0x45, 0x1C, 0x46, 0x66, 0x17, 0x10, 0x98,
1016                         0x03, 0x96, 0xD0, 0xE5, 0xC8, 0x30, 0x80, 0x72, 0xB6, 0x49, 0xB3, 0x82, 0x95, 0xB3, 0x8D, 0x3A, 0xA5, 0xE5, 0x60, 0xC6, 0x42, 0x3A,
1017                         0x33, 0x70, 0x67, 0x30, 0xC5, 0x1C, 0x32, 0xD9, 0xEB, 0xCF, 0xC1, 0x36, 0xB3, 0xF3, 0x24, 0x07, 0x39, 0x86, 0x0D, 0xE9, 0x12, 0x80,
1018                         0x73, 0x26, 0xA7, 0x8C, 0x8B, 0x8A, 0x40, 0xAA, 0x51, 0x43, 0x8F, 0x20, 0xDE, 0xD2, 0x9C, 0xF3, 0xB3, 0x51, 0x73, 0x83, 0x62, 0xA0,
1019                         0x11, 0xC9, 0x50, 0x93, 0xE1, 0xF0, 0x64, 0xBE, 0xD0, 0x9E, 0xE0, 0x5B, 0x13, 0x47, 0xAA, 0x56, 0x65, 0x62, 0x47, 0xFD, 0x3A, 0x94,
1020                         0xB7, 0x1B, 0xE5, 0x35, 0x95, 0x86, 0x14, 0x64, 0xC0, 0xD6, 0x07, 0x96, 0x4C, 0x55, 0x1E, 0x0A, 0x4C, 0x10, 0xC2, 0xB5, 0xE6, 0xFB,
1021                         0x74, 0xF9, 0xA5, 0x72, 0xE0, 0x42, 0x96, 0x62, 0x0B, 0xEF, 0xB7, 0x52, 0x36, 0x7D, 0xE3, 0x01, 0x12, 0x85, 0xE6, 0xFE, 0x92, 0x75,
1022                         0x40, 0xC2, 0xA6, 0xD0, 0x9D, 0x16, 0x6F, 0xC1, 0xC7, 0xA7, 0xDF, 0x48, 0x80, 0xA2, 0x5D, 0xA0, 0xFD, 0x84, 0xBE, 0x06, 0xAC, 0xCB,
1023                         0x32, 0x22, 0x82, 0xD2, 0xD7, 0x7C, 0x69, 0xFC, 0xBC, 0x94, 0x78, 0x2B, 0x11, 0x5B, 0x1C, 0x1E, 0xAF, 0xDB, 0x7A, 0xAA, 0x31, 0xF3,
1024                         0xD8, 0x74, 0x84, 0x00, 0x3F, 0x9D, 0xB9, 0x4B, 0xB2, 0x68, 0x7E, 0xF4, 0x1B, 0xC2, 0x83, 0x73, 0x21, 0x78, 0x0F, 0xD5, 0x0F, 0xB0,
1025                         0xEB, 0x76, 0x41, 0xF1, 0x23, 0x7A, 0x6A, 0x78, 0xCC, 0x4F, 0x3D, 0xB1, 0x2F, 0x0A, 0xF6, 0x9A, 0xA7, 0x18, 0xC1, 0x2F, 0xF0, 0xB7,
1026                         0x73, 0x91, 0x51, 0x6D, 0x9B, 0xB5, 0xB2, 0x03, 0x7C, 0xE0, 0x00, 0x00, 0x00, 0x9B, 0xAF, 0x1B, 0xE9, 0xC1, 0xC7, 0x35, 0xF5, 0xE2,
1027                         0xEB, 0xC9, 0xEE, 0xF6, 0xBA, 0x25, 0x6D, 0x6F, 0x39, 0x83, 0xB9 };
1028                 dsa = new DSACryptoServiceProvider (minKeySize);
1029                 dsa.ImportCspBlob (blob);
1030
1031                 byte[] keypair = dsa.ExportCspBlob (true);
1032                 for (int i = 0; i < blob.Length; i++)
1033                         AssertEquals (i.ToString (), blob [i], keypair [i]);
1034         }
1035
1036         [Test]
1037         [Category ("NotWorking")]
1038         public void ExportCspBlob_PublicKey ()
1039         {
1040                 byte[] blob = new byte [444] { 0x06, 0x02, 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x44, 0x53, 0x53, 0x31, 0x00, 0x04, 0x00, 0x00, 0xD3,
1041                         0x7B, 0xC6, 0xED, 0x3F, 0x72, 0x44, 0xBD, 0x22, 0x7D, 0xF2, 0xD4, 0x62, 0xFE, 0x7C, 0xE3, 0x75, 0x8F, 0x9C, 0xDE, 0x69, 0xC0, 0x3A,
1042                         0x0C, 0xE6, 0x26, 0x5A, 0x46, 0x3D, 0xEF, 0x0D, 0x90, 0x20, 0xC6, 0xF6, 0x45, 0x7C, 0x73, 0xE8, 0xB9, 0x7D, 0x86, 0x27, 0xF7, 0x97,
1043                         0x76, 0xC8, 0x1C, 0x8E, 0x8B, 0xCE, 0x26, 0x93, 0xE6, 0x21, 0x53, 0x20, 0x93, 0x58, 0x25, 0x45, 0x1C, 0x46, 0x66, 0x17, 0x10, 0x98,
1044                         0x03, 0x96, 0xD0, 0xE5, 0xC8, 0x30, 0x80, 0x72, 0xB6, 0x49, 0xB3, 0x82, 0x95, 0xB3, 0x8D, 0x3A, 0xA5, 0xE5, 0x60, 0xC6, 0x42, 0x3A,
1045                         0x33, 0x70, 0x67, 0x30, 0xC5, 0x1C, 0x32, 0xD9, 0xEB, 0xCF, 0xC1, 0x36, 0xB3, 0xF3, 0x24, 0x07, 0x39, 0x86, 0x0D, 0xE9, 0x12, 0x80,
1046                         0x73, 0x26, 0xA7, 0x8C, 0x8B, 0x8A, 0x40, 0xAA, 0x51, 0x43, 0x8F, 0x20, 0xDE, 0xD2, 0x9C, 0xF3, 0xB3, 0x51, 0x73, 0x83, 0x62, 0xA0,
1047                         0x11, 0xC9, 0x50, 0x93, 0xE1, 0xF0, 0x64, 0xBE, 0xD0, 0x9E, 0xE0, 0x5B, 0x13, 0x47, 0xAA, 0x56, 0x65, 0x62, 0x47, 0xFD, 0x3A, 0x94,
1048                         0xB7, 0x1B, 0xE5, 0x35, 0x95, 0x86, 0x14, 0x64, 0xC0, 0xD6, 0x07, 0x96, 0x4C, 0x55, 0x1E, 0x0A, 0x4C, 0x10, 0xC2, 0xB5, 0xE6, 0xFB,
1049                         0x74, 0xF9, 0xA5, 0x72, 0xE0, 0x42, 0x96, 0x62, 0x0B, 0xEF, 0xB7, 0x52, 0x36, 0x7D, 0xE3, 0x01, 0x12, 0x85, 0xE6, 0xFE, 0x92, 0x75,
1050                         0x40, 0xC2, 0xA6, 0xD0, 0x9D, 0x16, 0x6F, 0xC1, 0xC7, 0xA7, 0xDF, 0x48, 0x80, 0xA2, 0x5D, 0xA0, 0xFD, 0x84, 0xBE, 0x06, 0xAC, 0xCB,
1051                         0x32, 0x22, 0x82, 0xD2, 0xD7, 0x7C, 0x69, 0xFC, 0xBC, 0x94, 0x78, 0x2B, 0x11, 0x5B, 0x1C, 0x1E, 0xAF, 0xDB, 0x7A, 0xAA, 0x31, 0xF3,
1052                         0xD8, 0x74, 0x84, 0x00, 0x3F, 0x9D, 0xB9, 0x4B, 0xB2, 0x68, 0x7E, 0xF4, 0x1B, 0xC2, 0x83, 0x73, 0x21, 0x78, 0x0F, 0xD5, 0x0F, 0xB0,
1053                         0xEB, 0x76, 0x41, 0xF1, 0x23, 0x7A, 0x6A, 0x78, 0xCC, 0x4F, 0x3D, 0xBB, 0xC7, 0x03, 0x89, 0xC4, 0x0B, 0x66, 0x86, 0x80, 0xD5, 0xAA,
1054                         0x34, 0xE8, 0x14, 0x71, 0xF9, 0x29, 0xBE, 0xB9, 0xEE, 0x34, 0xB1, 0x5F, 0xA2, 0xC8, 0x4D, 0xCD, 0xCF, 0x0E, 0x8E, 0xA4, 0x2E, 0xD4,
1055                         0x65, 0x8C, 0x27, 0xFF, 0xC1, 0x41, 0x26, 0xF9, 0x0E, 0xE5, 0x11, 0xC9, 0xCC, 0x3E, 0x45, 0x87, 0xEC, 0x49, 0xBA, 0x7C, 0x83, 0x91,
1056                         0xDE, 0x70, 0xE8, 0x27, 0x1C, 0x47, 0xEB, 0x1D, 0xE2, 0x37, 0x62, 0x2F, 0xAA, 0x5B, 0x30, 0x80, 0x8B, 0x80, 0x00, 0x55, 0xF4, 0x64,
1057                         0xC2, 0xBE, 0x5A, 0xD3, 0x54, 0x4A, 0xE7, 0x0B, 0x95, 0x00, 0xF4, 0xBA, 0x72, 0xCD, 0xF8, 0x22, 0xE6, 0x30, 0x4E, 0xF6, 0xBD, 0xBE,
1058                         0x3F, 0x00, 0x52, 0x7F, 0xE2, 0x57, 0x5F, 0xC0, 0xBE, 0x82, 0xC0, 0x50, 0x07, 0x1C, 0x7D, 0x89, 0x56, 0x49, 0xCE, 0x28, 0x52, 0x8C,
1059                         0x11, 0xB1, 0xD1, 0x51, 0x51, 0x12, 0xB2, 0xE0, 0x00, 0x00, 0x00, 0x9B, 0xAF, 0x1B, 0xE9, 0xC1, 0xC7, 0x35, 0xF5, 0xE2, 0xEB, 0xC9,
1060                         0xEE, 0xF6, 0xBA, 0x25, 0x6D, 0x6F, 0x39, 0x83, 0xB9 };
1061                 dsa = new DSACryptoServiceProvider (minKeySize);
1062                 dsa.ImportCspBlob (blob);
1063
1064                 byte[] pubkey = dsa.ExportCspBlob (false);
1065                 for (int i = 0; i < blob.Length; i++)
1066                         AssertEquals (i.ToString (), blob [i], pubkey [i]);
1067         }
1068
1069         [Test]
1070         [ExpectedException (typeof (ArgumentNullException))]
1071         public void ImportCspBlob_Null ()
1072         {
1073                 dsa = new DSACryptoServiceProvider (minKeySize);
1074                 dsa.ImportCspBlob (null);
1075         }
1076
1077         [Test]
1078         [ExpectedException (typeof (CryptographicException))]
1079         [Category ("NotWorking")]
1080         public void ImportCspBlob_Bad ()
1081         {
1082                 byte[] blob = new byte [148]; // valid size for public key
1083                 dsa = new DSACryptoServiceProvider (minKeySize);
1084                 dsa.ImportCspBlob (blob);
1085         }
1086 #endif
1087 }
1088
1089 }