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

   1 //
   2 // TestSuite.System.Security.Cryptography.DESCryptoServiceProviderTest.cs
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using System;
  30 using System.Security.Cryptography;
  31
  32 using NUnit.Framework;
  33
  34 namespace MonoTests.System.Security.Cryptography {
  35
  36         [TestFixture]
  37         public class DESCryptoServiceProviderTest : DESFIPS81Test {
  38
  39                 [SetUp]
  40                 public void SetUp ()
  41                 {
  42                         des = new DESCryptoServiceProvider ();
  43                 }
  44
  45                 [Test]
  46                 public void KeyChecks ()
  47                 {
  48                         byte[] key = des.Key;
  49                         Assert.AreEqual (8, key.Length, "Key");
  50                         Assert.IsFalse (DES.IsWeakKey (key), "IsWeakKey");
  51                         Assert.IsFalse (DES.IsSemiWeakKey (key), "IsSemiWeakKey");
  52                 }
  53
  54                 [Test]
  55                 public void IV ()
  56                 {
  57                         byte[] iv = des.IV;
  58                         Assert.AreEqual (8, iv.Length, "IV");
  59                 }
  60
  61                 // other tests (test vectors) are inherited from DESFIPS81Test
  62                 // (in DESTest.cs) but executed here
  63
  64                 [Test]
  65 #if NET_2_0
  66                 [ExpectedException (typeof (CryptographicException))]
  67 #else
  68                 [ExpectedException (typeof (NullReferenceException))]
  69 #endif
  70                 public void CreateEncryptor_KeyNull ()
  71                 {
  72                         ICryptoTransform encryptor = des.CreateEncryptor (null, des.IV);
  73                         byte[] data = new byte[encryptor.InputBlockSize];
  74                         byte[] encdata = encryptor.TransformFinalBlock (data, 0, data.Length);
  75
  76                         ICryptoTransform decryptor = des.CreateDecryptor (des.Key, des.IV);
  77                         byte[] decdata = decryptor.TransformFinalBlock (encdata, 0, encdata.Length);
  78                         // null key != SymmetricAlgorithm.Key
  79
  80                         // in about 1 out of 256 runs the exception will not be thrown because the padding will be
  81                         // the same as expected - however this still won't produce the right results (next check)
  82                         Assert.IsFalse (BitConverter.ToString (data) == BitConverter.ToString (decdata), "Compare");
  83                         // so this case is ok too, throw the expected exception to make the unit test succeed
  84                         throw new CryptographicException ("1/256");
  85                 }
  86
  87                 [Test]
  88                 public void CreateEncryptor_IvNull ()
  89                 {
  90                         ICryptoTransform encryptor = des.CreateEncryptor (des.Key, null);
  91                         byte[] data = new byte[encryptor.InputBlockSize];
  92                         byte[] encdata = encryptor.TransformFinalBlock (data, 0, data.Length);
  93
  94                         ICryptoTransform decryptor = des.CreateDecryptor (des.Key, des.IV);
  95                         byte[] decdata = decryptor.TransformFinalBlock (encdata, 0, encdata.Length);
  96                         Assert.IsFalse (BitConverter.ToString (data) == BitConverter.ToString (decdata), "Compare");
  97                         // null iv != SymmetricAlgorithm.IV
  98                 }
  99
 100                 [Test]
 101                 public void CreateEncryptor_KeyIv ()
 102                 {
 103                         byte[] originalKey = des.Key;
 104                         byte[] originalIV = des.IV;
 105
 106                         byte[] key = (byte[]) des.Key.Clone ();
 107                         Array.Reverse (key);
 108                         byte[] iv = (byte[]) des.IV.Clone ();
 109                         Array.Reverse (iv);
 110
 111                         Assert.IsNotNull (des.CreateEncryptor (key, iv), "CreateEncryptor");
 112
 113                         Assert.AreEqual (originalKey, des.Key, "Key");
 114                         Assert.AreEqual (originalIV, des.IV, "IV");
 115                         // SymmetricAlgorithm Key and IV not changed by CreateEncryptor
 116                 }
 117
 118                 [Test]
 119 #if NET_2_0
 120                 [ExpectedException (typeof (CryptographicException))]
 121 #else
 122                 [ExpectedException (typeof (NullReferenceException))]
 123 #endif
 124                 public void CreateDecryptor_KeyNull ()
 125                 {
 126                         ICryptoTransform encryptor = des.CreateEncryptor (des.Key, des.IV);
 127                         byte[] data = new byte[encryptor.InputBlockSize];
 128                         byte[] encdata = encryptor.TransformFinalBlock (data, 0, data.Length);
 129
 130                         ICryptoTransform decryptor = des.CreateDecryptor (null, des.IV);
 131                         byte[] decdata = decryptor.TransformFinalBlock (encdata, 0, encdata.Length);
 132                         // null key != SymmetricAlgorithm.Key
 133
 134                         // in about 1 out of 256 runs the exception will not be thrown because the padding will be
 135                         // the same as expected - however this still won't produce the right results (next check)
 136                         Assert.IsFalse (BitConverter.ToString (data) == BitConverter.ToString (decdata), "Compare");
 137                         // so this case is ok too, throw the expected exception to make the unit test succeed
 138                         throw new CryptographicException ("1/256");
 139                 }
 140
 141                 [Test]
 142                 public void CreateDecryptor_IvNull ()
 143                 {
 144                         ICryptoTransform encryptor = des.CreateEncryptor (des.Key, des.IV);
 145                         byte[] data = new byte[encryptor.InputBlockSize];
 146                         byte[] encdata = encryptor.TransformFinalBlock (data, 0, data.Length);
 147
 148                         ICryptoTransform decryptor = des.CreateDecryptor (des.Key, null);
 149                         byte[] decdata = decryptor.TransformFinalBlock (encdata, 0, encdata.Length);
 150                         Assert.IsFalse (BitConverter.ToString (data) == BitConverter.ToString (decdata), "Compare");
 151                         // null iv != SymmetricAlgorithm.IV
 152                 }
 153
 154                 [Test]
 155                 public void CreateDecryptor_KeyIv ()
 156                 {
 157                         byte[] originalKey = des.Key;
 158                         byte[] originalIV = des.IV;
 159
 160                         byte[] key = (byte[]) des.Key.Clone ();
 161                         Array.Reverse (key);
 162                         byte[] iv = (byte[]) des.IV.Clone ();
 163                         Array.Reverse (iv);
 164
 165                         Assert.IsNotNull (des.CreateEncryptor (key, iv), "CreateDecryptor");
 166
 167                         Assert.AreEqual (originalKey, des.Key, "Key");
 168                         Assert.AreEqual (originalIV, des.IV, "IV");
 169                         // SymmetricAlgorithm Key and IV not changed by CreateDecryptor
 170                 }
 171
 172                 // Setting the IV is more restrictive than supplying an IV to
 173                 // CreateEncryptor and CreateDecryptor. See bug #76483
 174
 175                 private ICryptoTransform CreateEncryptor_IV (int size)
 176                 {
 177                         byte[] iv = (size == -1) ? null : new byte[size];
 178                         return des.CreateEncryptor (des.Key, iv);
 179                 }
 180
 181                 [Test]
 182                 public void CreateEncryptor_IV_Null ()
 183                 {
 184                         CreateEncryptor_IV (-1);
 185                 }
 186
 187                 [Test]
 188 #if NET_2_0
 189                 [ExpectedException (typeof (CryptographicException))]
 190 #endif
 191                 public void CreateEncryptor_IV_Zero ()
 192                 {
 193                         CreateEncryptor_IV (0);
 194                 }
 195
 196                 [Test]
 197 #if NET_2_0
 198                 [ExpectedException (typeof (CryptographicException))]
 199 #endif
 200                 public void CreateEncryptor_IV_TooSmall ()
 201                 {
 202                         int size = (des.BlockSize >> 3) - 1;
 203                         CreateEncryptor_IV (size);
 204                 }
 205
 206                 [Test]
 207                 public void CreateEncryptor_IV_BlockSize ()
 208                 {
 209                         int size = (des.BlockSize >> 3);
 210                         CreateEncryptor_IV (size);
 211                 }
 212
 213                 [Test]
 214                 public void CreateEncryptor_IV_TooBig ()
 215                 {
 216                         int size = des.BlockSize; // 8 times too big
 217                         CreateEncryptor_IV (size);
 218                 }
 219
 220                 private ICryptoTransform CreateDecryptor_IV (int size)
 221                 {
 222                         byte[] iv = (size == -1) ? null : new byte[size];
 223                         return des.CreateDecryptor (des.Key, iv);
 224                 }
 225
 226                 [Test]
 227                 public void CreateDecryptor_IV_Null ()
 228                 {
 229                         CreateDecryptor_IV (-1);
 230                 }
 231
 232                 [Test]
 233 #if NET_2_0
 234                 [ExpectedException (typeof (CryptographicException))]
 235 #endif
 236                 public void CreateDecryptor_IV_Zero ()
 237                 {
 238                         CreateDecryptor_IV (0);
 239                 }
 240
 241                 [Test]
 242 #if NET_2_0
 243                 [ExpectedException (typeof (CryptographicException))]
 244 #endif
 245                 public void CreateDecryptor_IV_TooSmall ()
 246                 {
 247                         int size = (des.BlockSize >> 3) - 1;
 248                         CreateDecryptor_IV (size);
 249                 }
 250
 251                 [Test]
 252                 public void CreateDecryptor_IV_BlockSize ()
 253                 {
 254                         int size = (des.BlockSize >> 3);
 255                         CreateDecryptor_IV (size);
 256                 }
 257
 258                 [Test]
 259                 public void CreateDecryptor_IV_TooBig ()
 260                 {
 261                         int size = des.BlockSize; // 8 times too big
 262                         CreateDecryptor_IV (size);
 263                 }
 264         }
 265 }