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
  81                 [Test]
  82                 public void CreateEncryptor_IvNull ()
  83                 {
  84                         ICryptoTransform encryptor = des.CreateEncryptor (des.Key, null);
  85                         byte[] data = new byte[encryptor.InputBlockSize];
  86                         byte[] encdata = encryptor.TransformFinalBlock (data, 0, data.Length);
  87
  88                         ICryptoTransform decryptor = des.CreateDecryptor (des.Key, des.IV);
  89                         byte[] decdata = decryptor.TransformFinalBlock (encdata, 0, encdata.Length);
  90                         Assert.IsFalse (BitConverter.ToString (data) == BitConverter.ToString (decdata), "Compare");
  91                         // null iv != SymmetricAlgorithm.IV
  92                 }
  93
  94                 [Test]
  95                 public void CreateEncryptor_KeyIv ()
  96                 {
  97                         byte[] originalKey = des.Key;
  98                         byte[] originalIV = des.IV;
  99
 100                         byte[] key = (byte[]) des.Key.Clone ();
 101                         Array.Reverse (key);
 102                         byte[] iv = (byte[]) des.IV.Clone ();
 103                         Array.Reverse (iv);
 104
 105                         Assert.IsNotNull (des.CreateEncryptor (key, iv), "CreateEncryptor");
 106
 107                         Assert.AreEqual (originalKey, des.Key, "Key");
 108                         Assert.AreEqual (originalIV, des.IV, "IV");
 109                         // SymmetricAlgorithm Key and IV not changed by CreateEncryptor
 110                 }
 111
 112                 [Test]
 113 #if NET_2_0
 114                 [ExpectedException (typeof (CryptographicException))]
 115 #else
 116                 [ExpectedException (typeof (NullReferenceException))]
 117 #endif
 118                 public void CreateDecryptor_KeyNull ()
 119                 {
 120                         ICryptoTransform encryptor = des.CreateEncryptor (des.Key, des.IV);
 121                         byte[] data = new byte[encryptor.InputBlockSize];
 122                         byte[] encdata = encryptor.TransformFinalBlock (data, 0, data.Length);
 123
 124                         ICryptoTransform decryptor = des.CreateDecryptor (null, des.IV);
 125                         byte[] decdata = decryptor.TransformFinalBlock (encdata, 0, encdata.Length);
 126                         // null key != SymmetricAlgorithm.Key
 127                 }
 128
 129                 [Test]
 130                 public void CreateDecryptor_IvNull ()
 131                 {
 132                         ICryptoTransform encryptor = des.CreateEncryptor (des.Key, des.IV);
 133                         byte[] data = new byte[encryptor.InputBlockSize];
 134                         byte[] encdata = encryptor.TransformFinalBlock (data, 0, data.Length);
 135
 136                         ICryptoTransform decryptor = des.CreateDecryptor (des.Key, null);
 137                         byte[] decdata = decryptor.TransformFinalBlock (encdata, 0, encdata.Length);
 138                         Assert.IsFalse (BitConverter.ToString (data) == BitConverter.ToString (decdata), "Compare");
 139                         // null iv != SymmetricAlgorithm.IV
 140                 }
 141
 142                 [Test]
 143                 public void CreateDecryptor_KeyIv ()
 144                 {
 145                         byte[] originalKey = des.Key;
 146                         byte[] originalIV = des.IV;
 147
 148                         byte[] key = (byte[]) des.Key.Clone ();
 149                         Array.Reverse (key);
 150                         byte[] iv = (byte[]) des.IV.Clone ();
 151                         Array.Reverse (iv);
 152
 153                         Assert.IsNotNull (des.CreateEncryptor (key, iv), "CreateDecryptor");
 154
 155                         Assert.AreEqual (originalKey, des.Key, "Key");
 156                         Assert.AreEqual (originalIV, des.IV, "IV");
 157                         // SymmetricAlgorithm Key and IV not changed by CreateDecryptor
 158                 }
 159
 160                 // Setting the IV is more restrictive than supplying an IV to
 161                 // CreateEncryptor and CreateDecryptor. See bug #76483
 162
 163                 private ICryptoTransform CreateEncryptor_IV (int size)
 164                 {
 165                         byte[] iv = (size == -1) ? null : new byte[size];
 166                         return des.CreateEncryptor (des.Key, iv);
 167                 }
 168
 169                 [Test]
 170                 public void CreateEncryptor_IV_Null ()
 171                 {
 172                         CreateEncryptor_IV (-1);
 173                 }
 174
 175                 [Test]
 176 #if NET_2_0
 177                 [ExpectedException (typeof (CryptographicException))]
 178 #endif
 179                 public void CreateEncryptor_IV_Zero ()
 180                 {
 181                         CreateEncryptor_IV (0);
 182                 }
 183
 184                 [Test]
 185 #if NET_2_0
 186                 [ExpectedException (typeof (CryptographicException))]
 187 #endif
 188                 public void CreateEncryptor_IV_TooSmall ()
 189                 {
 190                         int size = (des.BlockSize >> 3) - 1;
 191                         CreateEncryptor_IV (size);
 192                 }
 193
 194                 [Test]
 195                 public void CreateEncryptor_IV_BlockSize ()
 196                 {
 197                         int size = (des.BlockSize >> 3);
 198                         CreateEncryptor_IV (size);
 199                 }
 200
 201                 [Test]
 202                 public void CreateEncryptor_IV_TooBig ()
 203                 {
 204                         int size = des.BlockSize; // 8 times too big
 205                         CreateEncryptor_IV (size);
 206                 }
 207
 208                 private ICryptoTransform CreateDecryptor_IV (int size)
 209                 {
 210                         byte[] iv = (size == -1) ? null : new byte[size];
 211                         return des.CreateDecryptor (des.Key, iv);
 212                 }
 213
 214                 [Test]
 215                 public void CreateDecryptor_IV_Null ()
 216                 {
 217                         CreateDecryptor_IV (-1);
 218                 }
 219
 220                 [Test]
 221 #if NET_2_0
 222                 [ExpectedException (typeof (CryptographicException))]
 223 #endif
 224                 public void CreateDecryptor_IV_Zero ()
 225                 {
 226                         CreateDecryptor_IV (0);
 227                 }
 228
 229                 [Test]
 230 #if NET_2_0
 231                 [ExpectedException (typeof (CryptographicException))]
 232 #endif
 233                 public void CreateDecryptor_IV_TooSmall ()
 234                 {
 235                         int size = (des.BlockSize >> 3) - 1;
 236                         CreateDecryptor_IV (size);
 237                 }
 238
 239                 [Test]
 240                 public void CreateDecryptor_IV_BlockSize ()
 241                 {
 242                         int size = (des.BlockSize >> 3);
 243                         CreateDecryptor_IV (size);
 244                 }
 245
 246                 [Test]
 247                 public void CreateDecryptor_IV_TooBig ()
 248                 {
 249                         int size = des.BlockSize; // 8 times too big
 250                         CreateDecryptor_IV (size);
 251                 }
 252         }
 253 }