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

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