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                 [Test]
  85                 public void DontDecryptLastBlock_CBC_ANSIX923 ()
  86                 {
  87                         DontDecryptLastBlock (CipherMode.CBC, PaddingMode.ANSIX923);
  88                 }
  89
  90                 [Test]
  91                 public void DontDecryptLastBlock_CBC_ISO10126 ()
  92                 {
  93                         DontDecryptLastBlock (CipherMode.CBC, PaddingMode.ISO10126);
  94                 }
  95                 [Test]
  96                 [ExpectedException (typeof (CryptographicException))]
  97                 public void DontDecryptLastBlock_CFB_None ()
  98                 {
  99                         DontDecryptLastBlock (CipherMode.CFB, PaddingMode.None);
 100                 }
 101
 102                 [Test]
 103                 public virtual void DontDecryptLastBlock_CFB_PKCS7 ()
 104                 {
 105                         DontDecryptLastBlock (CipherMode.CFB, PaddingMode.PKCS7);
 106                 }
 107
 108                 [Test]
 109                 [ExpectedException (typeof (CryptographicException))]
 110                 public void DontDecryptLastBlock_CFB_Zeros ()
 111                 {
 112                         DontDecryptLastBlock (CipherMode.CFB, PaddingMode.Zeros);
 113                 }
 114                 [Test]
 115                 public void DontDecryptLastBlock_CFB_ANSIX923 ()
 116                 {
 117                         DontDecryptLastBlock (CipherMode.CFB, PaddingMode.ANSIX923);
 118                 }
 119
 120                 [Test]
 121                 public void DontDecryptLastBlock_CFB_ISO10126 ()
 122                 {
 123                         DontDecryptLastBlock (CipherMode.CFB, PaddingMode.ISO10126);
 124                 }
 125                 [Test]
 126                 [ExpectedException (typeof (CryptographicException))]
 127                 public void DontDecryptLastBlock_ECB_None ()
 128                 {
 129                         DontDecryptLastBlock (CipherMode.ECB, PaddingMode.None);
 130                 }
 131
 132                 [Test]
 133                 public void DontDecryptLastBlock_ECB_PKCS7 ()
 134                 {
 135                         DontDecryptLastBlock (CipherMode.ECB, PaddingMode.PKCS7);
 136                 }
 137
 138                 [Test]
 139                 [ExpectedException (typeof (CryptographicException))]
 140                 public void DontDecryptLastBlock_ECB_Zeros ()
 141                 {
 142                         DontDecryptLastBlock (CipherMode.ECB, PaddingMode.Zeros);
 143                 }
 144                 [Test]
 145                 public void DontDecryptLastBlock_ECB_ANSIX923 ()
 146                 {
 147                         DontDecryptLastBlock (CipherMode.ECB, PaddingMode.ANSIX923);
 148                 }
 149
 150                 [Test]
 151                 public void DontDecryptLastBlock_ECB_ISO10126 ()
 152                 {
 153                         DontDecryptLastBlock (CipherMode.ECB, PaddingMode.ISO10126);
 154                 }
 155                 // see bug #80439 (2nd try, reopened)
 156                 // same as DontDecryptLastBlock except
 157                 // a. the encryption transform was final (padding was added)
 158                 // b. we can call/test decryption TransformFinalBlock too
 159                 public void DontDecryptLastBlock_Final (CipherMode mode, PaddingMode padding)
 160                 {
 161                         SymmetricAlgorithm algo = Algorithm;
 162                         algo.Mode = mode;
 163                         algo.Padding = padding;
 164                         ICryptoTransform enc = algo.CreateEncryptor ();
 165                         byte[] plaintext = new byte[BlockSize * 7];
 166                         byte[] encdata = enc.TransformFinalBlock (plaintext, 0, plaintext.Length);
 167                         switch (padding) {
 168                         case PaddingMode.None:
 169                         case PaddingMode.Zeros:
 170                                 Assert.AreEqual (BlockSize * 7, encdata.Length, "encdata");
 171                                 break;
 172                         default:
 173                                 Assert.AreEqual (BlockSize * 8, encdata.Length, "encdata");
 174                                 break;
 175                         }
 176
 177                         ICryptoTransform dec = algo.CreateDecryptor ();
 178                         byte[] decdata = new byte[plaintext.Length];
 179                         dec.TransformBlock (encdata, 0, encdata.Length, decdata, 0);
 180
 181                         Assert.AreEqual (plaintext, decdata, "TransformBlock." + mode.ToString ());
 182
 183                         dec = algo.CreateDecryptor ();
 184                         byte[] final = dec.TransformFinalBlock (encdata, 0, encdata.Length);
 185                         Assert.AreEqual (plaintext, final, "TransformFinalBlock." + mode.ToString ());
 186                 }
 187
 188                 [Test]
 189                 public void DontDecryptLastBlock_Final_CBC_None ()
 190                 {
 191                         DontDecryptLastBlock_Final (CipherMode.CBC, PaddingMode.None);
 192                 }
 193
 194                 [Test]
 195                 public void DontDecryptLastBlock_Final_CBC_PKCS7 ()
 196                 {
 197                         DontDecryptLastBlock_Final (CipherMode.CBC, PaddingMode.PKCS7);
 198                 }
 199
 200                 [Test]
 201                 public void DontDecryptLastBlock_Final_CBC_Zeros ()
 202                 {
 203                         DontDecryptLastBlock_Final (CipherMode.CBC, PaddingMode.Zeros);
 204                 }
 205                 [Test]
 206                 public void DontDecryptLastBlock_Final_CBC_ANSIX923 ()
 207                 {
 208                         DontDecryptLastBlock_Final (CipherMode.CBC, PaddingMode.ANSIX923);
 209                 }
 210
 211                 [Test]
 212                 public void DontDecryptLastBlock_Final_CBC_ISO10126 ()
 213                 {
 214                         DontDecryptLastBlock_Final (CipherMode.CBC, PaddingMode.ISO10126);
 215                 }
 216                 [Test]
 217                 public virtual void DontDecryptLastBlock_Final_CFB_None ()
 218                 {
 219                         DontDecryptLastBlock_Final (CipherMode.CFB, PaddingMode.None);
 220                 }
 221
 222                 [Test]
 223                 public virtual void DontDecryptLastBlock_Final_CFB_PKCS7 ()
 224                 {
 225                         DontDecryptLastBlock_Final (CipherMode.CFB, PaddingMode.PKCS7);
 226                 }
 227
 228                 [Test]
 229                 public virtual void DontDecryptLastBlock_Final_CFB_Zeros ()
 230                 {
 231                         DontDecryptLastBlock_Final (CipherMode.CFB, PaddingMode.Zeros);
 232                 }
 233                 [Test]
 234                 public void DontDecryptLastBlock_Final_CFB_ANSIX923 ()
 235                 {
 236                         DontDecryptLastBlock_Final (CipherMode.CFB, PaddingMode.ANSIX923);
 237                 }
 238
 239                 [Test]
 240                 public void DontDecryptLastBlock_Final_CFB_ISO10126 ()
 241                 {
 242                         DontDecryptLastBlock_Final (CipherMode.CFB, PaddingMode.ISO10126);
 243                 }
 244                 [Test]
 245                 public void DontDecryptLastBlock_Final_ECB_None ()
 246                 {
 247                         DontDecryptLastBlock_Final (CipherMode.ECB, PaddingMode.None);
 248                 }
 249
 250                 [Test]
 251                 public void DontDecryptLastBlock_Final_ECB_PKCS7 ()
 252                 {
 253                         DontDecryptLastBlock_Final (CipherMode.ECB, PaddingMode.PKCS7);
 254                 }
 255
 256                 [Test]
 257                 public void DontDecryptLastBlock_Final_ECB_Zeros ()
 258                 {
 259                         DontDecryptLastBlock_Final (CipherMode.ECB, PaddingMode.Zeros);
 260                 }
 261                 [Test]
 262                 public void DontDecryptLastBlock_Final_ECB_ANSIX923 ()
 263                 {
 264                         DontDecryptLastBlock_Final (CipherMode.ECB, PaddingMode.ANSIX923);
 265                 }
 266
 267                 [Test]
 268                 public void DontDecryptLastBlock_Final_ECB_ISO10126 ()
 269                 {
 270                         DontDecryptLastBlock_Final (CipherMode.ECB, PaddingMode.ISO10126);
 271                 }
 272                 // similar to previous case but here we try to skip several blocks
 273                 // i.e. encdata.Length versus decdata.Length
 274                 public void DontDecryptMultipleBlock (CipherMode mode, PaddingMode padding)
 275                 {
 276                         SymmetricAlgorithm algo = Algorithm;
 277                         algo.Mode = mode;
 278                         algo.Padding = padding;
 279                         ICryptoTransform enc = algo.CreateEncryptor ();
 280                         byte[] plaintext = new byte[BlockSize * 7];
 281                         byte[] encdata = new byte[BlockSize * 8];
 282                         int len = enc.TransformBlock (plaintext, 0, plaintext.Length, encdata, 0);
 283                         Assert.AreEqual (plaintext.Length, len, "encdata");
 284
 285                         ICryptoTransform dec = algo.CreateDecryptor ();
 286                         byte[] decdata = new byte[BlockSize];
 287                         dec.TransformBlock (encdata, 0, encdata.Length, decdata, 0);
 288                 }
 289
 290                 [Test]
 291                 [ExpectedException (typeof (CryptographicException))]
 292                 public void DontDecryptMultipleBlock_CBC_None ()
 293                 {
 294                         DontDecryptMultipleBlock (CipherMode.CBC, PaddingMode.None);
 295                 }
 296
 297                 [Test]
 298                 [ExpectedException (typeof (CryptographicException))]
 299                 public virtual void DontDecryptMultipleBlock_CBC_PKCS7 ()
 300                 {
 301                         DontDecryptMultipleBlock (CipherMode.CBC, PaddingMode.PKCS7);
 302                 }
 303
 304                 [Test]
 305                 [ExpectedException (typeof (CryptographicException))]
 306                 public void DontDecryptMultipleBlock_CBC_Zeros ()
 307                 {
 308                         DontDecryptMultipleBlock (CipherMode.CBC, PaddingMode.Zeros);
 309                 }
 310                 [Test]
 311                 [ExpectedException (typeof (CryptographicException))]
 312                 public void DontDecryptMultipleBlock_CBC_ANSIX923 ()
 313                 {
 314                         DontDecryptMultipleBlock (CipherMode.CBC, PaddingMode.ANSIX923);
 315                 }
 316
 317                 [Test]
 318                 [ExpectedException (typeof (CryptographicException))]
 319                 public void DontDecryptMultipleBlock_CBC_ISO10126 ()
 320                 {
 321                         DontDecryptMultipleBlock (CipherMode.CBC, PaddingMode.ISO10126);
 322                 }
 323                 [Test]
 324                 [ExpectedException (typeof (CryptographicException))]
 325                 public virtual void DontDecryptMultipleBlock_CFB_None ()
 326                 {
 327                         DontDecryptMultipleBlock (CipherMode.CFB, PaddingMode.None);
 328                 }
 329
 330                 [Test]
 331                 [ExpectedException (typeof (CryptographicException))]
 332                 public virtual void DontDecryptMultipleBlock_CFB_PKCS7 ()
 333                 {
 334                         DontDecryptMultipleBlock (CipherMode.CFB, PaddingMode.PKCS7);
 335                 }
 336
 337                 [Test]
 338                 [ExpectedException (typeof (CryptographicException))]
 339                 public void DontDecryptMultipleBlock_CFB_Zeros ()
 340                 {
 341                         DontDecryptMultipleBlock (CipherMode.CFB, PaddingMode.Zeros);
 342                 }
 343                 [Test]
 344                 [ExpectedException (typeof (CryptographicException))]
 345                 public void DontDecryptMultipleBlock_CFB_ANSIX923 ()
 346                 {
 347                         DontDecryptMultipleBlock (CipherMode.CFB, PaddingMode.ANSIX923);
 348                 }
 349
 350                 [Test]
 351                 [ExpectedException (typeof (CryptographicException))]
 352                 public void DontDecryptMultipleBlock_CFB_ISO10126 ()
 353                 {
 354                         DontDecryptMultipleBlock (CipherMode.CFB, PaddingMode.ISO10126);
 355                 }
 356                 [Test]
 357                 [ExpectedException (typeof (CryptographicException))]
 358                 public void DontDecryptMultipleBlock_ECB_None ()
 359                 {
 360                         DontDecryptMultipleBlock (CipherMode.ECB, PaddingMode.None);
 361                 }
 362
 363                 [Test]
 364                 [ExpectedException (typeof (CryptographicException))]
 365                 public virtual void DontDecryptMultipleBlock_ECB_PKCS7 ()
 366                 {
 367                         DontDecryptMultipleBlock (CipherMode.ECB, PaddingMode.PKCS7);
 368                 }
 369
 370                 [Test]
 371                 [ExpectedException (typeof (CryptographicException))]
 372                 public void DontDecryptMultipleBlock_ECB_Zeros ()
 373                 {
 374                         DontDecryptMultipleBlock (CipherMode.ECB, PaddingMode.Zeros);
 375                 }
 376                 [Test]
 377                 [ExpectedException (typeof (CryptographicException))]
 378                 public void DontDecryptMultipleBlock_ECB_ANSIX923 ()
 379                 {
 380                         DontDecryptMultipleBlock (CipherMode.ECB, PaddingMode.ANSIX923);
 381                 }
 382
 383                 [Test]
 384                 [ExpectedException (typeof (CryptographicException))]
 385                 public void DontDecryptMultipleBlock_ECB_ISO10126 ()
 386                 {
 387                         DontDecryptMultipleBlock (CipherMode.ECB, PaddingMode.ISO10126);
 388                 }
 389                 // similar to previous case but here the encryption transform was final
 390                 public void DontDecryptMultipleBlock_Final (CipherMode mode, PaddingMode padding)
 391                 {
 392                         SymmetricAlgorithm algo = Algorithm;
 393                         algo.Mode = mode;
 394                         algo.Padding = padding;
 395                         ICryptoTransform enc = algo.CreateEncryptor ();
 396                         byte[] plaintext = new byte[BlockSize * 7];
 397                         byte[] encdata = enc.TransformFinalBlock (plaintext, 0, plaintext.Length);
 398                         switch (padding) {
 399                         case PaddingMode.None:
 400                         case PaddingMode.Zeros:
 401                                 Assert.AreEqual (BlockSize * 7, encdata.Length, "encdata");
 402                                 break;
 403                         default:
 404                                 Assert.AreEqual (BlockSize * 8, encdata.Length, "encdata");
 405                                 break;
 406                         }
 407
 408                         ICryptoTransform dec = algo.CreateDecryptor ();
 409                         byte[] decdata = new byte[BlockSize];
 410                         dec.TransformBlock (encdata, 0, encdata.Length, decdata, 0);
 411                 }
 412
 413                 [Test]
 414                 [ExpectedException (typeof (CryptographicException))]
 415                 public void DontDecryptMultipleBlock_Final_CBC_None ()
 416                 {
 417                         DontDecryptMultipleBlock_Final (CipherMode.CBC, PaddingMode.None);
 418                 }
 419
 420                 [Test]
 421                 [ExpectedException (typeof (CryptographicException))]
 422                 public virtual void DontDecryptMultipleBlock_Final_CBC_PKCS7 ()
 423                 {
 424                         DontDecryptMultipleBlock_Final (CipherMode.CBC, PaddingMode.PKCS7);
 425                 }
 426
 427                 [Test]
 428                 [ExpectedException (typeof (CryptographicException))]
 429                 public void DontDecryptMultipleBlock_Final_CBC_Zeros ()
 430                 {
 431                         DontDecryptMultipleBlock_Final (CipherMode.CBC, PaddingMode.Zeros);
 432                 }
 433                 [Test]
 434                 [ExpectedException (typeof (CryptographicException))]
 435                 public void DontDecryptMultipleBlock_Final_CBC_ANSIX923 ()
 436                 {
 437                         DontDecryptMultipleBlock_Final (CipherMode.CBC, PaddingMode.ANSIX923);
 438                 }
 439
 440                 [Test]
 441                 [ExpectedException (typeof (CryptographicException))]
 442                 public void DontDecryptMultipleBlock_Final_CBC_ISO10126 ()
 443                 {
 444                         DontDecryptMultipleBlock_Final (CipherMode.CBC, PaddingMode.ISO10126);
 445                 }
 446                 [Test]
 447                 [ExpectedException (typeof (CryptographicException))]
 448                 public virtual void DontDecryptMultipleBlock_Final_CFB_None ()
 449                 {
 450                         DontDecryptMultipleBlock_Final (CipherMode.CFB, PaddingMode.None);
 451                 }
 452
 453                 [Test]
 454                 [ExpectedException (typeof (CryptographicException))]
 455                 public virtual void DontDecryptMultipleBlock_Final_CFB_PKCS7 ()
 456                 {
 457                         DontDecryptMultipleBlock_Final (CipherMode.CFB, PaddingMode.PKCS7);
 458                 }
 459
 460                 [Test]
 461                 [ExpectedException (typeof (CryptographicException))]
 462                 public void DontDecryptMultipleBlock_Final_CFB_Zeros ()
 463                 {
 464                         DontDecryptMultipleBlock_Final (CipherMode.CFB, PaddingMode.Zeros);
 465                 }
 466                 [Test]
 467                 [ExpectedException (typeof (CryptographicException))]
 468                 public void DontDecryptMultipleBlock_Final_CFB_ANSIX923 ()
 469                 {
 470                         DontDecryptMultipleBlock_Final (CipherMode.CFB, PaddingMode.ANSIX923);
 471                 }
 472
 473                 [Test]
 474                 [ExpectedException (typeof (CryptographicException))]
 475                 public void DontDecryptMultipleBlock_Final_CFB_ISO10126 ()
 476                 {
 477                         DontDecryptMultipleBlock_Final (CipherMode.CFB, PaddingMode.ISO10126);
 478                 }
 479                 [Test]
 480                 [ExpectedException (typeof (CryptographicException))]
 481                 public void DontDecryptMultipleBlock_Final_ECB_None ()
 482                 {
 483                         DontDecryptMultipleBlock_Final (CipherMode.ECB, PaddingMode.None);
 484                 }
 485
 486                 [Test]
 487                 [ExpectedException (typeof (CryptographicException))]
 488                 public virtual void DontDecryptMultipleBlock_Final_ECB_PKCS7 ()
 489                 {
 490                         DontDecryptMultipleBlock_Final (CipherMode.ECB, PaddingMode.PKCS7);
 491                 }
 492
 493                 [Test]
 494                 [ExpectedException (typeof (CryptographicException))]
 495                 public void DontDecryptMultipleBlock_Final_ECB_Zeros ()
 496                 {
 497                         DontDecryptMultipleBlock_Final (CipherMode.ECB, PaddingMode.Zeros);
 498                 }
 499                 [Test]
 500                 [ExpectedException (typeof (CryptographicException))]
 501                 public void DontDecryptMultipleBlock_Final_ECB_ANSIX923 ()
 502                 {
 503                         DontDecryptMultipleBlock_Final (CipherMode.ECB, PaddingMode.ANSIX923);
 504                 }
 505
 506                 [Test]
 507                 [ExpectedException (typeof (CryptographicException))]
 508                 public void DontDecryptMultipleBlock_Final_ECB_ISO10126 ()
 509                 {
 510                         DontDecryptMultipleBlock_Final (CipherMode.ECB, PaddingMode.ISO10126);
 511                 }
 512
 513                 private void TransformBlock_One (ICryptoTransform ct, int expected)
 514                 {
 515                         byte[] data = new byte[ct.InputBlockSize];
 516                         Assert.AreEqual (expected, ct.TransformBlock (data, 0, ct.InputBlockSize, data, 0));
 517                 }
 518
 519                 public void Encryptor_TransformBlock_One (PaddingMode padding, CipherMode mode, int expected)
 520                 {
 521                         SymmetricAlgorithm sa = Algorithm;
 522                         sa.Padding = padding;
 523                         sa.Mode = mode;
 524                         TransformBlock_One (sa.CreateEncryptor (), expected);
 525                 }
 526
 527                 [Test]
 528                 public void CreateEncryptor_TransformBlock_One_PKCS7_ECB ()
 529                 {
 530                         Encryptor_TransformBlock_One (PaddingMode.PKCS7, CipherMode.ECB, BlockSize);
 531                 }
 532
 533                 [Test]
 534                 public void CreateEncryptor_TransformBlock_One_PKCS7_CBC ()
 535                 {
 536                         Encryptor_TransformBlock_One (PaddingMode.PKCS7, CipherMode.CBC, BlockSize);
 537                 }
 538
 539                 [Test]
 540                 public virtual void CreateEncryptor_TransformBlock_One_PKCS7_CFB ()
 541                 {
 542                         Encryptor_TransformBlock_One (PaddingMode.PKCS7, CipherMode.CFB, BlockSize);
 543                 }
 544
 545                 [Test]
 546                 public void CreateEncryptor_TransformBlock_One_Zeros_ECB ()
 547                 {
 548                         Encryptor_TransformBlock_One (PaddingMode.Zeros, CipherMode.ECB, BlockSize);
 549                 }
 550
 551                 [Test]
 552                 public void CreateEncryptor_TransformBlock_One_Zeros_CBC ()
 553                 {
 554                         Encryptor_TransformBlock_One (PaddingMode.Zeros, CipherMode.CBC, BlockSize);
 555                 }
 556
 557                 [Test]
 558                 public virtual void CreateEncryptor_TransformBlock_One_Zeros_CFB ()
 559                 {
 560                         Encryptor_TransformBlock_One (PaddingMode.Zeros, CipherMode.CFB, BlockSize);
 561                 }
 562
 563                 [Test]
 564                 public void CreateEncryptor_TransformBlock_One_None_ECB ()
 565                 {
 566                         Encryptor_TransformBlock_One (PaddingMode.None, CipherMode.ECB, BlockSize);
 567                 }
 568
 569                 [Test]
 570                 public void CreateEncryptor_TransformBlock_One_None_CBC ()
 571                 {
 572                         Encryptor_TransformBlock_One (PaddingMode.None, CipherMode.CBC, BlockSize);
 573                 }
 574
 575                 [Test]
 576                 public virtual void CreateEncryptor_TransformBlock_One_None_CFB ()
 577                 {
 578                         Encryptor_TransformBlock_One (PaddingMode.None, CipherMode.CFB, BlockSize);
 579                 }
 580
 581                 [Test]
 582                 public void CreateEncryptor_TransformBlock_One_ANSIX923_ECB ()
 583                 {
 584                         Encryptor_TransformBlock_One (PaddingMode.ANSIX923, CipherMode.ECB, BlockSize);
 585                 }
 586
 587                 [Test]
 588                 public void CreateEncryptor_TransformBlock_One_ANSIX923_CBC ()
 589                 {
 590                         Encryptor_TransformBlock_One (PaddingMode.ANSIX923, CipherMode.CBC, BlockSize);
 591                 }
 592
 593                 [Test]
 594                 public void CreateEncryptor_TransformBlock_One_ANSIX923_CFB ()
 595                 {
 596                         Encryptor_TransformBlock_One (PaddingMode.ANSIX923, CipherMode.CFB, BlockSize);
 597                 }
 598
 599                 [Test]
 600                 public void CreateEncryptor_TransformBlock_One_ISO10126_ECB ()
 601                 {
 602                         Encryptor_TransformBlock_One (PaddingMode.ISO10126, CipherMode.ECB, BlockSize);
 603                 }
 604
 605                 [Test]
 606                 public void CreateEncryptor_TransformBlock_One_ISO10126_CBC ()
 607                 {
 608                         Encryptor_TransformBlock_One (PaddingMode.ISO10126, CipherMode.CBC, BlockSize);
 609                 }
 610
 611                 [Test]
 612                 public void CreateEncryptor_TransformBlock_One_ISO10126_CFB ()
 613                 {
 614                         Encryptor_TransformBlock_One (PaddingMode.ISO10126, CipherMode.CFB, BlockSize);
 615                 }
 616
 617                 public void Decryptor_TransformBlock_One (PaddingMode padding, CipherMode mode, int expected)
 618                 {
 619                         SymmetricAlgorithm sa = Algorithm;
 620                         sa.Padding = padding;
 621                         sa.Mode = mode;
 622                         TransformBlock_One (sa.CreateDecryptor (), expected);
 623                 }
 624
 625                 [Test]
 626                 public void CreateDecryptor_TransformBlock_One_PKCS7_ECB ()
 627                 {
 628                         Decryptor_TransformBlock_One (PaddingMode.PKCS7, CipherMode.ECB, 0);
 629                 }
 630
 631                 [Test]
 632                 public void CreateDecryptor_TransformBlock_One_PKCS7_CBC ()
 633                 {
 634                         Decryptor_TransformBlock_One (PaddingMode.PKCS7, CipherMode.CBC, 0);
 635                 }
 636
 637                 [Test]
 638                 public virtual void CreateDecryptor_TransformBlock_One_PKCS7_CFB ()
 639                 {
 640                         Decryptor_TransformBlock_One (PaddingMode.PKCS7, CipherMode.CFB, 0);
 641                 }
 642
 643                 [Test]
 644                 public void CreateDecryptor_TransformBlock_One_Zeros_ECB ()
 645                 {
 646                         Decryptor_TransformBlock_One (PaddingMode.Zeros, CipherMode.ECB, BlockSize);
 647                 }
 648
 649                 [Test]
 650                 public void CreateDecryptor_TransformBlock_One_Zeros_CBC ()
 651                 {
 652                         Decryptor_TransformBlock_One (PaddingMode.Zeros, CipherMode.CBC, BlockSize);
 653                 }
 654
 655                 [Test]
 656                 public virtual void CreateDecryptor_TransformBlock_One_Zeros_CFB ()
 657                 {
 658                         Decryptor_TransformBlock_One (PaddingMode.Zeros, CipherMode.CFB, BlockSize);
 659                 }
 660
 661                 [Test]
 662                 public void CreateDecryptor_TransformBlock_One_None_ECB ()
 663                 {
 664                         Decryptor_TransformBlock_One (PaddingMode.None, CipherMode.ECB, BlockSize);
 665                 }
 666
 667                 [Test]
 668                 public void CreateDecryptor_TransformBlock_One_None_CBC ()
 669                 {
 670                         Decryptor_TransformBlock_One (PaddingMode.None, CipherMode.CBC, BlockSize);
 671                 }
 672
 673                 [Test]
 674                 public virtual void CreateDecryptor_TransformBlock_One_None_CFB ()
 675                 {
 676                         Decryptor_TransformBlock_One (PaddingMode.None, CipherMode.CFB, BlockSize);
 677                 }
 678                 [Test]
 679                 public void CreateDecryptor_TransformBlock_One_ANSIX923_ECB ()
 680                 {
 681                         Decryptor_TransformBlock_One (PaddingMode.ANSIX923, CipherMode.ECB, 0);
 682                 }
 683
 684                 [Test]
 685                 public void CreateDecryptor_TransformBlock_One_ANSIX923_CBC ()
 686                 {
 687                         Decryptor_TransformBlock_One (PaddingMode.ANSIX923, CipherMode.CBC, 0);
 688                 }
 689
 690                 [Test]
 691                 public void CreateDecryptor_TransformBlock_One_ANSIX923_CFB ()
 692                 {
 693                         Decryptor_TransformBlock_One (PaddingMode.ANSIX923, CipherMode.CFB, 0);
 694                 }
 695
 696                 [Test]
 697                 public void CreateDecryptor_TransformBlock_One_ISO10126_ECB ()
 698                 {
 699                         Decryptor_TransformBlock_One (PaddingMode.ISO10126, CipherMode.ECB, 0);
 700                 }
 701
 702                 [Test]
 703                 public void CreateDecryptor_TransformBlock_One_ISO10126_CBC ()
 704                 {
 705                         Decryptor_TransformBlock_One (PaddingMode.ISO10126, CipherMode.CBC, 0);
 706                 }
 707
 708                 [Test]
 709                 public void CreateDecryptor_TransformBlock_One_ISO10126_CFB ()
 710                 {
 711                         Decryptor_TransformBlock_One (PaddingMode.ISO10126, CipherMode.CFB, 0);
 712                 }
 713         }
 714
 715         [TestFixture]
 716         public class DESTransformTest: SymmetricAlgorithmTransformTest {
 717
 718                 public override SymmetricAlgorithm Algorithm {
 719                         get { return DES.Create (); }
 720                 }
 721
 722                 // from Lauren Bedoule
 723                 // note: this test case works only for CBC
 724                 private void EncryptEncryptDecryptDecrypt (CipherMode mode, PaddingMode padding)
 725                 {
 726                         SymmetricAlgorithm des = Algorithm;
 727                         des.Mode = mode;
 728                         des.Padding = padding;
 729                         des.IV = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 };
 730                         des.Key = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 };
 731                         byte[] input = new byte[48] { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
 732                                           0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF,
 733                                           0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 734                                           0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
 735                                           0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 736                                           0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F};
 737                         byte[] result1 = new byte[48];
 738                         byte[] result2 = new byte[48];
 739                         // encrypts
 740                         ICryptoTransform encryptor = des.CreateEncryptor ();
 741                         int len = encryptor.TransformBlock (input, 0, input.Length, result1, 0);
 742                         Assert.AreEqual (48, len, "enc1");
 743                         len = encryptor.TransformBlock (result1, 0, result1.Length, result2, 0);
 744                         Assert.AreEqual (48, len, "enc2");
 745                         // decrypts
 746                         des.IV = new byte[] { 0x0F, 0x93, 0x8D, 0xED, 0xE3, 0x37, 0xA3, 0x09 };
 747                         byte[] result3 = new byte[40];
 748                         ICryptoTransform decryptor = des.CreateDecryptor ();
 749                         byte[] result4 = new byte[40];
 750                         len = decryptor.TransformBlock (result2, 0, result2.Length, result3, 0);
 751                         Assert.AreEqual (40, len, "dec1");
 752                         for (int i = 0; i < 40; i++) {
 753                                 Assert.AreEqual (result1[i], result3[i], "dec1." + i);
 754                         }
 755                         len = decryptor.TransformBlock (result3, 0, len, result4, 0);
 756                         Assert.AreEqual (40, len, "dec2");
 757                         for (int i = 0; i < 8; i++) {
 758                                 Assert.AreEqual (result1[40 + i], result4[i], "dec2." + i);
 759                         }
 760                         for (int i = 8; i < 16; i++) {
 761                                 Assert.AreEqual (result2[i - 8 + 40], result4[i], "dec2." + i);
 762                         }
 763                         for (int i = 16; i < 40; i++) {
 764                                 Assert.AreEqual (input[i - 16 + 8], result4[i], "dec2." + i);
 765                         }
 766                 }
 767
 768                 [Test]
 769                 [ExpectedException (typeof (CryptographicException))]
 770                 public void EncryptEncryptDecryptDecrypt_CBC_None ()
 771                 {
 772                         EncryptEncryptDecryptDecrypt (CipherMode.CBC, PaddingMode.None);
 773                 }
 774
 775                 [Test]
 776                 public void EncryptEncryptDecryptDecrypt_CBC_PKCS7 ()
 777                 {
 778                         EncryptEncryptDecryptDecrypt (CipherMode.CBC, PaddingMode.PKCS7);
 779                 }
 780
 781                 [Test]
 782                 [ExpectedException (typeof (CryptographicException))]
 783                 public void EncryptEncryptDecryptDecrypt_CBC_Zeros ()
 784                 {
 785                         EncryptEncryptDecryptDecrypt (CipherMode.CBC, PaddingMode.Zeros);
 786                 }
 787                 [Test]
 788                 public void EncryptEncryptDecryptDecrypt_CBC_ANSIX923 ()
 789                 {
 790                         EncryptEncryptDecryptDecrypt (CipherMode.CBC, PaddingMode.ANSIX923);
 791                 }
 792
 793                 [Test]
 794                 public void EncryptEncryptDecryptDecrypt_CBC_ISO10126 ()
 795                 {
 796                         EncryptEncryptDecryptDecrypt (CipherMode.CBC, PaddingMode.ISO10126);
 797                 }
 798         }
 799
 800         [TestFixture]
 801         public class RC2TransformTest: SymmetricAlgorithmTransformTest {
 802
 803                 public override SymmetricAlgorithm Algorithm {
 804                         get { return RC2.Create (); }
 805                 }
 806         }
 807
 808         public abstract class RijndaelTransformTest: SymmetricAlgorithmTransformTest {
 809
 810                 // Rijndael is the only managed crypto transform implementation and, before Fx 2.0,
 811                 // suffers from different issues than CSP-based CryptoAPITransform. In contrast
 812                 // Mono has a single (managed) implementation for all crypto transforms.
 813 #if ONLY_1_1
 814                 // The first case is that MS reports that OFB (output feedback) mode isn't
 815                 // supported even if this isn't the requested mode (CFB). We ignore those cases
 816                 // to (a) don't mess with existing Mono-only code and (b) it's the 2.0 behavior
 817                 // anyway.
 818
 819                 [Test]
 820                 [Category ("NotWorking")]
 821                 [ExpectedException (typeof (CryptographicException))]
 822                 public override void DontDecryptLastBlock_CFB_PKCS7 ()
 823                 {
 824                         DontDecryptLastBlock (CipherMode.CFB, PaddingMode.PKCS7);
 825                 }
 826
 827                 [Test]
 828                 [Category ("NotWorking")]
 829                 [ExpectedException (typeof (CryptographicException))]
 830                 public override void DontDecryptLastBlock_Final_CFB_PKCS7 ()
 831                 {
 832                         DontDecryptLastBlock_Final (CipherMode.CFB, PaddingMode.PKCS7);
 833                 }
 834
 835                 [Test]
 836                 [Category ("NotWorking")]
 837                 [ExpectedException (typeof (CryptographicException))]
 838                 public override void DontDecryptLastBlock_Final_CFB_None ()
 839                 {
 840                         DontDecryptLastBlock_Final (CipherMode.CFB, PaddingMode.None);
 841                 }
 842
 843                 [Test]
 844                 [Category ("NotWorking")]
 845                 [ExpectedException (typeof (CryptographicException))]
 846                 public override void DontDecryptLastBlock_Final_CFB_Zeros ()
 847                 {
 848                         DontDecryptLastBlock_Final (CipherMode.CFB, PaddingMode.Zeros);
 849                 }
 850
 851                 [Test]
 852                 [Category ("NotWorking")]
 853                 [ExpectedException (typeof (CryptographicException))]
 854                 public override void CreateEncryptor_TransformBlock_One_PKCS7_CFB ()
 855                 {
 856                         Encryptor_TransformBlock_One (PaddingMode.PKCS7, CipherMode.CFB, BlockSize);
 857                 }
 858
 859                 [Test]
 860                 [Category ("NotWorking")]
 861                 [ExpectedException (typeof (CryptographicException))]
 862                 public override void CreateEncryptor_TransformBlock_One_Zeros_CFB ()
 863                 {
 864                         Encryptor_TransformBlock_One (PaddingMode.Zeros, CipherMode.CFB, BlockSize);
 865                 }
 866
 867                 [Test]
 868                 [Category ("NotWorking")]
 869                 [ExpectedException (typeof (CryptographicException))]
 870                 public override void CreateEncryptor_TransformBlock_One_None_CFB ()
 871                 {
 872                         Encryptor_TransformBlock_One (PaddingMode.None, CipherMode.CFB, BlockSize);
 873                 }
 874
 875                 [Test]
 876                 [Category ("NotWorking")]
 877                 [ExpectedException (typeof (CryptographicException))]
 878                 public override void CreateDecryptor_TransformBlock_One_PKCS7_CFB ()
 879                 {
 880                         Decryptor_TransformBlock_One (PaddingMode.PKCS7, CipherMode.CFB, BlockSize);
 881                 }
 882
 883                 [Test]
 884                 [Category ("NotWorking")]
 885                 [ExpectedException (typeof (CryptographicException))]
 886                 public override void CreateDecryptor_TransformBlock_One_Zeros_CFB ()
 887                 {
 888                         Decryptor_TransformBlock_One (PaddingMode.Zeros, CipherMode.CFB, BlockSize);
 889                 }
 890
 891                 [Test]
 892                 [Category ("NotWorking")]
 893                 [ExpectedException (typeof (CryptographicException))]
 894                 public override void CreateDecryptor_TransformBlock_One_None_CFB ()
 895                 {
 896                         Decryptor_TransformBlock_One (PaddingMode.None, CipherMode.CFB, BlockSize);
 897                 }
 898
 899                 // The second case is that the MS managed transform (Rijndael) throws a CryptographicException
 900                 // (like 2.0) where the unmanaged one (CryptoAPITransform) throws an IndexOutOfRangeException.
 901                 // Since Mono has a single implementation we're ignoring this "special" case (wrong exception)
 902                 // in favor of the most "used" one. Note that it doesn't much affect existing code.
 903
 904                 [Test]
 905                 [Category ("NotWorking")]
 906                 [ExpectedException (typeof (CryptographicException))]
 907                 public override void DontDecryptMultipleBlock_CBC_PKCS7 ()
 908                 {
 909                         DontDecryptMultipleBlock (CipherMode.CBC, PaddingMode.PKCS7);
 910                 }
 911
 912                 [Test]
 913                 [Category ("NotWorking")]
 914                 [ExpectedException (typeof (CryptographicException))]
 915                 public override void DontDecryptMultipleBlock_CFB_PKCS7 ()
 916                 {
 917                         DontDecryptMultipleBlock (CipherMode.CFB, PaddingMode.PKCS7);
 918                 }
 919
 920                 [Test]
 921                 [Category ("NotWorking")]
 922                 [ExpectedException (typeof (CryptographicException))]
 923                 public override void DontDecryptMultipleBlock_ECB_PKCS7 ()
 924                 {
 925                         DontDecryptMultipleBlock (CipherMode.ECB, PaddingMode.PKCS7);
 926                 }
 927
 928                 [Test]
 929                 [Category ("NotWorking")]
 930                 [ExpectedException (typeof (CryptographicException))]
 931                 public override void DontDecryptMultipleBlock_Final_CBC_PKCS7 ()
 932                 {
 933                         DontDecryptMultipleBlock_Final (CipherMode.CBC, PaddingMode.PKCS7);
 934                 }
 935
 936                 [Test]
 937                 [Category ("NotWorking")]
 938                 [ExpectedException (typeof (CryptographicException))]
 939                 public override void DontDecryptMultipleBlock_Final_CFB_PKCS7 ()
 940                 {
 941                         DontDecryptMultipleBlock_Final (CipherMode.CFB, PaddingMode.PKCS7);
 942                 }
 943
 944                 [Test]
 945                 [Category ("NotWorking")]
 946                 [ExpectedException (typeof (CryptographicException))]
 947                 public override void DontDecryptMultipleBlock_Final_ECB_PKCS7 ()
 948                 {
 949                         DontDecryptMultipleBlock_Final (CipherMode.ECB, PaddingMode.PKCS7);
 950                 }
 951 #endif
 952         }
 953
 954         [TestFixture]
 955         public class Rijndael128TransformTest: RijndaelTransformTest {
 956
 957                 public override SymmetricAlgorithm Algorithm {
 958                         get { return Rijndael.Create (); }
 959                 }
 960
 961                 public override int BlockSize {
 962                         get { return 16; }
 963                 }
 964         }
 965
 966         [TestFixture]
 967         public class Rijndael192TransformTest: RijndaelTransformTest {
 968
 969                 public override SymmetricAlgorithm Algorithm {
 970                         get {
 971                                 SymmetricAlgorithm algo = Rijndael.Create ();
 972                                 algo.BlockSize = 192;
 973                                 algo.FeedbackSize = 192;
 974                                 return algo;
 975                         }
 976                 }
 977
 978                 public override int BlockSize {
 979                         get { return 24; }
 980                 }
 981         }
 982
 983         [TestFixture]
 984         public class Rijndael256TransformTest: RijndaelTransformTest {
 985
 986                 public override SymmetricAlgorithm Algorithm {
 987                         get {
 988                                 SymmetricAlgorithm algo = Rijndael.Create ();
 989                                 algo.BlockSize = 256;
 990                                 algo.FeedbackSize = 256;
 991                                 return algo;
 992                         }
 993                 }
 994
 995                 public override int BlockSize {
 996                         get { return 32; }
 997                 }
 998         }
 999
1000         [TestFixture]
1001         public class TripleDESTransformTest: SymmetricAlgorithmTransformTest {
1002
1003                 public override SymmetricAlgorithm Algorithm {
1004                         get { return TripleDES.Create (); }
1005                 }
1006         }
1007 }