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

   1 //
   2 // SHA1Test.cs - NUnit Test Cases for SHA1
   3 //
   4 // Author:
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // (C) 2002 Motus Technologies Inc. (http://www.motus.com)
   8 // (C) 2004 Novell  http://www.novell.com
   9 //
  10
  11 using NUnit.Framework;
  12 using System;
  13 using System.IO;
  14 using System.Security.Cryptography;
  15 using System.Text;
  16
  17 namespace MonoTests.System.Security.Cryptography
  18 {
  19
  20 // References:
  21 // a.   FIPS PUB 180-1: Secure Hash Standard
  22 //      http://csrc.nist.gov/publications/fips/fips180-1/fip180-1.txt
  23
  24 // SHA1 is a abstract class - so most of the test included here wont be tested
  25 // on the abstract class but should be tested in ALL its descendants.
  26
  27 [TestFixture]
  28 public class SHA1Test : HashAlgorithmTest {
  29
  30         [SetUp]
  31         protected override void SetUp ()
  32         {
  33                 hash = SHA1.Create ();
  34         }
  35
  36         public new void AssertEquals (string msg, byte[] array1, byte[] array2)
  37         {
  38                 AllTests.AssertEquals (msg, array1, array2);
  39         }
  40
  41         // test vectors from NIST FIPS 186-2
  42
  43         private string input1 = "abc";
  44         private string input2 = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
  45
  46         public void FIPS186_Test1 (SHA1 hash)
  47         {
  48                 string className = hash.ToString ();
  49                 byte[] result = { 0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81, 0x6a, 0xba, 0x3e, 0x25, 0x71, 0x78, 0x50, 0xc2, 0x6c, 0x9c, 0xd0, 0xd8, 0x9d };
  50                 byte[] input = Encoding.Default.GetBytes (input1);
  51
  52                 string testName = className + " 1";
  53                 FIPS186_a (testName, hash, input, result);
  54                 FIPS186_b (testName, hash, input, result);
  55                 FIPS186_c (testName, hash, input, result);
  56                 FIPS186_d (testName, hash, input, result);
  57                 FIPS186_e (testName, hash, input, result);
  58         }
  59
  60         public void FIPS186_Test2 (SHA1 hash)
  61         {
  62                 string className = hash.ToString ();
  63                 byte[] result = { 0x84, 0x98, 0x3e, 0x44, 0x1c, 0x3b, 0xd2, 0x6e, 0xba, 0xae, 0x4a, 0xa1, 0xf9, 0x51, 0x29, 0xe5, 0xe5, 0x46, 0x70, 0xf1 };
  64                 byte[] input = Encoding.Default.GetBytes (input2);
  65
  66                 string testName = className + " 2";
  67                 FIPS186_a (testName, hash, input, result);
  68                 FIPS186_b (testName, hash, input, result);
  69                 FIPS186_c (testName, hash, input, result);
  70                 FIPS186_d (testName, hash, input, result);
  71                 FIPS186_e (testName, hash, input, result);
  72         }
  73
  74         public void FIPS186_Test3 (SHA1 hash)
  75         {
  76                 string className = hash.ToString ();
  77                 byte[] result = { 0x34, 0xaa, 0x97, 0x3c, 0xd4, 0xc4, 0xda, 0xa4, 0xf6, 0x1e, 0xeb, 0x2b, 0xdb, 0xad, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6f };
  78                 byte[] input = new byte [1000000];
  79                 for (int i = 0; i < 1000000; i++)
  80                         input[i] = 0x61; // a
  81
  82                 string testName = className + " 3";
  83                 FIPS186_a (testName, hash, input, result);
  84                 FIPS186_b (testName, hash, input, result);
  85                 FIPS186_c (testName, hash, input, result);
  86                 FIPS186_d (testName, hash, input, result);
  87                 FIPS186_e (testName, hash, input, result);
  88         }
  89
  90         public void FIPS186_a (string testName, SHA1 hash, byte[] input, byte[] result)
  91         {
  92                 byte[] output = hash.ComputeHash (input);
  93                 AssertEquals (testName + ".a.1", result, output);
  94                 AssertEquals (testName + ".a.2", result, hash.Hash);
  95                 // required or next operation will still return old hash
  96                 hash.Initialize ();
  97         }
  98
  99         public void FIPS186_b (string testName, SHA1 hash, byte[] input, byte[] result)
 100         {
 101                 byte[] output = hash.ComputeHash (input, 0, input.Length);
 102                 AssertEquals (testName + ".b.1", result, output);
 103                 AssertEquals (testName + ".b.2", result, hash.Hash);
 104                 // required or next operation will still return old hash
 105                 hash.Initialize ();
 106         }
 107
 108         public void FIPS186_c (string testName, SHA1 hash, byte[] input, byte[] result)
 109         {
 110                 MemoryStream ms = new MemoryStream (input);
 111                 byte[] output = hash.ComputeHash (ms);
 112                 AssertEquals (testName + ".c.1", result, output);
 113                 AssertEquals (testName + ".c.2", result, hash.Hash);
 114                 // required or next operation will still return old hash
 115                 hash.Initialize ();
 116         }
 117
 118         public void FIPS186_d (string testName, SHA1 hash, byte[] input, byte[] result)
 119         {
 120                 byte[] output = hash.TransformFinalBlock (input, 0, input.Length);
 121                 // LAMESPEC or FIXME: TransformFinalBlock doesn't return HashValue !
 122                 // AssertEquals( testName + ".d.1", result, output );
 123                 AssertEquals (testName + ".d", result, hash.Hash);
 124                 // required or next operation will still return old hash
 125                 hash.Initialize ();
 126         }
 127
 128         public void FIPS186_e (string testName, SHA1 hash, byte[] input, byte[] result)
 129         {
 130                 byte[] copy = new byte [input.Length];
 131                 for (int i=0; i < input.Length - 1; i++)
 132                         hash.TransformBlock (input, i, 1, copy, i);
 133                 byte[] output = hash.TransformFinalBlock (input, input.Length - 1, 1);
 134                 // LAMESPEC or FIXME: TransformFinalBlock doesn't return HashValue !
 135                 // AssertEquals (testName + ".e.1", result, output);
 136                 AssertEquals (testName + ".e", result, hash.Hash);
 137                 // required or next operation will still return old hash
 138                 hash.Initialize ();
 139         }
 140
 141         [Test]
 142         public override void Create ()
 143         {
 144                 // Note: These tests will only be valid without a "machine.config" file
 145                 // or a "machine.config" file that do not modify the default algorithm
 146                 // configuration.
 147                 const string defaultSHA1 = "System.Security.Cryptography.SHA1CryptoServiceProvider";
 148
 149                 // try to build the default implementation
 150                 SHA1 hash = SHA1.Create ();
 151                 AssertEquals ("SHA1.Create()", hash.ToString (), defaultSHA1);
 152
 153                 // try to build, in every way, a SHA1 implementation
 154                 // note that it's not possible to create an instance of SHA1Managed using the Create methods
 155                 hash = SHA1.Create ("SHA");
 156                 AssertEquals ("SHA1.Create('SHA')", hash.ToString (), defaultSHA1);
 157                 hash = SHA1.Create ("SHA1");
 158                 AssertEquals ("SHA1.Create('SHA1')", hash.ToString (), defaultSHA1);
 159                 hash = SHA1.Create ("System.Security.Cryptography.SHA1");
 160                 AssertEquals ("SHA1.Create('System.Security.Cryptography.SHA1')", hash.ToString (), defaultSHA1);
 161                 hash = SHA1.Create ("System.Security.Cryptography.HashAlgorithm" );
 162                 AssertEquals ("SHA1.Create('System.Security.Cryptography.HashAlgorithm')", hash.ToString (), defaultSHA1);
 163         }
 164
 165         [Test]
 166         [ExpectedException (typeof (InvalidCastException))]
 167         public void CreateIncorrect ()
 168         {
 169                 // try to build an incorrect (existing) hash algorithms
 170                 hash = SHA1.Create ("MD5");
 171         }
 172
 173         [Test]
 174         public void CreateUnknown ()
 175         {
 176                 // try to build invalid (unexisting) implementation
 177                 hash = SHA1.Create ("InvalidHash");
 178                 AssertNull ("SHA1.Create('InvalidHash')", hash);
 179         }
 180
 181         [Test]
 182         [ExpectedException (typeof (ArgumentNullException))]
 183         public override void CreateNull ()
 184         {
 185                 // try to build null implementation
 186                 hash = SHA1.Create (null);
 187         }
 188
 189         // none of those values changes for any implementation of SHA1
 190         [Test]
 191         public virtual void StaticInfo ()
 192         {
 193                 string className = hash.ToString ();
 194                 AssertEquals (className + ".HashSize", 160, hash.HashSize);
 195                 AssertEquals (className + ".InputBlockSize", 1, hash.InputBlockSize);
 196                 AssertEquals (className + ".OutputBlockSize", 1, hash.OutputBlockSize);
 197         }
 198 }
 199
 200 }