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

   1 //
   2 // MonoTests.System.Security.SymmetricAlgorithmTransformTest.cs
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // Copyright (C) 2007 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         public abstract class SymmetricAlgorithmTransformTest {
  37
  38                 public abstract SymmetricAlgorithm Algorithm { get; }
  39
  40                 public virtual int BlockSize {
  41                         get { return 8; }
  42                 }
  43
  44
  45                 // see bug #80439
  46                 public void DontDecryptLastBlock (CipherMode mode, PaddingMode padding)
  47                 {
  48                         SymmetricAlgorithm algo = Algorithm;
  49                         algo.Mode = mode;
  50                         algo.Padding = padding;
  51                         ICryptoTransform enc = algo.CreateEncryptor ();
  52                         byte[] plaintext = new byte[BlockSize * 7];
  53                         byte[] encdata = new byte[BlockSize * 8];
  54                         int len = enc.TransformBlock (plaintext, 0, plaintext.Length, encdata, 0);
  55                         Assert.AreEqual (plaintext.Length, len, "encdata");
  56
  57                         ICryptoTransform dec = algo.CreateDecryptor ();
  58                         byte[] decdata = new byte[plaintext.Length];
  59                         len = dec.TransformBlock (encdata, 0, encdata.Length, decdata, 0);
  60                         Assert.AreEqual (plaintext.Length, len, "decdata");
  61
  62                         Assert.AreEqual (plaintext, decdata, "TransformBlock." + mode.ToString ());
  63                 }
  64
  65                 [Test]
  66                 [ExpectedException (typeof (CryptographicException))]
  67                 public void DontDecryptLastBlock_CBC_None ()
  68                 {
  69                         DontDecryptLastBlock (CipherMode.CBC, PaddingMode.None);
  70                 }
  71
  72                 [Test]
  73                 public void DontDecryptLastBlock_CBC_PKCS7 ()
  74                 {
  75                         DontDecryptLastBlock (CipherMode.CBC, PaddingMode.PKCS7);
  76                 }
  77
  78                 [Test]
  79                 [ExpectedException (typeof (CryptographicException))]
  80                 public void DontDecryptLastBlock_CBC_Zeros ()
  81                 {
  82                         DontDecryptLastBlock (CipherMode.CBC, PaddingMode.Zeros);
  83                 }
  84 #if NET_2_0
  85                 [Test]
  86                 public void DontDecryptLastBlock_CBC_ANSIX923 ()
  87                 {
  88                         DontDecryptLastBlock (CipherMode.CBC, PaddingMode.ANSIX923);
  89                 }
  90
  91                 [Test]
  92                 public void DontDecryptLastBlock_CBC_ISO10126 ()
  93                 {
  94                         DontDecryptLastBlock (CipherMode.CBC, PaddingMode.ISO10126);
  95                 }
  96 #endif
  97                 [Test]
  98                 [ExpectedException (typeof (CryptographicException))]
  99                 public void DontDecryptLastBlock_CFB_None ()
 100                 {
 101                         DontDecryptLastBlock (CipherMode.CFB, PaddingMode.None);
 102                 }
 103
 104                 [Test]
 105                 public void DontDecryptLastBlock_CFB_PKCS7 ()
 106                 {
 107                         DontDecryptLastBlock (CipherMode.CFB, PaddingMode.PKCS7);
 108                 }
 109
 110                 [Test]
 111                 [ExpectedException (typeof (CryptographicException))]
 112                 public void DontDecryptLastBlock_CFB_Zeros ()
 113                 {
 114                         DontDecryptLastBlock (CipherMode.CFB, PaddingMode.Zeros);
 115                 }
 116 #if NET_2_0
 117                 [Test]
 118                 public void DontDecryptLastBlock_CFB_ANSIX923 ()
 119                 {
 120                         DontDecryptLastBlock (CipherMode.CFB, PaddingMode.ANSIX923);
 121                 }
 122
 123                 [Test]
 124                 public void DontDecryptLastBlock_CFB_ISO10126 ()
 125                 {
 126                         DontDecryptLastBlock (CipherMode.CFB, PaddingMode.ISO10126);
 127                 }
 128 #endif
 129                 [Test]
 130                 [ExpectedException (typeof (CryptographicException))]
 131                 public void DontDecryptLastBlock_ECB_None ()
 132                 {
 133                         DontDecryptLastBlock (CipherMode.ECB, PaddingMode.None);
 134                 }
 135
 136                 [Test]
 137                 public void DontDecryptLastBlock_ECB_PKCS7 ()
 138                 {
 139                         DontDecryptLastBlock (CipherMode.ECB, PaddingMode.PKCS7);
 140                 }
 141
 142                 [Test]
 143                 [ExpectedException (typeof (CryptographicException))]
 144                 public void DontDecryptLastBlock_ECB_Zeros ()
 145                 {
 146                         DontDecryptLastBlock (CipherMode.ECB, PaddingMode.Zeros);
 147                 }
 148 #if NET_2_0
 149                 [Test]
 150                 public void DontDecryptLastBlock_ECB_ANSIX923 ()
 151                 {
 152                         DontDecryptLastBlock (CipherMode.ECB, PaddingMode.ANSIX923);
 153                 }
 154
 155                 [Test]
 156                 public void DontDecryptLastBlock_ECB_ISO10126 ()
 157                 {
 158                         DontDecryptLastBlock (CipherMode.ECB, PaddingMode.ISO10126);
 159                 }
 160 #endif
 161                 // see bug #80439 (2nd try, reopened)
 162                 // same as DontDecryptLastBlock except
 163                 // a. the encryption transform was final (padding was added)
 164                 // b. we can call/test decryption TransformFinalBlock too
 165                 public void DontDecryptLastBlock_Final (CipherMode mode, PaddingMode padding)
 166                 {
 167                         SymmetricAlgorithm algo = Algorithm;
 168                         algo.Mode = mode;
 169                         algo.Padding = padding;
 170                         ICryptoTransform enc = algo.CreateEncryptor ();
 171                         byte[] plaintext = new byte[BlockSize * 7];
 172                         byte[] encdata = enc.TransformFinalBlock (plaintext, 0, plaintext.Length);
 173                         switch (padding) {
 174                         case PaddingMode.None:
 175                         case PaddingMode.Zeros:
 176                                 Assert.AreEqual (BlockSize * 7, encdata.Length, "encdata");
 177                                 break;
 178                         default:
 179                                 Assert.AreEqual (BlockSize * 8, encdata.Length, "encdata");
 180                                 break;
 181                         }
 182
 183                         ICryptoTransform dec = algo.CreateDecryptor ();
 184                         byte[] decdata = new byte[plaintext.Length];
 185                         dec.TransformBlock (encdata, 0, encdata.Length, decdata, 0);
 186
 187                         Assert.AreEqual (plaintext, decdata, "TransformBlock." + mode.ToString ());
 188
 189                         dec = algo.CreateDecryptor ();
 190                         byte[] final = dec.TransformFinalBlock (encdata, 0, encdata.Length);
 191                         Assert.AreEqual (plaintext, final, "TransformFinalBlock." + mode.ToString ());
 192                 }
 193
 194                 [Test]
 195                 public void DontDecryptLastBlock_Final_CBC_None ()
 196                 {
 197                         DontDecryptLastBlock_Final (CipherMode.CBC, PaddingMode.None);
 198                 }
 199
 200                 [Test]
 201                 public void DontDecryptLastBlock_Final_CBC_PKCS7 ()
 202                 {
 203                         DontDecryptLastBlock_Final (CipherMode.CBC, PaddingMode.PKCS7);
 204                 }
 205
 206                 [Test]
 207                 public void DontDecryptLastBlock_Final_CBC_Zeros ()
 208                 {
 209                         DontDecryptLastBlock_Final (CipherMode.CBC, PaddingMode.Zeros);
 210                 }
 211 #if NET_2_0
 212                 [Test]
 213                 public void DontDecryptLastBlock_Final_CBC_ANSIX923 ()
 214                 {
 215                         DontDecryptLastBlock_Final (CipherMode.CBC, PaddingMode.ANSIX923);
 216                 }
 217
 218                 [Test]
 219                 public void DontDecryptLastBlock_Final_CBC_ISO10126 ()
 220                 {
 221                         DontDecryptLastBlock_Final (CipherMode.CBC, PaddingMode.ISO10126);
 222                 }
 223 #endif
 224                 [Test]
 225                 public void DontDecryptLastBlock_Final_CFB_None ()
 226                 {
 227                         DontDecryptLastBlock_Final (CipherMode.CFB, PaddingMode.None);
 228                 }
 229
 230                 [Test]
 231                 public void DontDecryptLastBlock_Final_CFB_PKCS7 ()
 232                 {
 233                         DontDecryptLastBlock_Final (CipherMode.CFB, PaddingMode.PKCS7);
 234                 }
 235
 236                 [Test]
 237                 public void DontDecryptLastBlock_Final_CFB_Zeros ()
 238                 {
 239                         DontDecryptLastBlock_Final (CipherMode.CFB, PaddingMode.Zeros);
 240                 }
 241 #if NET_2_0
 242                 [Test]
 243                 public void DontDecryptLastBlock_Final_CFB_ANSIX923 ()
 244                 {
 245                         DontDecryptLastBlock_Final (CipherMode.CFB, PaddingMode.ANSIX923);
 246                 }
 247
 248                 [Test]
 249                 public void DontDecryptLastBlock_Final_CFB_ISO10126 ()
 250                 {
 251                         DontDecryptLastBlock_Final (CipherMode.CFB, PaddingMode.ISO10126);
 252                 }
 253 #endif
 254                 [Test]
 255                 public void DontDecryptLastBlock_Final_ECB_None ()
 256                 {
 257                         DontDecryptLastBlock_Final (CipherMode.ECB, PaddingMode.None);
 258                 }
 259
 260                 [Test]
 261                 public void DontDecryptLastBlock_Final_ECB_PKCS7 ()
 262                 {
 263                         DontDecryptLastBlock_Final (CipherMode.ECB, PaddingMode.PKCS7);
 264                 }
 265
 266                 [Test]
 267                 public void DontDecryptLastBlock_Final_ECB_Zeros ()
 268                 {
 269                         DontDecryptLastBlock_Final (CipherMode.ECB, PaddingMode.Zeros);
 270                 }
 271 #if NET_2_0
 272                 [Test]
 273                 public void DontDecryptLastBlock_Final_ECB_ANSIX923 ()
 274                 {
 275                         DontDecryptLastBlock_Final (CipherMode.ECB, PaddingMode.ANSIX923);
 276                 }
 277
 278                 [Test]
 279                 public void DontDecryptLastBlock_Final_ECB_ISO10126 ()
 280                 {
 281                         DontDecryptLastBlock_Final (CipherMode.ECB, PaddingMode.ISO10126);
 282                 }
 283 #endif
 284                 // similar to previous case but here we try to skip several blocks
 285                 // i.e. encdata.Length versus decdata.Length
 286                 public void DontDecryptMultipleBlock (CipherMode mode, PaddingMode padding)
 287                 {
 288                         SymmetricAlgorithm algo = Algorithm;
 289                         algo.Mode = mode;
 290                         algo.Padding = padding;
 291                         ICryptoTransform enc = algo.CreateEncryptor ();
 292                         byte[] plaintext = new byte[BlockSize * 7];
 293                         byte[] encdata = new byte[BlockSize * 8];
 294                         int len = enc.TransformBlock (plaintext, 0, plaintext.Length, encdata, 0);
 295                         Assert.AreEqual (plaintext.Length, len, "encdata");
 296
 297                         ICryptoTransform dec = algo.CreateDecryptor ();
 298                         byte[] decdata = new byte[BlockSize];
 299                         dec.TransformBlock (encdata, 0, encdata.Length, decdata, 0);
 300                 }
 301
 302                 [Test]
 303                 [ExpectedException (typeof (CryptographicException))]
 304                 public void DontDecryptMultipleBlock_CBC_None ()
 305                 {
 306                         DontDecryptMultipleBlock (CipherMode.CBC, PaddingMode.None);
 307                 }
 308
 309                 [Test]
 310                 [ExpectedException (typeof (CryptographicException))]
 311                 public void DontDecryptMultipleBlock_CBC_PKCS7 ()
 312                 {
 313                         DontDecryptMultipleBlock (CipherMode.CBC, PaddingMode.PKCS7);
 314                 }
 315
 316                 [Test]
 317                 [ExpectedException (typeof (CryptographicException))]
 318                 public void DontDecryptMultipleBlock_CBC_Zeros ()
 319                 {
 320                         DontDecryptMultipleBlock (CipherMode.CBC, PaddingMode.Zeros);
 321                 }
 322 #if NET_2_0
 323                 [Test]
 324                 [ExpectedException (typeof (CryptographicException))]
 325                 public void DontDecryptMultipleBlock_CBC_ANSIX923 ()
 326                 {
 327                         DontDecryptMultipleBlock (CipherMode.CBC, PaddingMode.ANSIX923);
 328                 }
 329
 330                 [Test]
 331                 [ExpectedException (typeof (CryptographicException))]
 332                 public void DontDecryptMultipleBlock_CBC_ISO10126 ()
 333                 {
 334                         DontDecryptMultipleBlock (CipherMode.CBC, PaddingMode.ISO10126);
 335                 }
 336 #endif
 337                 [Test]
 338                 [ExpectedException (typeof (CryptographicException))]
 339                 public void DontDecryptMultipleBlock_CFB_None ()
 340                 {
 341                         DontDecryptMultipleBlock (CipherMode.CFB, PaddingMode.None);
 342                 }
 343
 344                 [Test]
 345                 [ExpectedException (typeof (CryptographicException))]
 346                 public void DontDecryptMultipleBlock_CFB_PKCS7 ()
 347                 {
 348                         DontDecryptMultipleBlock (CipherMode.CFB, PaddingMode.PKCS7);
 349                 }
 350
 351                 [Test]
 352                 [ExpectedException (typeof (CryptographicException))]
 353                 public void DontDecryptMultipleBlock_CFB_Zeros ()
 354                 {
 355                         DontDecryptMultipleBlock (CipherMode.CFB, PaddingMode.Zeros);
 356                 }
 357 #if NET_2_0
 358                 [Test]
 359                 [ExpectedException (typeof (CryptographicException))]
 360                 public void DontDecryptMultipleBlock_CFB_ANSIX923 ()
 361                 {
 362                         DontDecryptMultipleBlock (CipherMode.CFB, PaddingMode.ANSIX923);
 363                 }
 364
 365                 [Test]
 366                 [ExpectedException (typeof (CryptographicException))]
 367                 public void DontDecryptMultipleBlock_CFB_ISO10126 ()
 368                 {
 369                         DontDecryptMultipleBlock (CipherMode.CFB, PaddingMode.ISO10126);
 370                 }
 371 #endif
 372                 [Test]
 373                 [ExpectedException (typeof (CryptographicException))]
 374                 public void DontDecryptMultipleBlock_ECB_None ()
 375                 {
 376                         DontDecryptMultipleBlock (CipherMode.ECB, PaddingMode.None);
 377                 }
 378
 379                 [Test]
 380                 [ExpectedException (typeof (CryptographicException))]
 381                 public void DontDecryptMultipleBlock_ECB_PKCS7 ()
 382                 {
 383                         DontDecryptMultipleBlock (CipherMode.ECB, PaddingMode.PKCS7);
 384                 }
 385
 386                 [Test]
 387                 [ExpectedException (typeof (CryptographicException))]
 388                 public void DontDecryptMultipleBlock_ECB_Zeros ()
 389                 {
 390                         DontDecryptMultipleBlock (CipherMode.ECB, PaddingMode.Zeros);
 391                 }
 392 #if NET_2_0
 393                 [Test]
 394                 [ExpectedException (typeof (CryptographicException))]
 395                 public void DontDecryptMultipleBlock_ECB_ANSIX923 ()
 396                 {
 397                         DontDecryptMultipleBlock (CipherMode.ECB, PaddingMode.ANSIX923);
 398                 }
 399
 400                 [Test]
 401                 [ExpectedException (typeof (CryptographicException))]
 402                 public void DontDecryptMultipleBlock_ECB_ISO10126 ()
 403                 {
 404                         DontDecryptMultipleBlock (CipherMode.ECB, PaddingMode.ISO10126);
 405                 }
 406 #endif
 407                 // similar to previous case but here the encryption transform was final
 408                 public void DontDecryptMultipleBlock_Final (CipherMode mode, PaddingMode padding)
 409                 {
 410                         SymmetricAlgorithm algo = Algorithm;
 411                         algo.Mode = mode;
 412                         algo.Padding = padding;
 413                         ICryptoTransform enc = algo.CreateEncryptor ();
 414                         byte[] plaintext = new byte[BlockSize * 7];
 415                         byte[] encdata = enc.TransformFinalBlock (plaintext, 0, plaintext.Length);
 416                         switch (padding) {
 417                         case PaddingMode.None:
 418                         case PaddingMode.Zeros:
 419                                 Assert.AreEqual (BlockSize * 7, encdata.Length, "encdata");
 420                                 break;
 421                         default:
 422                                 Assert.AreEqual (BlockSize * 8, encdata.Length, "encdata");
 423                                 break;
 424                         }
 425
 426                         ICryptoTransform dec = algo.CreateDecryptor ();
 427                         byte[] decdata = new byte[BlockSize];
 428                         dec.TransformBlock (encdata, 0, encdata.Length, decdata, 0);
 429                 }
 430
 431                 [Test]
 432                 [ExpectedException (typeof (CryptographicException))]
 433                 public void DontDecryptMultipleBlock_Final_CBC_None ()
 434                 {
 435                         DontDecryptMultipleBlock_Final (CipherMode.CBC, PaddingMode.None);
 436                 }
 437
 438                 [Test]
 439                 [ExpectedException (typeof (CryptographicException))]
 440                 public void DontDecryptMultipleBlock_Final_CBC_PKCS7 ()
 441                 {
 442                         DontDecryptMultipleBlock_Final (CipherMode.CBC, PaddingMode.PKCS7);
 443                 }
 444
 445                 [Test]
 446                 [ExpectedException (typeof (CryptographicException))]
 447                 public void DontDecryptMultipleBlock_Final_CBC_Zeros ()
 448                 {
 449                         DontDecryptMultipleBlock_Final (CipherMode.CBC, PaddingMode.Zeros);
 450                 }
 451 #if NET_2_0
 452                 [Test]
 453                 [ExpectedException (typeof (CryptographicException))]
 454                 public void DontDecryptMultipleBlock_Final_CBC_ANSIX923 ()
 455                 {
 456                         DontDecryptMultipleBlock_Final (CipherMode.CBC, PaddingMode.ANSIX923);
 457                 }
 458
 459                 [Test]
 460                 [ExpectedException (typeof (CryptographicException))]
 461                 public void DontDecryptMultipleBlock_Final_CBC_ISO10126 ()
 462                 {
 463                         DontDecryptMultipleBlock_Final (CipherMode.CBC, PaddingMode.ISO10126);
 464                 }
 465 #endif
 466                 [Test]
 467                 [ExpectedException (typeof (CryptographicException))]
 468                 public void DontDecryptMultipleBlock_Final_CFB_None ()
 469                 {
 470                         DontDecryptMultipleBlock_Final (CipherMode.CFB, PaddingMode.None);
 471                 }
 472
 473                 [Test]
 474                 [ExpectedException (typeof (CryptographicException))]
 475                 public void DontDecryptMultipleBlock_Final_CFB_PKCS7 ()
 476                 {
 477                         DontDecryptMultipleBlock_Final (CipherMode.CFB, PaddingMode.PKCS7);
 478                 }
 479
 480                 [Test]
 481                 [ExpectedException (typeof (CryptographicException))]
 482                 public void DontDecryptMultipleBlock_Final_CFB_Zeros ()
 483                 {
 484                         DontDecryptMultipleBlock_Final (CipherMode.CFB, PaddingMode.Zeros);
 485                 }
 486 #if NET_2_0
 487                 [Test]
 488                 [ExpectedException (typeof (CryptographicException))]
 489                 public void DontDecryptMultipleBlock_Final_CFB_ANSIX923 ()
 490                 {
 491                         DontDecryptMultipleBlock_Final (CipherMode.CFB, PaddingMode.ANSIX923);
 492                 }
 493
 494                 [Test]
 495                 [ExpectedException (typeof (CryptographicException))]
 496                 public void DontDecryptMultipleBlock_Final_CFB_ISO10126 ()
 497                 {
 498                         DontDecryptMultipleBlock_Final (CipherMode.CFB, PaddingMode.ISO10126);
 499                 }
 500 #endif
 501                 [Test]
 502                 [ExpectedException (typeof (CryptographicException))]
 503                 public void DontDecryptMultipleBlock_Final_ECB_None ()
 504                 {
 505                         DontDecryptMultipleBlock_Final (CipherMode.ECB, PaddingMode.None);
 506                 }
 507
 508                 [Test]
 509                 [ExpectedException (typeof (CryptographicException))]
 510                 public void DontDecryptMultipleBlock_Final_ECB_PKCS7 ()
 511                 {
 512                         DontDecryptMultipleBlock_Final (CipherMode.ECB, PaddingMode.PKCS7);
 513                 }
 514
 515                 [Test]
 516                 [ExpectedException (typeof (CryptographicException))]
 517                 public void DontDecryptMultipleBlock_Final_ECB_Zeros ()
 518                 {
 519                         DontDecryptMultipleBlock_Final (CipherMode.ECB, PaddingMode.Zeros);
 520                 }
 521 #if NET_2_0
 522                 [Test]
 523                 [ExpectedException (typeof (CryptographicException))]
 524                 public void DontDecryptMultipleBlock_Final_ECB_ANSIX923 ()
 525                 {
 526                         DontDecryptMultipleBlock_Final (CipherMode.ECB, PaddingMode.ANSIX923);
 527                 }
 528
 529                 [Test]
 530                 [ExpectedException (typeof (CryptographicException))]
 531                 public void DontDecryptMultipleBlock_Final_ECB_ISO10126 ()
 532                 {
 533                         DontDecryptMultipleBlock_Final (CipherMode.ECB, PaddingMode.ISO10126);
 534                 }
 535 #endif
 536         }
 537
 538         [TestFixture]
 539         public class DESTransformTest: SymmetricAlgorithmTransformTest {
 540
 541                 public override SymmetricAlgorithm Algorithm {
 542                         get { return DES.Create (); }
 543                 }
 544
 545                 // from Lauren Bedoule
 546                 // note: this test case works only for CBC
 547                 private void EncryptEncryptDecryptDecrypt (CipherMode mode, PaddingMode padding)
 548                 {
 549                         SymmetricAlgorithm des = Algorithm;
 550                         des.Mode = mode;
 551                         des.Padding = padding;
 552                         des.IV = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 };
 553                         des.Key = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 };
 554                         byte[] input = new byte[48] { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
 555                                           0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF,
 556                                           0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 557                                           0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
 558                                           0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 559                                           0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F};
 560                         byte[] result1 = new byte[48];
 561                         byte[] result2 = new byte[48];
 562                         // encrypts
 563                         ICryptoTransform encryptor = des.CreateEncryptor ();
 564                         int len = encryptor.TransformBlock (input, 0, input.Length, result1, 0);
 565                         Assert.AreEqual (48, len, "enc1");
 566                         len = encryptor.TransformBlock (result1, 0, result1.Length, result2, 0);
 567                         Assert.AreEqual (48, len, "enc2");
 568                         // decrypts
 569                         des.IV = new byte[] { 0x0F, 0x93, 0x8D, 0xED, 0xE3, 0x37, 0xA3, 0x09 };
 570                         byte[] result3 = new byte[40];
 571                         ICryptoTransform decryptor = des.CreateDecryptor ();
 572                         byte[] result4 = new byte[40];
 573                         len = decryptor.TransformBlock (result2, 0, result2.Length, result3, 0);
 574                         Assert.AreEqual (40, len, "dec1");
 575                         for (int i = 0; i < 40; i++) {
 576                                 Assert.AreEqual (result1[i], result3[i], "dec1." + i);
 577                         }
 578                         len = decryptor.TransformBlock (result3, 0, len, result4, 0);
 579                         Assert.AreEqual (40, len, "dec2");
 580                         for (int i = 0; i < 8; i++) {
 581                                 Assert.AreEqual (result1[40 + i], result4[i], "dec2." + i);
 582                         }
 583                         for (int i = 8; i < 16; i++) {
 584                                 Assert.AreEqual (result2[i - 8 + 40], result4[i], "dec2." + i);
 585                         }
 586                         for (int i = 16; i < 40; i++) {
 587                                 Assert.AreEqual (input[i - 16 + 8], result4[i], "dec2." + i);
 588                         }
 589                 }
 590
 591                 [Test]
 592                 [ExpectedException (typeof (CryptographicException))]
 593                 public void EncryptEncryptDecryptDecrypt_CBC_None ()
 594                 {
 595                         EncryptEncryptDecryptDecrypt (CipherMode.CBC, PaddingMode.None);
 596                 }
 597
 598                 [Test]
 599                 public void EncryptEncryptDecryptDecrypt_CBC_PKCS7 ()
 600                 {
 601                         EncryptEncryptDecryptDecrypt (CipherMode.CBC, PaddingMode.PKCS7);
 602                 }
 603
 604                 [Test]
 605                 [ExpectedException (typeof (CryptographicException))]
 606                 public void EncryptEncryptDecryptDecrypt_CBC_Zeros ()
 607                 {
 608                         EncryptEncryptDecryptDecrypt (CipherMode.CBC, PaddingMode.Zeros);
 609                 }
 610 #if NET_2_0
 611                 [Test]
 612                 public void EncryptEncryptDecryptDecrypt_CBC_ANSIX923 ()
 613                 {
 614                         EncryptEncryptDecryptDecrypt (CipherMode.CBC, PaddingMode.ANSIX923);
 615                 }
 616
 617                 [Test]
 618                 public void EncryptEncryptDecryptDecrypt_CBC_ISO10126 ()
 619                 {
 620                         EncryptEncryptDecryptDecrypt (CipherMode.CBC, PaddingMode.ISO10126);
 621                 }
 622 #endif
 623         }
 624
 625         [TestFixture]
 626         public class RC2TransformTest: SymmetricAlgorithmTransformTest {
 627
 628                 public override SymmetricAlgorithm Algorithm {
 629                         get { return RC2.Create (); }
 630                 }
 631         }
 632
 633         [TestFixture]
 634         public class Rijndael128TransformTest: SymmetricAlgorithmTransformTest {
 635
 636                 public override SymmetricAlgorithm Algorithm {
 637                         get { return Rijndael.Create (); }
 638                 }
 639
 640                 public override int BlockSize {
 641                         get { return 16; }
 642                 }
 643         }
 644
 645         [TestFixture]
 646         public class Rijndael192TransformTest: SymmetricAlgorithmTransformTest {
 647
 648                 public override SymmetricAlgorithm Algorithm {
 649                         get {
 650                                 SymmetricAlgorithm algo = Rijndael.Create ();
 651                                 algo.BlockSize = 192;
 652                                 algo.FeedbackSize = 192;
 653                                 return algo;
 654                         }
 655                 }
 656
 657                 public override int BlockSize {
 658                         get { return 24; }
 659                 }
 660         }
 661
 662         [TestFixture]
 663         public class Rijndael256TransformTest: SymmetricAlgorithmTransformTest {
 664
 665                 public override SymmetricAlgorithm Algorithm {
 666                         get {
 667                                 SymmetricAlgorithm algo = Rijndael.Create ();
 668                                 algo.BlockSize = 256;
 669                                 algo.FeedbackSize = 256;
 670                                 return algo;
 671                         }
 672                 }
 673
 674                 public override int BlockSize {
 675                         get { return 32; }
 676                 }
 677         }
 678
 679         [TestFixture]
 680         public class TripleDESTransformTest: SymmetricAlgorithmTransformTest {
 681
 682                 public override SymmetricAlgorithm Algorithm {
 683                         get { return TripleDES.Create (); }
 684                 }
 685         }
 686 }