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

   1 //
   2 // PaddingModeTest.cs - NUnit Test Cases for PaddingMode
   3 //
   4 // Author:
   5 //      Sebastien Pouliot (spouliot@motus.com)
   6 //
   7 // (C) 2003 Motus Technologies Inc. (http://www.motus.com)
   8 //
   9
  10 using NUnit.Framework;
  11 using System;
  12 using System.IO;
  13 using System.Security.Cryptography;
  14
  15 namespace MonoTests.System.Security.Cryptography {
  16
  17         [TestFixture]
  18         public class PaddingModeTest : Assertion {
  19
  20                 private static byte[] key1 = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
  21                 private static byte[] key2 = { 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01 };
  22                 private static byte[] key3 = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
  23
  24                 public void AssertEquals (string msg, byte[] array1, byte[] array2)
  25                 {
  26                         AllTests.AssertEquals (msg, array1, array2);
  27                 }
  28
  29                 protected byte[] CombineKeys (byte[] key1, byte[] key2, byte[] key3)
  30                 {
  31                         int k1l = key1.Length;
  32                         int k2l = key2.Length;
  33                         int k3l = key3.Length;
  34                         byte[] key = new byte [k1l + k2l + k3l];
  35                         Array.Copy (key1, 0, key, 0, k1l);
  36                         Array.Copy (key2, 0, key, k1l, k2l);
  37                         Array.Copy (key3, 0, key, k1l + k2l, k3l);
  38                         return key;
  39                 }
  40
  41                 private byte[] Decrypt (SymmetricAlgorithm algo, PaddingMode padding, byte[] data)
  42                 {
  43                         algo.IV = new byte [algo.BlockSize >> 3];
  44                         algo.Mode = CipherMode.CBC;
  45                         algo.Padding = padding;
  46                         ICryptoTransform ct = algo.CreateDecryptor ();
  47                         return ct.TransformFinalBlock (data, 0, data.Length);
  48                 }
  49
  50                 private byte[] Encrypt (SymmetricAlgorithm algo, PaddingMode padding, byte[] data)
  51                 {
  52                         algo.IV = new byte [algo.BlockSize >> 3];
  53                         algo.Mode = CipherMode.CBC;
  54                         algo.Padding = padding;
  55                         ICryptoTransform ct = algo.CreateEncryptor ();
  56                         return ct.TransformFinalBlock (data, 0, data.Length);
  57                 }
  58
  59                 private byte[] GetData (byte size)
  60                 {
  61                         byte[] data = new byte [size];
  62                         for (byte i=0; i < size; i++) {
  63                                 data [i] = i;
  64                         }
  65                         return data;
  66                 }
  67
  68                 private TripleDES GetTripleDES ()
  69                 {
  70                         TripleDES tdes = TripleDES.Create ();
  71                         tdes.Key = CombineKeys (key1, key2, key3);
  72                         return tdes;
  73                 }
  74
  75                 [Test]
  76                 [ExpectedException (typeof (CryptographicException))]
  77                 public void TripleDESNone_SmallerThanOneBlockSize ()
  78                 {
  79                         TripleDES tdes = GetTripleDES ();
  80                         byte[] data = GetData (7);
  81                         byte[] encdata = Encrypt (tdes, PaddingMode.None, data);
  82                 }
  83
  84                 [Test]
  85                 public void TripleDESNone_ExactlyOneBlockSize ()
  86                 {
  87                         TripleDES tdes = GetTripleDES ();
  88                         byte[] data = GetData (8);
  89                         byte[] encdata = Encrypt (tdes, PaddingMode.None, data);
  90                         AssertEquals ("TripleDESNone_ExactlyOneBlockSize_Encrypt", "23-61-AC-E6-C5-17-10-51", BitConverter.ToString (encdata));
  91                         byte[] decdata = Decrypt (tdes, PaddingMode.None, encdata);
  92                         AssertEquals ("TripleDESNone_ExactlyOneBlockSize_Decrypt", data, decdata);
  93                 }
  94
  95                 [Test]
  96                 [ExpectedException (typeof (CryptographicException))]
  97                 public void TripleDESNone_MoreThanOneBlockSize ()
  98                 {
  99                         TripleDES tdes = GetTripleDES ();
 100                         byte[] data = GetData (12);
 101                         byte[] encdata = Encrypt (tdes, PaddingMode.None, data);
 102                 }
 103
 104                 [Test]
 105                 public void TripleDESNone_ExactMultipleBlockSize ()
 106                 {
 107                         TripleDES tdes = GetTripleDES ();
 108                         byte[] data = GetData (48);
 109                         byte[] encdata = Encrypt (tdes, PaddingMode.None, data);
 110                         // note: encrypted data is truncated to a multiple of block size
 111                         AssertEquals ("TripleDESNone_ExactMultipleBlockSize_Encrypt", "23-61-AC-E6-C5-17-10-51-BF-AB-79-9C-CD-5E-79-40-16-81-0D-6B-40-E6-B2-E9-86-34-8A-9E-5D-56-DA-D1-0C-8C-76-0A-E1-69-A1-0A-B5-B5-7F-FC-5A-D0-6E-6A", BitConverter.ToString (encdata));
 112                         byte[] decdata = Decrypt (tdes, PaddingMode.None, encdata);
 113                         AssertEquals ("TripleDESNone_ExactMultipleBlockSize_Decrypt", GetData (48), decdata);
 114                 }
 115
 116                 [Test]
 117                 public void TripleDESPKCS7_SmallerThanOneBlockSize ()
 118                 {
 119                         TripleDES tdes = GetTripleDES ();
 120                         byte[] data = GetData (7);
 121                         byte[] encdata = Encrypt (tdes, PaddingMode.PKCS7, data);
 122                         AssertEquals ("TripleDESPKCS7_SmallerThanOneBlockSize_Encrypt", "C6-59-0E-E3-7F-26-92-B0", BitConverter.ToString (encdata));
 123                         byte[] decdata = Decrypt (tdes, PaddingMode.PKCS7, encdata);
 124                         AssertEquals ("TripleDESPKCS7_SmallerThanOneBlockSize_Decrypt", data, decdata);
 125                 }
 126
 127                 [Test]
 128                 public void TripleDESPKCS7_ExactlyOneBlockSize ()
 129                 {
 130                         TripleDES tdes = GetTripleDES ();
 131                         byte[] data = GetData (8);
 132                         byte[] encdata = Encrypt (tdes, PaddingMode.PKCS7, data);
 133                         AssertEquals ("TripleDESPKCS7_ExactlyOneBlockSize_Encrypt", "23-61-AC-E6-C5-17-10-51-C0-60-5B-6A-5C-B7-69-62", BitConverter.ToString (encdata));
 134                         byte[] decdata = Decrypt (tdes, PaddingMode.PKCS7, encdata);
 135                         AssertEquals ("TripleDESPKCS7_ExactlyOneBlockSize_Decrypt", data, decdata);
 136                 }
 137
 138                 [Test]
 139                 public void TripleDESPKCS7_MoreThanOneBlockSize ()
 140                 {
 141                         TripleDES tdes = GetTripleDES ();
 142                         byte[] data = GetData (12);
 143                         byte[] encdata = Encrypt (tdes, PaddingMode.PKCS7, data);
 144                         AssertEquals ("TripleDESPKCS7_MoreThanOneBlockSize_Encrypt", "23-61-AC-E6-C5-17-10-51-D9-CB-92-8C-76-89-35-84", BitConverter.ToString (encdata));
 145                         byte[] decdata = Decrypt (tdes, PaddingMode.PKCS7, encdata);
 146                         AssertEquals ("TripleDESPKCS7_MoreThanOneBlockSize_Decrypt", data, decdata);
 147                 }
 148
 149                 [Test]
 150                 public void TripleDESPKCS7_ExactMultipleBlockSize ()
 151                 {
 152                         TripleDES tdes = GetTripleDES ();
 153                         byte[] data = GetData (48);
 154                         byte[] encdata = Encrypt (tdes, PaddingMode.PKCS7, data);
 155                         AssertEquals ("TripleDESPKCS7_ExactMultipleBlockSize_Encrypt", "23-61-AC-E6-C5-17-10-51-BF-AB-79-9C-CD-5E-79-40-16-81-0D-6B-40-E6-B2-E9-86-34-8A-9E-5D-56-DA-D1-0C-8C-76-0A-E1-69-A1-0A-B5-B5-7F-FC-5A-D0-6E-6A-73-61-63-1C-58-A2-9C-B3", BitConverter.ToString (encdata));
 156                         byte[] decdata = Decrypt (tdes, PaddingMode.PKCS7, encdata);
 157                         AssertEquals ("TripleDESPKCS7_ExactMultipleBlockSize_Decrypt", data, decdata);
 158                 }
 159
 160                 [Test]
 161                 public void TripleDESZeros_SmallerThanOneBlockSize ()
 162                 {
 163                         TripleDES tdes = GetTripleDES ();
 164                         byte[] data = GetData (7);
 165                         byte[] encdata = Encrypt (tdes, PaddingMode.Zeros, data);
 166                         AssertEquals ("TripleDESZeros_SmallerThanOneBlockSize_Encrypt", "B8-5C-5B-A5-06-0B-7E-C6", BitConverter.ToString (encdata));
 167                         byte[] decdata = Decrypt (tdes, PaddingMode.Zeros, encdata);
 168                         AssertEquals ("TripleDESZeros_SmallerThanOneBlockSize_Decrypt", "00-01-02-03-04-05-06-00", BitConverter.ToString (decdata));
 169                 }
 170
 171                 [Test]
 172                 public void TripleDESZeros_ExactlyOneBlockSize ()
 173                 {
 174                         TripleDES tdes = GetTripleDES ();
 175                         byte[] data = GetData (8);
 176                         byte[] encdata = Encrypt (tdes, PaddingMode.Zeros, data);
 177                         AssertEquals ("TripleDESZeros_ExactlyOneBlockSize_Encrypt", "23-61-AC-E6-C5-17-10-51", BitConverter.ToString (encdata));
 178                         byte[] decdata = Decrypt (tdes, PaddingMode.Zeros, encdata);
 179                         AssertEquals ("TripleDESZeros_ExactlyOneBlockSize_Decrypt", data, decdata);
 180                 }
 181
 182                 [Test]
 183                 public void TripleDESZeros_MoreThanOneBlockSize ()
 184                 {
 185                         TripleDES tdes = GetTripleDES ();
 186                         byte[] data = GetData (12);
 187                         byte[] encdata = Encrypt (tdes, PaddingMode.Zeros, data);
 188                         AssertEquals ("TripleDESZeros_MoreThanOneBlockSize_Encrypt", "23-61-AC-E6-C5-17-10-51-6E-75-2E-33-12-09-5D-66", BitConverter.ToString (encdata));
 189                         byte[] decdata = Decrypt (tdes, PaddingMode.Zeros, encdata);
 190                         AssertEquals ("TripleDESZeros_MoreThanOneBlockSize_Decrypt", "00-01-02-03-04-05-06-07-08-09-0A-0B-00-00-00-00", BitConverter.ToString (decdata));
 191                 }
 192
 193                 [Test]
 194                 public void TripleDESZeros_ExactMultipleBlockSize ()
 195                 {
 196                         TripleDES tdes = GetTripleDES ();
 197                         byte[] data = GetData (48);
 198                         byte[] encdata = Encrypt (tdes, PaddingMode.Zeros, data);
 199                         AssertEquals ("TripleDESZeros_ExactMultipleBlockSize_Encrypt", "23-61-AC-E6-C5-17-10-51-BF-AB-79-9C-CD-5E-79-40-16-81-0D-6B-40-E6-B2-E9-86-34-8A-9E-5D-56-DA-D1-0C-8C-76-0A-E1-69-A1-0A-B5-B5-7F-FC-5A-D0-6E-6A", BitConverter.ToString (encdata));
 200                         byte[] decdata = Decrypt (tdes, PaddingMode.Zeros, encdata);
 201                         AssertEquals ("TripleDESZeros_ExactMultipleBlockSize_Decrypt", GetData (48), decdata);
 202                 }
 203
 204                 private Rijndael GetAES ()
 205                 {
 206                         Rijndael aes = Rijndael.Create ();
 207                         aes.Key = CombineKeys (key1, key2, key3);
 208                         return aes;
 209                 }
 210
 211                 [Test]
 212                 [ExpectedException (typeof (CryptographicException))]
 213                 public void RijndaelNone_SmallerThanOneBlockSize ()
 214                 {
 215                         Rijndael aes = GetAES ();
 216                         byte[] data = GetData (8);
 217                         byte[] encdata = Encrypt (aes, PaddingMode.None, data);
 218                 }
 219
 220                 [Test]
 221                 public void RijndaelNone_ExactlyOneBlockSize ()
 222                 {
 223                         Rijndael aes = GetAES ();
 224                         byte[] data = GetData (16);
 225                         byte[] encdata = Encrypt (aes, PaddingMode.None, data);
 226                         AssertEquals ("RijndaelNone_ExactlyOneBlockSize_Encrypt", "79-42-36-2F-D6-DB-F1-0C-87-99-58-06-D5-F6-B0-BB", BitConverter.ToString (encdata));
 227                         byte[] decdata = Decrypt (aes, PaddingMode.None, encdata);
 228                         AssertEquals ("RijndaelNone_ExactlyOneBlockSize_Decrypt", data, decdata);
 229                 }
 230
 231                 [Test]
 232                 [ExpectedException (typeof (CryptographicException))]
 233                 public void RijndaelNone_MoreThanOneBlockSize ()
 234                 {
 235                         Rijndael aes = GetAES ();
 236                         byte[] data = GetData (20);
 237                         byte[] encdata = Encrypt (aes, PaddingMode.None, data);
 238                 }
 239
 240                 [Test]
 241                 public void RijndaelNone_ExactMultipleBlockSize ()
 242                 {
 243                         Rijndael aes = GetAES ();
 244                         byte[] data = GetData (48);
 245                         byte[] encdata = Encrypt (aes, PaddingMode.None, data);
 246                         // note: encrypted data is truncated to a multiple of block size
 247                         AssertEquals ("RijndaelNone_ExactMultipleBlockSize_Encrypt", "79-42-36-2F-D6-DB-F1-0C-87-99-58-06-D5-F6-B0-BB-E1-27-3E-21-5A-BE-D5-12-F4-AF-06-8D-0A-BD-02-64-02-CB-FF-D7-32-19-5E-69-3C-54-C2-8C-A1-D7-72-FF", BitConverter.ToString (encdata));
 248                         byte[] decdata = Decrypt (aes, PaddingMode.None, encdata);
 249                         AssertEquals ("RijndaelNone_ExactMultipleBlockSize_Decrypt", GetData (48), decdata);
 250                 }
 251
 252                 [Test]
 253                 public void RijndaelPKCS7_SmallerThanOneBlockSize ()
 254                 {
 255                         Rijndael aes = GetAES ();
 256                         byte[] data = GetData (8);
 257                         byte[] encdata = Encrypt (aes, PaddingMode.PKCS7, data);
 258                         AssertEquals ("RijndaelPKCS7_SmallerThanOneBlockSize_Encrypt", "AB-E0-20-5E-BC-28-A0-B7-A7-56-A3-BF-13-55-13-7E", BitConverter.ToString (encdata));
 259                         byte[] decdata = Decrypt (aes, PaddingMode.PKCS7, encdata);
 260                         AssertEquals ("RijndaelPKCS7_SmallerThanOneBlockSize_Decrypt", data, decdata);
 261                 }
 262
 263                 [Test]
 264                 public void RijndaelPKCS7_ExactlyOneBlockSize ()
 265                 {
 266                         Rijndael aes = GetAES ();
 267                         byte[] data = GetData (16);
 268                         byte[] encdata = Encrypt (aes, PaddingMode.PKCS7, data);
 269                         AssertEquals ("RijndaelPKCS7_ExactlyOneBlockSize_Encrypt", "79-42-36-2F-D6-DB-F1-0C-87-99-58-06-D5-F6-B0-BB-60-CE-9F-E0-72-3B-D6-D1-A5-F8-33-D8-25-31-7F-D4", BitConverter.ToString (encdata));
 270                         byte[] decdata = Decrypt (aes, PaddingMode.PKCS7, encdata);
 271                         AssertEquals ("RijndaelPKCS7_ExactlyOneBlockSize_Decrypt", data, decdata);
 272                 }
 273
 274                 [Test]
 275                 public void RijndaelPKCS7_MoreThanOneBlockSize ()
 276                 {
 277                         Rijndael aes = GetAES ();
 278                         byte[] data = GetData (20);
 279                         byte[] encdata = Encrypt (aes, PaddingMode.PKCS7, data);
 280                         AssertEquals ("RijndaelPKCS7_MoreThanOneBlockSize_Encrypt", "79-42-36-2F-D6-DB-F1-0C-87-99-58-06-D5-F6-B0-BB-06-3F-D3-51-8D-55-E9-2F-02-4A-4E-F2-91-55-31-83", BitConverter.ToString (encdata));
 281                         byte[] decdata = Decrypt (aes, PaddingMode.PKCS7, encdata);
 282                         AssertEquals ("RijndaelPKCS7_MoreThanOneBlockSize_Decrypt", data, decdata);
 283                 }
 284
 285                 [Test]
 286                 public void RijndaelPKCS7_ExactMultipleBlockSize ()
 287                 {
 288                         Rijndael aes = GetAES ();
 289                         byte[] data = GetData (48);
 290                         byte[] encdata = Encrypt (aes, PaddingMode.PKCS7, data);
 291                         AssertEquals ("RijndaelPKCS7_ExactMultipleBlockSize_Encrypt", "79-42-36-2F-D6-DB-F1-0C-87-99-58-06-D5-F6-B0-BB-E1-27-3E-21-5A-BE-D5-12-F4-AF-06-8D-0A-BD-02-64-02-CB-FF-D7-32-19-5E-69-3C-54-C2-8C-A1-D7-72-FF-37-42-81-21-47-A7-E0-AA-64-A7-8B-65-25-95-AA-54", BitConverter.ToString (encdata));
 292                         byte[] decdata = Decrypt (aes, PaddingMode.PKCS7, encdata);
 293                         AssertEquals ("RijndaelPKCS7_ExactMultipleBlockSize_Decrypt", data, decdata);
 294                 }
 295
 296                 [Test]
 297                 public void RijndaelZeros_SmallerThanOneBlockSize ()
 298                 {
 299                         Rijndael aes = GetAES ();
 300                         byte[] data = GetData (8);
 301                         byte[] encdata = Encrypt (aes, PaddingMode.Zeros, data);
 302                         AssertEquals ("RijndaelZeros_SmallerThanOneBlockSize_Encrypt", "DD-BE-D7-CE-E2-DD-5C-A3-3E-44-A1-76-00-E5-5B-5D", BitConverter.ToString (encdata));
 303                         byte[] decdata = Decrypt (aes, PaddingMode.Zeros, encdata);
 304                         AssertEquals ("RijndaelZeros_SmallerThanOneBlockSize_Decrypt", "00-01-02-03-04-05-06-07-00-00-00-00-00-00-00-00", BitConverter.ToString (decdata));
 305                 }
 306
 307                 [Test]
 308                 public void RijndaelZeros_ExactlyOneBlockSize ()
 309                 {
 310                         Rijndael aes = GetAES ();
 311                         byte[] data = GetData (16);
 312                         byte[] encdata = Encrypt (aes, PaddingMode.Zeros, data);
 313                         AssertEquals ("RijndaelZeros_ExactlyOneBlockSize_Encrypt", "79-42-36-2F-D6-DB-F1-0C-87-99-58-06-D5-F6-B0-BB", BitConverter.ToString (encdata));
 314                         byte[] decdata = Decrypt (aes, PaddingMode.Zeros, encdata);
 315                         AssertEquals ("RijndaelZeros_ExactlyOneBlockSize_Decrypt", data, decdata);
 316                 }
 317
 318                 [Test]
 319                 public void RijndaelZeros_MoreThanOneBlockSize ()
 320                 {
 321                         Rijndael aes = GetAES ();
 322                         byte[] data = GetData (20);
 323                         byte[] encdata = Encrypt (aes, PaddingMode.Zeros, data);
 324                         AssertEquals ("RijndaelZeros_MoreThanOneBlockSize_Encrypt", "79-42-36-2F-D6-DB-F1-0C-87-99-58-06-D5-F6-B0-BB-04-6C-F7-A5-DE-FF-B4-30-29-7A-0E-04-3B-D4-B8-F2", BitConverter.ToString (encdata));
 325                         byte[] decdata = Decrypt (aes, PaddingMode.Zeros, encdata);
 326                         AssertEquals ("RijndaelZeros_MoreThanOneBlockSize_Decrypt", "00-01-02-03-04-05-06-07-08-09-0A-0B-0C-0D-0E-0F-10-11-12-13-00-00-00-00-00-00-00-00-00-00-00-00", BitConverter.ToString (decdata));
 327                 }
 328
 329                 [Test]
 330                 public void RijndaelZeros_ExactMultipleBlockSize ()
 331                 {
 332                         Rijndael aes = GetAES ();
 333                         byte[] data = GetData (48);
 334                         byte[] encdata = Encrypt (aes, PaddingMode.Zeros, data);
 335                         AssertEquals ("RijndaelZeros_ExactMultipleBlockSize_Encrypt", "79-42-36-2F-D6-DB-F1-0C-87-99-58-06-D5-F6-B0-BB-E1-27-3E-21-5A-BE-D5-12-F4-AF-06-8D-0A-BD-02-64-02-CB-FF-D7-32-19-5E-69-3C-54-C2-8C-A1-D7-72-FF", BitConverter.ToString (encdata));
 336                         byte[] decdata = Decrypt (aes, PaddingMode.Zeros, encdata);
 337                         AssertEquals ("RijndaelZeros_ExactMultipleBlockSize_Decrypt", GetData (48), decdata);
 338                 }
 339         }
 340 }