mcs/class/Mono.Security/Test/Mono.Security.Cryptography/KeyPairPersistenceTest.cs

   1 //
   2 // KeyPairPersistenceTest.cs: Unit tests for keypair persistence
   3 //
   4 // Author:
   5 //      Sebastien Pouliot <sebastien@ximian.com>
   6 //
   7 // (C) 2004 Novell (http://www.novell.com)
   8 //
   9
  10 using NUnit.Framework;
  11 using System;
  12 using System.IO;
  13 using System.Security.Cryptography;
  14
  15 using Mono.Security.Cryptography;
  16
  17 namespace MonoTests.Mono.Security.Cryptography {
  18
  19         [TestFixture]
  20         public class KeyPairPersistenceTest : Assertion {
  21
  22                 [Test]
  23                 [ExpectedException (typeof (ArgumentNullException))]
  24                 public void Constructor_Null ()
  25                 {
  26                         KeyPairPersistence kpp = new KeyPairPersistence (null);
  27                 }
  28
  29                 private void Compare (KeyPairPersistence saved, KeyPairPersistence loaded)
  30                 {
  31                         // Note: there is an additional Environement.NewLine
  32                         // at the end of the loaded string - that's why we do
  33                         // not use AssertEquals (for strings)
  34                         Assert ("Filename", loaded.Filename.StartsWith (saved.Filename));
  35                         Assert ("KeyValue", loaded.KeyValue.StartsWith (saved.KeyValue));
  36                         Assert ("Parameters.KeyContainerName", loaded.Parameters.KeyContainerName.StartsWith (saved.Parameters.KeyContainerName));
  37                         AssertEquals ("Parameters.KeyNumber", saved.Parameters.KeyNumber, loaded.Parameters.KeyNumber);
  38                         Assert ("Parameters.ProviderName", loaded.Parameters.ProviderName.StartsWith (saved.Parameters.ProviderName));
  39                         AssertEquals ("Parameters.ProviderType", saved.Parameters.ProviderType, loaded.Parameters.ProviderType);
  40                 }
  41
  42                 [Test]
  43                 public void CspType ()
  44                 {
  45                         CspParameters cp = new CspParameters (-1);
  46                         KeyPairPersistence kpp = new KeyPairPersistence (cp, "<keypair/>");
  47                         kpp.Save ();
  48
  49                         Assert ("Save-Exists", File.Exists (kpp.Filename));
  50                         // we didn't supply a name so we can't load it back
  51
  52                         kpp.Remove ();
  53                         Assert ("Remove-!Exists", !File.Exists (kpp.Filename));
  54                 }
  55
  56                 [Test]
  57                 public void CspTypeProvider ()
  58                 {
  59                         CspParameters cp = new CspParameters (-2, "Provider");
  60                         KeyPairPersistence kpp = new KeyPairPersistence (cp, "<keypair/>");
  61                         kpp.Save ();
  62
  63                         Assert ("Save-Exists", File.Exists (kpp.Filename));
  64                         // we didn't supply a name so we can't load it back
  65
  66                         kpp.Remove ();
  67                         Assert ("Remove-!Exists", !File.Exists (kpp.Filename));
  68                 }
  69
  70                 [Test]
  71                 public void CspTypeProviderContainer ()
  72                 {
  73                         CspParameters cp = new CspParameters (-3, "Provider", "Container");
  74                         KeyPairPersistence kpp = new KeyPairPersistence (cp, "<keypair/>");
  75                         kpp.Save ();
  76
  77                         Assert ("Save-Exists", File.Exists (kpp.Filename));
  78                         KeyPairPersistence kpp2 = new KeyPairPersistence (cp);
  79                         Assert ("Load", kpp2.Load ());
  80
  81                         Compare (kpp, kpp2);
  82                         kpp.Remove ();
  83                         Assert ("Remove-!Exists", !File.Exists (kpp.Filename));
  84                 }
  85
  86                 [Test]
  87                 public void CspTypeProviderContainerKeyNumber ()
  88                 {
  89                         CspParameters cp = new CspParameters (-4, "Provider", "Container");
  90                         cp.KeyNumber = 0;
  91                         KeyPairPersistence kpp = new KeyPairPersistence (cp, "<keypair/>");
  92                         kpp.Save ();
  93
  94                         Assert ("Save-Exists", File.Exists (kpp.Filename));
  95                         KeyPairPersistence kpp2 = new KeyPairPersistence (cp);
  96                         Assert ("Load", kpp2.Load ());
  97
  98                         Compare (kpp, kpp2);
  99                         kpp.Remove ();
 100                         Assert ("Remove-!Exists", !File.Exists (kpp.Filename));
 101                 }
 102
 103                 [Test]
 104                 public void CspFlagsDefault ()
 105                 {
 106                         CspParameters cp = new CspParameters (-5, "Provider", "Container");
 107                         cp.Flags = CspProviderFlags.UseDefaultKeyContainer;
 108                         KeyPairPersistence kpp = new KeyPairPersistence (cp, "<keypair/>");
 109                         kpp.Save ();
 110
 111                         Assert ("Save-Exists", File.Exists (kpp.Filename));
 112                         KeyPairPersistence kpp2 = new KeyPairPersistence (cp);
 113                         Assert ("Load", kpp2.Load ());
 114
 115                         Compare (kpp, kpp2);
 116                         kpp.Remove ();
 117                         Assert ("Remove-!Exists", !File.Exists (kpp.Filename));
 118                 }
 119
 120                 [Test]
 121                 public void CspFlagsMachine ()
 122                 {
 123                         CspParameters cp = new CspParameters (-6, "Provider", "Container");
 124                         cp.Flags = CspProviderFlags.UseMachineKeyStore;
 125                         KeyPairPersistence kpp = new KeyPairPersistence (cp, "<keypair/>");
 126                         try {
 127                                 kpp.Save ();
 128
 129                                 Assert ("Save-Exists", File.Exists (kpp.Filename));
 130                                 KeyPairPersistence kpp2 = new KeyPairPersistence (cp);
 131                                 Assert ("Load", kpp2.Load ());
 132
 133                                 Compare (kpp, kpp2);
 134                                 kpp.Remove ();
 135                                 Assert ("Remove-!Exists", !File.Exists (kpp.Filename));
 136                         }
 137                         catch (CryptographicException ce) {
 138                                 // not everyone can write to the machine store
 139                                 if (!(ce.InnerException is UnauthorizedAccessException))
 140                                         throw;
 141                         }
 142                 }
 143
 144                 [Test]
 145                 public void CspFlagsDefaultMachine ()
 146                 {
 147                         CspParameters cp = new CspParameters (-7, "Provider", "Container");
 148                         cp.Flags = CspProviderFlags.UseDefaultKeyContainer | CspProviderFlags.UseMachineKeyStore;
 149                         KeyPairPersistence kpp = new KeyPairPersistence (cp, "<keypair/>");
 150                         try {
 151                                 kpp.Save ();
 152
 153                                 Assert ("Save-Exists", File.Exists (kpp.Filename));
 154                                 KeyPairPersistence kpp2 = new KeyPairPersistence (cp);
 155                                 Assert ("Load", kpp2.Load ());
 156
 157                                 Compare (kpp, kpp2);
 158                                 kpp.Remove ();
 159                                 Assert ("Remove-!Exists", !File.Exists (kpp.Filename));
 160                         }
 161                         catch (CryptographicException ce) {
 162                                 // not everyone can write to the machine store
 163                                 if (!(ce.InnerException is UnauthorizedAccessException))
 164                                         throw;
 165                         }
 166                 }
 167
 168                 [Test]
 169                 public void CspNoChangesPermitted ()
 170                 {
 171                         CspParameters cp = new CspParameters (-8, "Provider", "Container");
 172                         cp.KeyNumber = 0;
 173                         cp.Flags = CspProviderFlags.UseMachineKeyStore;
 174
 175                         KeyPairPersistence kpp = new KeyPairPersistence (cp);
 176                         CspParameters copy = kpp.Parameters;
 177                         copy.Flags = CspProviderFlags.UseDefaultKeyContainer;
 178                         copy.KeyContainerName = "NewContainerName";
 179                         copy.KeyNumber = 1;
 180                         copy.ProviderName = "NewProviderName";
 181                         copy.ProviderType = -9;
 182
 183                         Assert ("Flags", cp.Flags != copy.Flags);
 184                         Assert ("KeyContainerName", cp.KeyContainerName != copy.KeyContainerName);
 185                         Assert ("KeyNumber", cp.KeyNumber != copy.KeyNumber);
 186                         Assert ("ProviderName", cp.ProviderName != copy.ProviderName);
 187                         Assert ("ProviderType", cp.ProviderType != copy.ProviderType);
 188                 }
 189         }
 190 }