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

   1 //
   2 // TestSuite.System.Security.Cryptography.AsymmetricAlgorithmTest.cs
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // (C) 2004 Novell (http://www.novell.com)
   8 //
   9
  10 using System;
  11 using System.Security.Cryptography;
  12
  13 using NUnit.Framework;
  14
  15 namespace MonoTests.System.Security.Cryptography {
  16
  17         [TestFixture]
  18         public class DESTest : Assertion {
  19
  20                 static byte[] wk1 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
  21                 static byte[] wk2 = { 0x1E, 0x1E, 0x1E, 0x1E, 0x0F, 0x0F, 0x0F, 0x0F };
  22                 static byte[] wk3 = { 0xE1, 0xE1, 0xE1, 0xE1, 0xF0, 0xF0, 0xF0, 0xF0 };
  23                 static byte[] wk4 = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
  24
  25                 // parity adjusted
  26                 static byte[] wk1p = { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 };
  27                 static byte[] wk2p = { 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E };
  28                 static byte[] wk3p = { 0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1 };
  29                 static byte[] wk4p = { 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE };
  30
  31                 [Test]
  32                 public void WeakKeys_WithoutParity ()
  33                 {
  34                         Assert ("WK-1", DES.IsWeakKey (wk1));
  35                         Assert ("WK-2", DES.IsWeakKey (wk2));
  36                         Assert ("WK-3", DES.IsWeakKey (wk3));
  37                         Assert ("WK-4", DES.IsWeakKey (wk4));
  38                 }
  39
  40                 [Test]
  41                 public void WeakKeys_WithParity ()
  42                 {
  43                         Assert ("WK-1P", DES.IsWeakKey (wk1p));
  44                         Assert ("WK-2P", DES.IsWeakKey (wk2p));
  45                         Assert ("WK-3P", DES.IsWeakKey (wk3p));
  46                         Assert ("WK-4P", DES.IsWeakKey (wk4p));
  47                 }
  48
  49                 [Test]
  50                 [ExpectedException (typeof (CryptographicException))]
  51                 public void IsWeakKey_WrongKeyLength ()
  52                 {
  53                         byte[] key = new byte [16]; // 128 bits
  54                         DES.IsWeakKey (key);
  55                 }
  56
  57                 [Test]
  58                 [ExpectedException (typeof (NullReferenceException))]
  59                 public void IsWeakKey_Null ()
  60                 {
  61                         DES.IsWeakKey (null);
  62                 }
  63
  64                 static byte[] swk1   = { 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF };
  65                 static byte[] swk2   = { 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00 };
  66                 static byte[] swk3   = { 0x1E, 0xE1, 0x1E, 0xE1, 0x0F, 0xF0, 0x0F, 0xF0 };
  67                 static byte[] swk4   = { 0xE1, 0x1E, 0xE1, 0x1E, 0xF0, 0x0F, 0xF0, 0x0F };
  68                 static byte[] swk5   = { 0x00, 0xE1, 0x00, 0xE1, 0x00, 0xF0, 0x00, 0xF0 };
  69                 static byte[] swk6   = { 0xE1, 0x00, 0xE1, 0x00, 0xF0, 0x00, 0xF0, 0x00 };
  70                 static byte[] swk7   = { 0x1E, 0xFF, 0x1E, 0xFF, 0x0F, 0xFF, 0x0F, 0xFF };
  71                 static byte[] swk8   = { 0xFF, 0x1E, 0xFF, 0x1E, 0xFF, 0x0F, 0xFF, 0x0F };
  72                 static byte[] swk9   = { 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x0F, 0x00, 0x0F };
  73                 static byte[] swk10  = { 0x1E, 0x00, 0x1E, 0x00, 0x0F, 0x00, 0x0F, 0x00 };
  74                 static byte[] swk11  = { 0xE1, 0xFF, 0xE1, 0xFF, 0xF0, 0xFF, 0xF0, 0xFF };
  75                 static byte[] swk12  = { 0xFF, 0xE1, 0xFF, 0xE1, 0xFF, 0xF0, 0xFF, 0xF0 };
  76
  77                 static byte[] swk1p  = { 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE };
  78                 static byte[] swk2p  = { 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01 };
  79                 static byte[] swk3p  = { 0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1 };
  80                 static byte[] swk4p  = { 0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E };
  81                 static byte[] swk5p  = { 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1 };
  82                 static byte[] swk6p  = { 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01 };
  83                 static byte[] swk7p  = { 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE };
  84                 static byte[] swk8p  = { 0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E };
  85                 static byte[] swk9p  = { 0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E };
  86                 static byte[] swk10p = { 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01 };
  87                 static byte[] swk11p = { 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE };
  88                 static byte[] swk12p = { 0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1 };
  89
  90                 [Test]
  91                 public void SemiWeakKeys_WithoutParity ()
  92                 {
  93                         Assert ("SWK-01", DES.IsSemiWeakKey (swk1));
  94                         Assert ("SWK-02", DES.IsSemiWeakKey (swk2));
  95                         Assert ("SWK-03", DES.IsSemiWeakKey (swk3));
  96                         Assert ("SWK-04", DES.IsSemiWeakKey (swk4));
  97                         Assert ("SWK-05", DES.IsSemiWeakKey (swk5));
  98                         Assert ("SWK-06", DES.IsSemiWeakKey (swk6));
  99                         Assert ("SWK-07", DES.IsSemiWeakKey (swk7));
 100                         Assert ("SWK-08", DES.IsSemiWeakKey (swk8));
 101                         Assert ("SWK-09", DES.IsSemiWeakKey (swk9));
 102                         Assert ("SWK-10", DES.IsSemiWeakKey (swk10));
 103                         Assert ("SWK-11", DES.IsSemiWeakKey (swk11));
 104                         Assert ("SWK-12", DES.IsSemiWeakKey (swk12));
 105                 }
 106
 107                 [Test]
 108                 public void SemiWeakKeys_WithParity ()
 109                 {
 110                         Assert ("SWK-01P", DES.IsSemiWeakKey (swk1p));
 111                         Assert ("SWK-02P", DES.IsSemiWeakKey (swk2p));
 112                         Assert ("SWK-03P", DES.IsSemiWeakKey (swk3p));
 113                         Assert ("SWK-04P", DES.IsSemiWeakKey (swk4p));
 114                         Assert ("SWK-05P", DES.IsSemiWeakKey (swk5p));
 115                         Assert ("SWK-06P", DES.IsSemiWeakKey (swk6p));
 116                         Assert ("SWK-07P", DES.IsSemiWeakKey (swk7p));
 117                         Assert ("SWK-08P", DES.IsSemiWeakKey (swk8p));
 118                         Assert ("SWK-09P", DES.IsSemiWeakKey (swk9p));
 119                         Assert ("SWK-10P", DES.IsSemiWeakKey (swk10p));
 120                         Assert ("SWK-11P", DES.IsSemiWeakKey (swk11p));
 121                         Assert ("SWK-12P", DES.IsSemiWeakKey (swk12p));
 122                 }
 123
 124                 [Test]
 125                 [ExpectedException (typeof (CryptographicException))]
 126                 public void IsSemiWeakKey_WrongKeyLength ()
 127                 {
 128                         byte[] key = new byte [16]; // 128 bits
 129                         DES.IsSemiWeakKey (key);
 130                 }
 131
 132                 [Test]
 133                 [ExpectedException (typeof (NullReferenceException))]
 134                 public void IsSemiWeakKey_Null ()
 135                 {
 136                         DES.IsSemiWeakKey (null);
 137                 }
 138
 139                 [Test]
 140                 public void GetKey ()
 141                 {
 142                         DES des = DES.Create ();
 143                         byte[] key = des.Key;
 144                         AssertEquals ("64 bits", 8, key.Length);
 145
 146                         // we get a copy of the key (not the original)
 147                         string s = BitConverter.ToString (key);
 148                         des.Clear ();
 149                         AssertEquals ("Copy", s, BitConverter.ToString (key));
 150                 }
 151
 152                 [Test]
 153                 [ExpectedException (typeof (ArgumentNullException))]
 154                 public void SetKey_Null ()
 155                 {
 156                         DES des = DES.Create ();
 157                         des.Key = null;
 158                 }
 159
 160                 [Test]
 161                 [ExpectedException (typeof (ArgumentException))]
 162                 public void SetKey_WrongLength ()
 163                 {
 164                         DES des = DES.Create ();
 165                         des.Key = new byte [16]; // 128 bits
 166                 }
 167
 168                 [Test]
 169                 [ExpectedException (typeof (CryptographicException))]
 170                 public void SetKey_Weak ()
 171                 {
 172                         DES des = DES.Create ();
 173                         des.Key = wk1;
 174                 }
 175
 176                 [Test]
 177                 [ExpectedException (typeof (CryptographicException))]
 178                 public void SetKey_SemiWeak ()
 179                 {
 180                         DES des = DES.Create ();
 181                         des.Key = swk1;
 182                 }
 183         }
 184 }