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